"""Minimal data builders for integration tests — inserts ORM rows directly
so tests don't depend on network calls to a real provider."""

from __future__ import annotations

from sqlalchemy.ext.asyncio import AsyncSession

from app.core.ids import aurora_id
from app.models.artwork import Artwork
from app.models.credit import Credit
from app.models.enums import ArtworkType, MovieStatus
from app.models.external_id import ExternalID
from app.models.genre import Genre, MovieGenre
from app.models.movie import Movie
from app.models.person import Person
from app.models.provider import Provider
from app.models.tv import Series
from app.repositories.provider_repository import get_or_create_provider


async def make_provider(session: AsyncSession, slug: str = "tmdb") -> Provider:
    # get_or_create, not a raw insert: some tests (e.g. the ingestion
    # cascade ones) create a real "tmdb" Provider row via session_scope()'s
    # own connection, outside this test's rolled-back transaction, so it
    # can already exist here regardless of db_session's per-test isolation.
    return await get_or_create_provider(session, slug, slug.upper())


async def make_movie(
    session: AsyncSession, *, title: str = "The Matrix", provider: Provider | None = None
) -> Movie:
    movie = Movie(
        title=title,
        sort_title=title,
        overview="A hacker discovers reality is a simulation.",
        status=MovieStatus.RELEASED,
        runtime_minutes=136,
    )
    session.add(movie)
    await session.flush()

    genre = Genre(name="Science Fiction", slug="science-fiction")
    session.add(genre)
    await session.flush()
    session.add(MovieGenre(movie_id=movie.id, genre_id=genre.id))

    person = Person(name="Keanu Reeves")
    session.add(person)
    await session.flush()
    session.add(
        Credit(
            person_id=person.id,
            entity_type="movie",
            entity_id=movie.id,
            department="Acting",
            character="Neo",
            billing_order=0,
        )
    )

    session.add(
        Artwork(
            entity_type="movie",
            entity_id=movie.id,
            artwork_type=ArtworkType.POSTER,
            provider_id=(provider or await make_provider(session)).id,
            original_url="https://image.tmdb.org/t/p/original/poster.jpg",
            is_primary=True,
        )
    )

    if provider is not None:
        session.add(
            ExternalID(
                entity_type="movie", entity_id=movie.id, provider_id=provider.id, external_id="603"
            )
        )

    await session.flush()
    return movie


def movie_aurora_id(movie: Movie) -> str:
    return aurora_id("movie", str(movie.id))


async def make_series(session: AsyncSession, *, title: str = "The Wire") -> Series:
    series = Series(title=title, sort_title=title, overview="Baltimore, drugs, and wiretaps.")
    session.add(series)
    await session.flush()
    return series


def series_aurora_id(series: Series) -> str:
    return aurora_id("series", str(series.id))