import json
import uuid

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.championship import Championship
from app.schemas.championship import ChampionshipCreate, ChampionshipUpdate


def _serialize(value) -> str | None:
    if value is None:
        return None
    return json.dumps(value)


async def get(db: AsyncSession, champ_id: str | uuid.UUID) -> Championship | None:
    cid = champ_id if isinstance(champ_id, uuid.UUID) else uuid.UUID(str(champ_id))
    result = await db.execute(select(Championship).where(Championship.id == cid))
    return result.scalar_one_or_none()


async def list_all(
    db: AsyncSession,
    status: str | None = None,
    skip: int = 0,
    limit: int = 50,
) -> list[Championship]:
    q = select(Championship).order_by(Championship.event_date.asc())
    if status:
        q = q.where(Championship.status == status)
    q = q.offset(skip).limit(limit)
    result = await db.execute(q)
    return list(result.scalars().all())


async def create(db: AsyncSession, data: ChampionshipCreate) -> Championship:
    payload = data.model_dump(exclude={"judges", "categories"})
    payload["judges"] = _serialize(data.judges)
    payload["categories"] = _serialize(data.categories)
    champ = Championship(**payload)
    db.add(champ)
    await db.commit()
    await db.refresh(champ)
    return champ


async def update(db: AsyncSession, champ: Championship, data: ChampionshipUpdate) -> Championship:
    raw = data.model_dump(exclude_none=True, exclude={"judges", "categories"})
    for field, value in raw.items():
        setattr(champ, field, value)
    if data.judges is not None:
        champ.judges = _serialize(data.judges)
    if data.categories is not None:
        champ.categories = _serialize(data.categories)
    await db.commit()
    await db.refresh(champ)
    return champ


async def delete(db: AsyncSession, champ: Championship) -> None:
    await db.delete(champ)
    await db.commit()