import datetime
import typing
from dataclasses import dataclass
from uuid import UUID

if typing.TYPE_CHECKING:
    from aiogram.types import InlineKeyboardButton

from src import domain

from .analytics.get_channel_analytics import get_channel_analytics
from .analytics.get_creatives_analytics import get_creatives_analytics
from .analytics.get_overview_analytics import get_overview_analytics
from .analytics.get_placements_analytics import get_placements_analytics
from .analytics.get_spending_analytics import get_spending_analytics
from .auth.create_telegram_login_token import create_telegram_login_token
from .auth.get_jwt_by_telegram_id import get_jwt_by_telegram_id
from .auth.get_me import get_me
from .auth.validate_login_token import validate_login_token
from .channel.attach_channel_to_workspace import attach_channel_to_workspace
from .channel.get_channel import get_channel
from .channel.get_channels import get_channels
from .creative.create_creative import create_creative
from .creative.delete_creative import delete_creative
from .creative.get_creative import get_creative
from .creative.get_creatives import get_creatives
from .creative.update_creative import update_creative
from .placement.fetch_placement_post_cycle import fetch_placement_post_cycle
from .placement.get_placement import get_placement
from .placement.get_placements import get_placements
from .project.archive_project import archive_project
from .project.delete_project import delete_project
from .project.disconnect_project_by_tg_id import disconnect_project_by_tg_id
from .project.get_project import get_project
from .project.get_workspace_projects import get_workspace_projects
from .project.tg_add_project import tg_add_project
from .project.update_project_invite_link_type import update_project_invite_link_type
from .project.update_project_permissions import update_project_permissions
from .purchase.create_purchase import create_purchase
from .purchase.get_purchase import get_purchase
from .purchase.get_purchases import get_purchases
from .subscription.handle_subscription import handle_subscription
from .subscription.handle_unsubscription import handle_unsubscription
from .views.get_views_history import get_views_history
from .workspace.accept_workspace_invite import accept_workspace_invite
from .workspace.create_workspace import create_workspace
from .workspace.create_workspace_invite import create_workspace_invite
from .workspace.delete_workspace import delete_workspace
from .workspace.get_workspace_invites import get_workspace_invites
from .workspace.get_workspace_members import get_workspace_members
from .workspace.get_workspaces import get_workspaces
from .workspace.tg_accept_workspace_invite import tg_accept_workspace_invite
from .workspace.update_workspace import update_workspace
from .workspace.update_workspace_member_permissions import update_workspace_member_permissions


class Database(typing.Protocol):
    def transaction(self) -> typing.AsyncContextManager[None]: ...

    async def get_user(
        self,
        user_id: UUID | None = None,
        telegram_id: int | None = None,
    ) -> domain.User | None: ...

    async def get_user_by_username(self, username: str) -> domain.User | None: ...

    async def create_user(self, user: domain.User) -> None: ...

    async def get_telegram_user(
        self,
        telegram_user_id: UUID | None = None,
        telegram_id: int | None = None,
    ) -> domain.TelegramUser | None: ...

    async def create_telegram_user(self, telegram_user: domain.TelegramUser) -> None: ...

    async def update_telegram_user(self, telegram_user: domain.TelegramUser) -> None: ...

    async def create_workspace(self, workspace: domain.Workspace) -> None: ...

    async def update_workspace(self, workspace: domain.Workspace) -> None: ...

    async def delete_workspace(self, workspace_id: UUID) -> None: ...

    async def add_user_to_workspace(self, workspace_id: UUID, user_id: UUID) -> domain.WorkspaceUser: ...

    async def set_workspace_user_permissions(
        self,
        workspace_user_id: UUID,
        global_permissions: set[domain.PermissionKey],
        scoped_permissions: list[tuple[domain.PermissionKey, domain.PermissionScopeType, UUID]],
    ) -> None: ...

    async def update_workspace_user(self, workspace_user: domain.WorkspaceUser) -> None: ...

    async def get_user_workspaces(self, user_id: UUID) -> list[domain.WorkspaceUser]: ...

    async def get_workspace(self, workspace_id: UUID) -> domain.Workspace | None: ...

    async def get_workspace_for_user(self, workspace_id: UUID, user_id: UUID) -> domain.Workspace | None: ...

    async def get_default_workspace_for_user(self, user_id: UUID) -> domain.Workspace | None: ...

    async def get_workspace_membership(self, workspace_id: UUID, user_id: UUID) -> domain.WorkspaceUser | None: ...

    async def get_workspace_members(self, workspace_id: UUID) -> list[domain.WorkspaceUser]: ...

    async def get_workspace_member(self, workspace_user_id: UUID) -> domain.WorkspaceUser | None: ...

    async def create_workspace_invite(self, invite: domain.WorkspaceInvite) -> None: ...

    async def update_workspace_invite(self, invite: domain.WorkspaceInvite) -> None: ...

    async def get_workspace_invite(self, invite_id: UUID) -> domain.WorkspaceInvite | None: ...

    async def get_workspace_invite_by_user(
        self, workspace_id: UUID, user_id: UUID
    ) -> domain.WorkspaceInvite | None: ...

    async def get_workspace_invites(self, workspace_id: UUID) -> list[domain.WorkspaceInvite]: ...

    async def create_login_token(self, login_token: domain.LoginToken) -> None: ...

    async def create_creative(self, creative: domain.Creative) -> None: ...

    async def get_login_token(self, token: str) -> domain.LoginToken | None: ...

    async def mark_token_as_used(self, token: str) -> None: ...

    async def update_user(self, user: domain.User) -> None: ...

    async def get_channel(
        self,
        channel_id: UUID | None = None,
        telegram_id: int | None = None,
        username: str | None = None,
    ) -> domain.Channel | None: ...

    async def create_channel(self, channel: domain.Channel) -> None: ...

    async def update_channel(self, channel: domain.Channel) -> None: ...

    async def delete_channel(self, channel_id: UUID) -> None: ...

    async def search_channels(self, username_query: str | None = None) -> list[domain.Channel]: ...

    async def get_project(
        self, workspace_id: UUID, project_id: UUID | None = None, channel_id: UUID | None = None
    ) -> domain.Project | None: ...

    async def get_project_for_user_by_telegram(
        self, user_id: UUID, channel_telegram_id: int
    ) -> domain.Project | None: ...

    async def get_project_by_channel_telegram(self, channel_telegram_id: int) -> domain.Project | None: ...

    async def create_project(self, project: domain.Project) -> None: ...

    async def update_project(self, project: domain.Project) -> None: ...

    async def get_workspace_projects(
        self, workspace_id: UUID, allowed_project_ids: set[UUID] | None = None, include_archived: bool = False
    ) -> list[domain.Project]: ...

    async def archive_project(self, workspace_id: UUID, project_id: UUID) -> None: ...

    async def delete_project(self, workspace_id: UUID, project_id: UUID) -> None: ...

    async def get_active_purchase(self, project_id: UUID, creative_id: UUID) -> domain.Purchase | None: ...

    async def get_purchase(self, workspace_id: UUID, purchase_id: UUID) -> domain.Purchase | None: ...

    async def get_project_purchases(self, workspace_id: UUID, project_id: UUID) -> list[domain.Purchase]: ...

    async def create_purchase(self, purchase: domain.Purchase) -> None: ...

    async def get_purchase_channels(self, purchase_id: UUID) -> list[domain.PurchaseChannel]: ...

    async def get_purchase_channel(
        self, purchase_channel_id: UUID, purchase_id: UUID
    ) -> domain.PurchaseChannel | None: ...

    async def get_purchase_channel_by_id(self, purchase_channel_id: UUID) -> domain.PurchaseChannel | None: ...

    async def get_purchase_channels_by_project(self, project_id: UUID) -> list[domain.PurchaseChannel]: ...

    async def add_channel_to_purchase(
        self,
        purchase_id: UUID,
        channel_id: UUID,
        invite_link: str,
        invite_link_type: domain.purchase.InviteLinkType,
        *,
        status: domain.PurchaseChannelStatus | None = None,
        comment: str | None = None,
        placement_at: datetime.datetime | None = None,
        cost_type: domain.purchase.CostType | None = None,
        cost_value: float | None = None,
        cost_before_bargain: float | None = None,
        format: str | None = None,
    ) -> domain.PurchaseChannel: ...

    async def update_purchase_channel(self, purchase_channel: domain.PurchaseChannel) -> None: ...

    async def remove_channel_from_purchase(self, purchase_id: UUID, channel_id: UUID) -> None: ...

    async def get_creative(self, workspace_id: UUID, creative_id: UUID) -> domain.Creative | None: ...

    async def update_creative(self, creative: domain.Creative) -> None: ...

    async def get_workspace_creatives(
        self,
        workspace_id: UUID,
        project_id: UUID | None = None,
        include_archived: bool = False,
        allowed_project_ids: set[UUID] | None = None,
    ) -> list[domain.Creative]: ...

    async def delete_creative(self, creative_id: UUID) -> None: ...

    async def get_placement(self, workspace_id: UUID, placement_id: UUID) -> domain.Placement | None: ...

    async def get_workspace_placements(
        self,
        workspace_id: UUID,
        project_id: UUID | None = None,
        placement_channel_id: UUID | None = None,
        creative_id: UUID | None = None,
        include_archived: bool = False,
        allowed_project_ids: set[UUID] | None = None,
        date_from: datetime.datetime | None = None,
        date_to: datetime.datetime | None = None,
    ) -> list[domain.Placement]: ...

    async def create_placement(self, placement: domain.Placement) -> None: ...

    async def update_placement(self, placement: domain.Placement) -> None: ...

    async def delete_placement(self, placement_id: UUID) -> None: ...

    async def get_placement_by_invite_link(self, invite_link: str) -> domain.Placement | None: ...

    async def create_subscription(self, subscription: domain.Subscription) -> None: ...

    async def get_subscription_by_subscriber_and_placement(
        self, telegram_user_id: UUID, placement_id: UUID
    ) -> domain.Subscription | None: ...

    async def update_subscription(self, subscription: domain.Subscription) -> None: ...

    async def get_subscriptions_for_placements(
        self,
        placement_ids: list[UUID],
        *,
        date_from: datetime.datetime | None = None,
        date_to: datetime.datetime | None = None,
    ) -> list[domain.Subscription]: ...

    async def get_active_subscriptions_by_subscriber_and_project(
        self, telegram_user_id: UUID, project_id: UUID
    ) -> list[domain.Subscription]: ...

    async def get_active_subscription_by_subscriber_and_project(
        self, telegram_user_id: UUID, project_id: UUID
    ) -> domain.Subscription | None: ...

    # Count methods
    async def count_placements_by_creative(self, creative_id: UUID) -> int: ...

    async def count_subscriptions_by_placement(self, placement_id: UUID) -> int: ...

    async def count_placements_by_creative_batch(self, creative_ids: list[UUID]) -> dict[UUID, int]: ...

    async def count_subscriptions_by_placement_batch(self, placement_ids: list[UUID]) -> dict[UUID, int]: ...

    async def has_placements_for_creative(self, creative_id: UUID) -> bool: ...

    # Post methods
    async def create_post(self, post: domain.Post) -> None: ...

    async def get_post(self, post_id: UUID) -> domain.Post | None: ...

    async def get_post_by_channel_and_message(self, channel_id: UUID, message_id: int) -> domain.Post | None: ...

    # Post views history
    async def create_post_views_history(self, history: domain.PostViewsHistory) -> None: ...

    async def get_views_history(
        self,
        post_id: UUID,
        *,
        from_date: datetime.datetime | None = None,
        to_date: datetime.datetime | None = None,
    ) -> list[domain.PostViewsHistory]: ...

    async def get_latest_views_data(self, post_id: UUID) -> tuple[int, datetime.datetime] | None: ...

    async def get_latest_views_data_batch(self, post_ids: list[UUID]) -> dict[UUID, tuple[int, datetime.datetime]]: ...


class TelegramBotWriter(typing.Protocol):
    async def send_message(self, text: str, chat_id: int) -> None: ...

    async def send_message_with_button(self, text: str, chat_id: int, button_text: str, button_url: str) -> None: ...

    async def send_message_with_inline_keyboard(
        self, text: str, chat_id: int, buttons: list[list['InlineKeyboardButton']]
    ) -> None: ...

    async def edit_message_reply_markup(self, chat_id: int, message_id: int) -> None: ...

    async def create_chat_invite_link(self, chat_id: int, requires_approval: bool = False) -> str: ...


class JWTEncoder(typing.Protocol):
    def encode_access_token(self, user_id: UUID, telegram_id: int, username: str | None = None) -> str: ...


class FetchChannelResponse(typing.Protocol):
    telegram_id: int
    username: str
    title: str


class Parser(typing.Protocol):
    async def fetch_telegram_channel(self, username: str) -> FetchChannelResponse | None: ...


class S3Storage(typing.Protocol):
    async def connect(self) -> None: ...

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

    async def upload(self, key: str, data: bytes, content_type: str) -> None: ...

    async def get(self, key: str) -> bytes: ...

    async def delete(self, key: str) -> None: ...


@dataclass
class Usecase:
    database: Database
    telegram_bot: TelegramBotWriter
    jwt_encoder: JWTEncoder
    parser: Parser
    s3: S3Storage

    async def ensure_workspace_access(self, workspace_id: UUID, user_id: UUID) -> domain.Workspace:
        workspace = await self.database.get_workspace_for_user(workspace_id, user_id)
        if not workspace:
            raise domain.WorkspaceNotFound(workspace_id)

        return workspace

    async def ensure_workspace_permission(
        self,
        workspace_id: UUID,
        user_id: UUID,
        permission: domain.PermissionKey,
        *,
        for_project_id: UUID | None = None,
    ) -> domain.WorkspacePermissionContext:
        membership = await self.database.get_workspace_membership(workspace_id, user_id)
        if not membership or not membership.workspace:
            raise domain.WorkspaceNotFound(workspace_id)

        permissions = domain.WorkspacePermissions.from_membership(membership)

        if for_project_id is not None:
            has_permission = permissions.has_permission(
                permission,
                scope_type=domain.PermissionScopeType.PROJECT,
                scope_id=for_project_id,
            )
        else:
            has_permission = permissions.has_any(permission)

        if not has_permission:
            raise domain.WorkspaceAccessDenied(workspace_id)

        return domain.build_workspace_permission_context(membership)

    async def get_or_create_personal_workspace(self, user: domain.User) -> domain.Workspace:
        workspace = await self.database.get_default_workspace_for_user(user.id)
        if workspace:
            return workspace

        if not user.telegram_user:
            raise domain.UserNotFound(user.id)

        telegram_user = user.telegram_user
        workspace_name = telegram_user.username or f'Workspace {telegram_user.telegram_id}'
        workspace = domain.Workspace(name=workspace_name)

        async with self.database.transaction():
            await self.database.create_workspace(workspace)
            membership = await self.database.add_user_to_workspace(workspace.id, user.id)
            await self.database.set_workspace_user_permissions(
                membership.id,
                global_permissions={domain.PermissionKey.ADMIN_FULL},
                scoped_permissions=[],
            )

        return workspace

    async def ensure_active_purchase(self, project: domain.Project, creative: domain.Creative) -> domain.Purchase:
        purchase = await self.database.get_active_purchase(project.id, creative.id)
        if purchase:
            return purchase

        purchase = domain.Purchase(project_id=project.id, creative_id=creative.id)
        await self.database.create_purchase(purchase)
        return purchase

    validate_login_token = validate_login_token
    create_telegram_login_token = create_telegram_login_token
    get_jwt_by_telegram_id = get_jwt_by_telegram_id
    get_me = get_me
    tg_add_project = tg_add_project
    get_workspace_projects = get_workspace_projects
    get_project = get_project
    archive_project = archive_project
    delete_project = delete_project
    disconnect_project_by_tg_id = disconnect_project_by_tg_id
    update_project_permissions = update_project_permissions
    update_project_invite_link_type = update_project_invite_link_type
    get_channels = get_channels
    get_channel = get_channel
    attach_channel_to_workspace = attach_channel_to_workspace
    create_purchase = create_purchase
    get_purchases = get_purchases
    get_purchase = get_purchase
    get_creatives = get_creatives
    get_creative = get_creative
    create_creative = create_creative
    update_creative = update_creative
    delete_creative = delete_creative
    get_placements = get_placements
    get_placement = get_placement
    fetch_placement_post_cycle = fetch_placement_post_cycle
    handle_subscription = handle_subscription
    handle_unsubscription = handle_unsubscription
    get_views_history = get_views_history
    get_placements_analytics = get_placements_analytics
    get_creatives_analytics = get_creatives_analytics
    get_channel_analytics = get_channel_analytics
    get_spending_analytics = get_spending_analytics
    get_overview_analytics = get_overview_analytics
    get_workspaces = get_workspaces
    create_workspace = create_workspace
    update_workspace = update_workspace
    delete_workspace = delete_workspace
    get_workspace_members = get_workspace_members
    update_workspace_member_permissions = update_workspace_member_permissions
    create_workspace_invite = create_workspace_invite
    get_workspace_invites = get_workspace_invites
    accept_workspace_invite = accept_workspace_invite
    tg_accept_workspace_invite = tg_accept_workspace_invite