import json
from uuid import uuid4

from fastapi import HTTPException, status
from sqlalchemy import asc, delete, select

from app.db.session import AsyncSessionLocal
from app.models.scheme_seat import SchemeSeatRecord


async def replace_scheme_version_seats(
    *,
    scheme_id: str,
    scheme_version_id: str,
    seats: list[dict],
) -> None:
    async with AsyncSessionLocal() as session:
        await session.execute(
            delete(SchemeSeatRecord).where(
                SchemeSeatRecord.scheme_version_id == scheme_version_id
            )
        )

        for item in seats:
            row = SchemeSeatRecord(
                seat_record_id=uuid4().hex,
                scheme_id=scheme_id,
                scheme_version_id=scheme_version_id,
                element_id=item.get("id"),
                seat_id=item.get("seat_id"),
                sector_id=item.get("sector_id"),
                group_id=item.get("group_id"),
                row_label=item.get("row"),
                seat_number=item.get("seat_number"),
                tag=item.get("tag"),
                classes_raw=json.dumps(item.get("classes", []), ensure_ascii=False),
                x=item.get("x"),
                y=item.get("y"),
                cx=item.get("cx"),
                cy=item.get("cy"),
                width=item.get("width"),
                height=item.get("height"),
            )
            session.add(row)

        await session.commit()


async def list_scheme_version_seats(scheme_version_id: str) -> list[SchemeSeatRecord]:
    async with AsyncSessionLocal() as session:
        result = await session.execute(
            select(SchemeSeatRecord)
            .where(SchemeSeatRecord.scheme_version_id == scheme_version_id)
            .order_by(asc(SchemeSeatRecord.id))
        )
        return list(result.scalars().all())


async def get_scheme_version_seat_by_seat_id(
    *,
    scheme_version_id: str,
    seat_id: str,
) -> SchemeSeatRecord:
    async with AsyncSessionLocal() as session:
        result = await session.execute(
            select(SchemeSeatRecord).where(
                SchemeSeatRecord.scheme_version_id == scheme_version_id,
                SchemeSeatRecord.seat_id == seat_id,
            )
        )
        row = result.scalar_one_or_none()

        if row is None:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="Seat not found in current scheme version",
            )

        return row


async def clone_scheme_version_seats(
    *,
    source_scheme_version_id: str,
    target_scheme_version_id: str,
) -> None:
    async with AsyncSessionLocal() as session:
        result = await session.execute(
            select(SchemeSeatRecord).where(
                SchemeSeatRecord.scheme_version_id == source_scheme_version_id
            )
        )
        rows = list(result.scalars().all())

        for row in rows:
            session.add(
                SchemeSeatRecord(
                    seat_record_id=uuid4().hex,
                    scheme_id=row.scheme_id,
                    scheme_version_id=target_scheme_version_id,
                    element_id=row.element_id,
                    seat_id=row.seat_id,
                    sector_id=row.sector_id,
                    group_id=row.group_id,
                    row_label=row.row_label,
                    seat_number=row.seat_number,
                    tag=row.tag,
                    classes_raw=row.classes_raw,
                    x=row.x,
                    y=row.y,
                    cx=row.cx,
                    cy=row.cy,
                    width=row.width,
                    height=row.height,
                )
            )

        await session.commit()