#  Hydrogram - Telegram MTProto API Client Library for Python
#  Copyright (C) 2023-present Hydrogram <https://hydrogram.org>
#
#  This file is part of Hydrogram.
#
#  Hydrogram is free software: you can redistribute it and/or modify
#  it under the terms of the GNU Lesser General Public License as published
#  by the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  Hydrogram is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU Lesser General Public License for more details.
#
#  You should have received a copy of the GNU Lesser General Public License
#  along with Hydrogram.  If not, see <http://www.gnu.org/licenses/>.

# methods/__init__.py
class Methods(
    Advanced, Auth, Bots, Contacts, Password, Chats,
    Users, Messages, Pyromod, Decorators, Utilities, InviteLinks, Phone
):
    pass

# client.py
class Client(Methods):
    """Main client class, inherits all methods"""

class Object:
    def __init__(self, client: "hydrogram.Client" = None):
        self._client = client

    def bind(self, client: "hydrogram.Client"):
        """Bind client to this and nested objects"""

    def __str__(self) -> str:  # JSON serialization
    def __repr__(self) -> str:  # Python repr
    def __eq__(self, other) -> bool:  # Deep equality

from __future__ import annotations

from typing import TYPE_CHECKING

import hydrogram
from hydrogram import enums, raw, types, utils

if TYPE_CHECKING:
    from datetime import datetime


class SendMessage:  # Class name in PascalCase matching method name
    async def send_message(
        self: hydrogram.Client,
        chat_id: int | str,
        text: str,
        *,  # Force keyword-only arguments after required params
        message_thread_id: int | None = None,
        parse_mode: enums.ParseMode | None = None,
        entities: list[types.MessageEntity] | None = None,
        disable_web_page_preview: bool | None = None,
        disable_notification: bool | None = None,
        reply_to_message_id: int | None = None,
        schedule_date: datetime | None = None,
        protect_content: bool | None = None,
        reply_markup: types.InlineKeyboardMarkup
        | types.ReplyKeyboardMarkup
        | types.ReplyKeyboardRemove
        | types.ForceReply = None,
    ) -> types.Message:
        """Send text messages.

        .. include:: /_includes/usable-by/users-bots.rst

        Parameters:
            chat_id (``int`` | ``str``):
                Unique identifier (int) or username (str) of the target chat.
                For your personal cloud (Saved Messages) you can simply use "me" or "self".
                For a contact that exists in your Telegram address book you can use his phone number (str).

            text (``str``):
                Text of the message to be sent.

            message_thread_id (``int``, *optional*):
                Unique identifier for the target message thread (topic) of the forum.
                for forum supergroups only.

            parse_mode (:obj:`~hydrogram.enums.ParseMode`, *optional*):
                By default, texts are parsed using both Markdown and HTML styles.
                You can combine both syntaxes together.

            entities (List of :obj:`~hydrogram.types.MessageEntity`):
                List of special entities that appear in message text, which can be specified instead of *parse_mode*.

            disable_web_page_preview (``bool``, *optional*):
                Disables link previews for links in this message.

            disable_notification (``bool``, *optional*):
                Sends the message silently.
                Users will receive a notification with no sound.

        Returns:
            :obj:`~hydrogram.types.Message`: On success, the sent message is returned.

        Example:
            .. code-block:: python

                # Simple send
                await app.send_message(chat_id, "Hello")

                # With formatting
                await app.send_message(chat_id, "**Bold** text", parse_mode=enums.ParseMode.MARKDOWN)
        """
        # Method implementation...

# File: hydrogram/methods/messages/__init__.py
from .send_message import SendMessage  # Import the new method class
# ... other imports ...

class Messages(
    # ... other method classes ...
    SendMessage,  # Add the class here (inherits the method)
):
    pass

class Filter:
    async def __call__(self, client: hydrogram.Client, update: Update) -> bool:
        raise NotImplementedError

    # Support logical operators
    def __invert__(self) -> InvertFilter
    def __and__(self, other: Filter) -> AndFilter
    def __or__(self, other: Filter) -> OrFilter

from __future__ import annotations

import inspect
from typing import TYPE_CHECKING, Callable

if TYPE_CHECKING:
    import hydrogram
    from hydrogram.filters import Filter
    from hydrogram.types import Update


class Handler:
    def __init__(self, callback: Callable, filters: Filter | None = None):
        self.callback = callback
        self.filters = filters

    async def check(self, client: hydrogram.Client, update: Update):
        if callable(self.filters):
            if inspect.iscoroutinefunction(self.filters.__call__):
                return await self.filters(client, update)
            return await client.loop.run_in_executor(client.executor, self.filters, client, update)

        return True

from __future__ import annotations

from abc import ABC, abstractmethod
from typing import Union

from hydrogram import raw

InputPeer = Union[raw.types.InputPeerUser, raw.types.InputPeerChat, raw.types.InputPeerChannel]


class BaseStorage(ABC):
    """Abstract base class for storage engines."""

    SESSION_STRING_FORMAT: str = ">BI?256sQ?"

    def __init__(self, name: str) -> None:
        self.name = name

    @abstractmethod
    async def open(self) -> None: ...

    @abstractmethod
    async def save(self) -> None: ...

    @abstractmethod
    async def close(self) -> None: ...

    @abstractmethod
    async def dc_id(self, value: int | None = None) -> int: ...

    @abstractmethod
    async def api_id(self, value: int | None = None) -> int: ...

    @abstractmethod
    async def auth_key(self, value: bytes | None = None) -> bytes: ...

    @abstractmethod
    async def update_peers(self, peers: list[tuple[int, int, str, str, str]]) -> None: ...

    @abstractmethod
    async def get_peer_by_id(self, peer_id: int) -> InputPeer: ...

# Custom exceptions for RPC errors
class SomeTelegramError(Exception):
    """Description of when this occurs"""

#  Hydrogram - Telegram MTProto API Client Library for Python
#  Copyright (C) 2023-present Hydrogram <https://hydrogram.org>
#
#  This file is part of Hydrogram.
#  ... (license header)

import pytest

from hydrogram.module import ThingToTest


def test_something():
    result = ThingToTest.method()
    assert result == expected


async def test_async_something():
    result = await ThingToTest.async_method()
    assert result == expected