from typing import Optional, Sequence
from uuid import UUID
from sqlalchemy import select, and_, delete
from sqlalchemy.orm import selectinload
from sqlalchemy.ext.asyncio import AsyncSession
from modules.message_studio.models import (
    BotMessageTemplate,
    BotMessageButton,
    BotMessageVersion,
)
from modules.message_studio.schemas import ButtonSchema


class MessageStudioRepository:
    def __init__(self, db: AsyncSession):
        self.db = db

    async def list_by_bot(
        self,
        bot_id: UUID,
        tenant_id: UUID,
        locale: Optional[str] = None,
    ) -> Sequence[BotMessageTemplate]:
        stmt = (
            select(BotMessageTemplate)
            .options(selectinload(BotMessageTemplate.buttons))
            .where(
                BotMessageTemplate.bot_id == bot_id,
                BotMessageTemplate.tenant_id == tenant_id,
            )
        )
        if locale:
            stmt = stmt.where(BotMessageTemplate.locale == locale)
        stmt = stmt.order_by(BotMessageTemplate.message_key, BotMessageTemplate.locale)
        res = await self.db.execute(stmt)
        return res.scalars().all()

    async def get_by_id(
        self,
        template_id: UUID,
        tenant_id: Optional[UUID] = None,
    ) -> Optional[BotMessageTemplate]:
        stmt = (
            select(BotMessageTemplate)
            .options(selectinload(BotMessageTemplate.buttons))
            .where(BotMessageTemplate.id == template_id)
        )
        if tenant_id:
            stmt = stmt.where(BotMessageTemplate.tenant_id == tenant_id)
        res = await self.db.execute(stmt)
        return res.scalar_one_or_none()

    async def get_by_key(
        self,
        bot_id: UUID,
        message_key: str,
        locale: str = "en",
        tenant_id: Optional[UUID] = None,
    ) -> Optional[BotMessageTemplate]:
        stmt = (
            select(BotMessageTemplate)
            .options(selectinload(BotMessageTemplate.buttons))
            .where(
                BotMessageTemplate.bot_id == bot_id,
                BotMessageTemplate.message_key == message_key,
                BotMessageTemplate.locale == locale,
            )
        )
        if tenant_id:
            stmt = stmt.where(BotMessageTemplate.tenant_id == tenant_id)
        res = await self.db.execute(stmt)
        return res.scalar_one_or_none()

    async def create_template(self, template: BotMessageTemplate) -> BotMessageTemplate:
        self.db.add(template)
        await self.db.flush()
        return template

    async def replace_buttons(
        self,
        template_id: UUID,
        buttons: list[ButtonSchema],
    ) -> None:
        await self.db.execute(
            delete(BotMessageButton).where(BotMessageButton.template_id == template_id)
        )
        for btn in buttons:
            new_btn = BotMessageButton(
                template_id=template_id,
                text=btn.text,
                button_type=btn.button_type,
                action_value=btn.action_value,
                row_position=btn.row_position,
                column_position=btn.column_position,
                sort_order=btn.sort_order,
            )
            self.db.add(new_btn)
        await self.db.flush()

    async def create_version(
        self,
        template: BotMessageTemplate,
        updated_by: Optional[UUID] = None,
    ) -> BotMessageVersion:
        # Build snapshot of current state
        buttons_snapshot = [
            {
                "text": b.text,
                "button_type": b.button_type,
                "action_value": b.action_value,
                "row_position": b.row_position,
                "column_position": b.column_position,
                "sort_order": b.sort_order,
            }
            for b in template.buttons
        ]

        snapshot = {
            "message_key": template.message_key,
            "title": template.title,
            "message_text": template.message_text,
            "parse_mode": template.parse_mode,
            "media_type": template.media_type,
            "media_file_id": template.media_file_id,
            "locale": template.locale,
            "is_active": template.is_active,
            "is_draft": template.is_draft,
            "buttons": buttons_snapshot,
        }

        version_record = BotMessageVersion(
            template_id=template.id,
            version=template.current_version,
            snapshot_json=snapshot,
            updated_by=updated_by,
        )
        self.db.add(version_record)
        await self.db.flush()
        return version_record

    async def get_versions(self, template_id: UUID) -> Sequence[BotMessageVersion]:
        stmt = (
            select(BotMessageVersion)
            .where(BotMessageVersion.template_id == template_id)
            .order_by(BotMessageVersion.version.desc())
        )
        res = await self.db.execute(stmt)
        return res.scalars().all()

    async def get_version(self, template_id: UUID, version: int) -> Optional[BotMessageVersion]:
        stmt = select(BotMessageVersion).where(
            BotMessageVersion.template_id == template_id,
            BotMessageVersion.version == version,
        )
        res = await self.db.execute(stmt)
        return res.scalar_one_or_none()

    async def delete_template(self, template: BotMessageTemplate) -> None:
        await self.db.delete(template)
        await self.db.flush()
