Aurora-Core/app/services/movie_service.py

"""Assembles Movie API responses from repository data."""

from __future__ import annotations

import uuid

from sqlalchemy.ext.asyncio import AsyncSession

from app.core.ids import aurora_id, parse_aurora_id
from app.models.enums import ArtworkType
from app.repositories import movie_repository, polymorphic
from app.schemas.common import CollectionBriefOut, CompanyBriefOut, GenreOut, KeywordOut
from app.schemas.movie import (
    MovieCreditsOut,
    MovieDetailOut,
    MovieImagesOut,
    MovieSummaryOut,
    MovieVideosOut,
)
from app.services.common import primary_artwork_path, split_credits, to_images_out, to_video_out


class MovieNotFoundError(Exception):
    pass


async def _resolve_movie_id(movie_aurora_id: str) -> uuid.UUID:
    try:
        return uuid.UUID(parse_aurora_id(movie_aurora_id, expected_type="movie"))
    except ValueError as exc:
        raise MovieNotFoundError(str(exc)) from exc


async def get_movie_detail(session: AsyncSession, movie_aurora_id: str) -> MovieDetailOut:
    movie_id = await _resolve_movie_id(movie_aurora_id)
    movie = await movie_repository.get_movie_by_id(session, movie_id)
    if movie is None:
        raise MovieNotFoundError(movie_aurora_id)

    genres = await movie_repository.get_movie_genres(session, movie_id)
    keywords = await movie_repository.get_movie_keywords(session, movie_id)
    companies = await movie_repository.get_movie_companies(session, movie_id)
    credits_ = await polymorphic.get_credits(session, "movie", movie_id)
    artwork = await polymorphic.get_artwork(session, "movie", movie_id)
    videos = await polymorphic.get_videos(session, "movie", movie_id)
    external_ids = await polymorphic.get_external_ids(session, "movie", movie_id)

    cast, crew = split_credits(credits_)

    return MovieDetailOut(
        id=aurora_id("movie", str(movie.id)),
        title=movie.title,
        original_title=movie.original_title,
        overview=movie.overview,
        tagline=movie.tagline,
        status=movie.status.value,
        original_language=movie.original_language_code,
        release_date=movie.primary_release_date,
        runtime=movie.runtime_minutes,
        budget=movie.budget,
        revenue=movie.revenue,
        popularity=movie.popularity,
        vote_average=movie.vote_average,
        vote_count=movie.vote_count,
        adult=movie.adult,
        genres=[GenreOut(id=aurora_id("genre", str(g.id)), name=g.name) for g in genres],
        keywords=[KeywordOut(id=aurora_id("keyword", str(k.id)), name=k.name) for k in keywords],
        cast=cast,
        crew=crew,
        companies=[
            CompanyBriefOut(
                id=aurora_id("company", str(company.id)),
                name=company.name,
                company_type=company.company_type.value,
                logo_path=None,
            )
            for company, _role in companies
        ],
        collection=(
            CollectionBriefOut(
                id=aurora_id("collection", str(movie.collection.id)), name=movie.collection.name
            )
            if movie.collection
            else None
        ),
        images=to_images_out(artwork),
        videos=[to_video_out(v) for v in videos],
        external_ids=external_ids,
        created_at=movie.created_at,
        updated_at=movie.updated_at,
    )


async def get_movie_credits(session: AsyncSession, movie_aurora_id: str) -> MovieCreditsOut:
    movie_id = await _resolve_movie_id(movie_aurora_id)
    movie = await movie_repository.get_movie_by_id(session, movie_id)
    if movie is None:
        raise MovieNotFoundError(movie_aurora_id)
    credits_ = await polymorphic.get_credits(session, "movie", movie_id)
    cast, crew = split_credits(credits_)
    return MovieCreditsOut(id=aurora_id("movie", str(movie.id)), cast=cast, crew=crew)


async def get_movie_images(session: AsyncSession, movie_aurora_id: str) -> MovieImagesOut:
    movie_id = await _resolve_movie_id(movie_aurora_id)
    movie = await movie_repository.get_movie_by_id(session, movie_id)
    if movie is None:
        raise MovieNotFoundError(movie_aurora_id)
    artwork = await polymorphic.get_artwork(session, "movie", movie_id)
    return MovieImagesOut(id=aurora_id("movie", str(movie.id)), images=to_images_out(artwork))


async def get_movie_videos(session: AsyncSession, movie_aurora_id: str) -> MovieVideosOut:
    movie_id = await _resolve_movie_id(movie_aurora_id)
    movie = await movie_repository.get_movie_by_id(session, movie_id)
    if movie is None:
        raise MovieNotFoundError(movie_aurora_id)
    videos = await polymorphic.get_videos(session, "movie", movie_id)
    return MovieVideosOut(id=aurora_id("movie", str(movie.id)), videos=[to_video_out(v) for v in videos])


async def build_movie_summary(session: AsyncSession, movie_id: uuid.UUID) -> MovieSummaryOut | None:
    movie = await movie_repository.get_movie_by_id(session, movie_id)
    if movie is None:
        return None
    posters = await polymorphic.get_artwork(session, "movie", movie_id, ArtworkType.POSTER)
    return MovieSummaryOut(
        id=aurora_id("movie", str(movie.id)),
        title=movie.title,
        original_title=movie.original_title,
        overview=movie.overview,
        release_date=movie.primary_release_date,
        poster_path=primary_artwork_path(posters, ArtworkType.POSTER),
        popularity=movie.popularity,
        vote_average=movie.vote_average,
    )


async def build_movie_summaries(
    session: AsyncSession, movie_ids: list[uuid.UUID]
) -> list[MovieSummaryOut]:
    out: list[MovieSummaryOut] = []
    for movie_id in movie_ids:
        summary = await build_movie_summary(session, movie_id)
        if summary is not None:
            out.append(summary)
    return out