"""ORM model for tracks — the central entity.

``id`` is the stable, client-facing ``content_id`` (generated app-side by
``UUIDPrimaryKeyMixin``) — never regenerate it. Dedup is enforced on both
``(source, source_id)`` (unique) and ``acoustid_fingerprint`` (indexed) so
imports/downloads stay idempotent (plan §4, §6.1).
"""

import datetime as dt
import uuid

from sqlalchemy import DateTime, ForeignKey, Integer, String, UniqueConstraint
from sqlalchemy.orm import Mapped, mapped_column

from app.infrastructure.db.base import Base
from app.infrastructure.db.models.enums import MetadataStatus, StoragePolicy, TrackAvailability
from app.infrastructure.db.models.mixins import TimestampMixin, UUIDPrimaryKeyMixin


class TrackModel(UUIDPrimaryKeyMixin, TimestampMixin, Base):
    __tablename__ = "tracks"
    __table_args__ = (
        # Dedup by source identity — a source never yields the same id twice.
        UniqueConstraint("source", "source_id", name="uq_tracks_source_source_id"),
    )

    title: Mapped[str] = mapped_column(String(1024), index=True, nullable=False)
    artist_id: Mapped[uuid.UUID] = mapped_column(
        ForeignKey("artists.id", ondelete="CASCADE"),
        index=True,
        nullable=False,
    )
    album_id: Mapped[uuid.UUID | None] = mapped_column(
        ForeignKey("albums.id", ondelete="SET NULL"),
        index=True,
        nullable=True,
    )
    track_number: Mapped[int | None] = mapped_column(Integer, nullable=True)
    duration_seconds: Mapped[int | None] = mapped_column(Integer, nullable=True)
    genre: Mapped[str | None] = mapped_column(String(255), index=True, nullable=True)
    year: Mapped[int | None] = mapped_column(Integer, nullable=True)

    # -- file (original, stored as-is) -----------------------------------
    # NULL on a remote placeholder (not yet materialized) — see ``availability``.
    storage_uri: Mapped[str | None] = mapped_column(String(2048), nullable=True)
    file_format: Mapped[str | None] = mapped_column(String(32), nullable=True)
    file_size: Mapped[int | None] = mapped_column(Integer, nullable=True)
    bitrate: Mapped[int | None] = mapped_column(Integer, nullable=True)

    # ``remote`` = placeholder with no local audio yet; materialize() flips this
    # to ``local`` once the file is downloaded and ``storage_uri`` is filled in.
    availability: Mapped[str] = mapped_column(
        String(16),
        nullable=False,
        default=TrackAvailability.LOCAL.value,
    )

    # -- dedup / external ids --------------------------------------------
    acoustid_fingerprint: Mapped[str | None] = mapped_column(String(64), index=True, nullable=True)
    musicbrainz_id: Mapped[str | None] = mapped_column(String(36), index=True, nullable=True)

    # -- provenance / policy ---------------------------------------------
    source: Mapped[str] = mapped_column(String(32), nullable=False)
    source_id: Mapped[str] = mapped_column(String(512), nullable=False)
    is_replaceable: Mapped[bool] = mapped_column(nullable=False, default=False)
    storage_policy: Mapped[str] = mapped_column(
        String(16),
        nullable=False,
        default=StoragePolicy.AS_IS.value,
    )
    metadata_status: Mapped[str] = mapped_column(
        String(16),
        nullable=False,
        default=MetadataStatus.PENDING.value,
    )
    # Human-readable reason the last enrichment run set ``failed`` (no match, or
    # an unexpected worker error). ``None`` once a run succeeds. Surfaced in the
    # UI so a stuck/failed track is diagnosable, not silent.
    metadata_error: Mapped[str | None] = mapped_column(String(2048), nullable=True)
    # When the last enrichment run finished (success or failure). ``None`` while
    # still ``pending`` — lets the UI distinguish "queued/running" from "done".
    enriched_at: Mapped[dt.datetime | None] = mapped_column(
        DateTime(timezone=True),
        nullable=True,
    )

    added_by: Mapped[uuid.UUID | None] = mapped_column(
        ForeignKey("users.id", ondelete="SET NULL"),
        index=True,
        nullable=True,
    )