"""Track video model."""

from typing import Any

from sqlalchemy import Column, Enum, Integer, String, select
from sqlalchemy.orm import Mapped, Session, mapped_column

from video.connectors import mysql


class TrackVideo(mysql.ArModel):
    """Track Video."""

    __tablename__ = "track_video"

    track_id = Column(
        Integer,
        name="id",
        nullable=False,
        primary_key=True,
        autoincrement=False,
    )
    color: Mapped[str | None] = mapped_column(
        Enum("black_and_white", "color"), default="color"
    )
    channel = Column(String)
    fps: Mapped[str | None] = mapped_column(Enum("30", "25", "24", "15", "12"))
    resolution: Mapped[str | None] = mapped_column(Enum("SD", "720HD", "1080HD", "4K"))
    aspect_ratio: Mapped[str | None] = mapped_column(
        Enum(
            "4:3",
            "16:9",
            "8:5",
            "5:3",
            "40:23",
            "20:11",
            "40:21",
            "4:2",
            "40:19",
            "20:9",
            "3:2",
            "40:17",
            "5:2",
            "8:3",
            "20:7",
            "40:29",
            "10:7",
            "40:27",
            "20:13",
            "1.85:1",
        )
    )

    def to_dict(self) -> dict[str, Any]:
        """Get a dict representation."""
        return {
            "track_id": self.track_id,
            "color": self.color,
            "channel": self.channel,
            "fps": self.fps,
            "resolution": self.resolution,
            "aspect_ratio": self.aspect_ratio,
        }


def _get(track_id: int, session: Session) -> TrackVideo | None:
    return session.execute(
        select(TrackVideo).where(TrackVideo.track_id == track_id)
    ).scalar_one_or_none()


def upsert(
    track_video: dict[str, Any], session: Session | None = None
) -> dict[str, Any]:
    """Create or update."""
    if session is None:
        with mysql.ar_db_session() as s:
            return upsert(track_video, s)
    track_entry = _get(track_video["track_id"], session)
    if track_entry:
        return update(track_entry, track_video, session)

    return create(track_video, session)


def create(track_video: dict[str, Any], session: Session) -> dict[str, Any]:
    """Create a track video entry."""
    track_video_model = TrackVideo(**track_video)
    session.add(track_video_model)
    session.flush()
    return track_video_model.to_dict()


def update(
    track_video: TrackVideo,
    track_video_update: dict[str, Any],
    session: Session,
) -> dict[str, Any]:
    """Update track video."""
    for field_name, value in track_video_update.items():
        setattr(track_video, field_name, value)

    session.add(track_video)
    session.flush()
    return track_video.to_dict()