"""direct_delivery client / dms_encoding_profiles"""

from typing import Any

from sqlalchemy import bindparam, text

from delivery_metadata.api.app import app
from delivery_metadata.constants import EncodingProfileType, ProductTypeId
from delivery_metadata.models import Model


class DmsEncodingProfile(Model):
    delivery_location_template: str
    filename_template: str
    hashcode_algorithm: str
    format: str
    profile_subtype: str
    placeholder_hashcode_template: str | None


class AudioDmsEncodingProfile(DmsEncodingProfile):
    number_of_audio_channels: int
    clip_length: int | None
    bitrate: int | None
    frequency: int | None
    bits_per_sample: int | None = None


class ImageDmsEncodingProfile(DmsEncodingProfile):
    width: int | None
    height: int | None


class MetadataDmsEncodingProfile(DmsEncodingProfile): ...


class VideoDmsEncodingProfile(DmsEncodingProfile): ...


def _hydrate_dms_encoding_profile(data: dict[str, Any]) -> DmsEncodingProfile:
    """Hydrate a DmsEncodingProfile."""
    return DmsEncodingProfile(
        delivery_location_template=data["delivery_location"],
        filename_template=data["filename"],
        hashcode_algorithm="MD5",
        format=data["format"],
        profile_subtype=data["profile_subtype"],
        placeholder_hashcode_template=data["hashcode"],
    )


def _hydrate_audio_dms_encoding_profile(
    data: list[dict[str, Any]],
) -> list[AudioDmsEncodingProfile]:
    """Hydrate an AudioDmsEncodingProfile."""
    channel_to_number_of_audio_channels = {
        "mono": 1,
        "stereo": 2,
        "atmos": 2,  # TBD - 2 for now, this is what Amazon wants
    }
    return [
        AudioDmsEncodingProfile(
            **_hydrate_dms_encoding_profile(row).model_dump(),
            number_of_audio_channels=channel_to_number_of_audio_channels[
                row["channel"]
            ],
            clip_length=row["clip_length"],
            bitrate=row["bitrate"],
            frequency=row["frequency"],
            bits_per_sample=row["bits_per_sample"],
        )
        for row in data
    ]


def _hydrate_image_dms_encoding_profile(
    data: list[dict[str, Any]],
) -> list[ImageDmsEncodingProfile]:
    """Hydrate an ImageDmsEncodingProfile."""
    return [
        ImageDmsEncodingProfile(
            **_hydrate_dms_encoding_profile(row).model_dump(),
            width=row["width"],
            height=row["height"],
        )
        for row in data
    ]


def _hydrate_metadata_dms_encoding_profile(
    data: list[dict[str, Any]],
) -> list[MetadataDmsEncodingProfile]:
    """Hydrate a MetadataDmsEncodingProfile."""
    return [
        MetadataDmsEncodingProfile(**_hydrate_dms_encoding_profile(row).model_dump())
        for row in data
    ]


def _hydrate_video_dms_encoding_profile(
    data: list[dict[str, Any]],
) -> list[VideoDmsEncodingProfile]:
    """Hydrate an VideoDmsEncodingProfile."""
    return [
        VideoDmsEncodingProfile(**_hydrate_dms_encoding_profile(row).model_dump())
        for row in data
    ]


async def get_dms_encoding_profiles(
    store_id: int, product_type_id: ProductTypeId
) -> dict[EncodingProfileType, list]:  # type: ignore[type-arg]
    """Get the dms encoding profiles."""
    async with app.state.direct_delivery_connector.db_session() as session:
        result = await session.execute(
            text(
                """
                SELECT
                    dep.delivery_location,
                    dep.filename,
                    dep.hashcode,
                    dep.channel,
                    dep.extension AS format,
                    dep.clip_length,
                    dep.width,
                    dep.height,
                    dep.bitrate,
                    dep.frequency,
                    ep.format AS profile_subtype,
                    ep.profile_type,
                    CASE ep.format
                        WHEN 'flac16' THEN 16
                        WHEN 'wav16' THEN 16
                        WHEN 'flac24' THEN 24
                        WHEN 'wav24' THEN 24
                        ELSE null
                    END AS bits_per_sample
                FROM dms_encoding_profile dep
                    INNER JOIN encoding_profile ep
                        ON dep.encoding_profile_id = ep.encoding_profile_id
                            AND ep.profile_type in :profile_types
                WHERE dep.dms_master_master_id = :store_id
                    AND dep.product_type_id = :product_type_id
                    AND dep.order_type = 'release'
                """
            ).bindparams(bindparam("profile_types", expanding=True)),
            {
                "profile_types": ("audio", "image", "metadata", "video", "video_image"),
                "store_id": store_id,
                "product_type_id": product_type_id.value,
            },
        )

        dms_encoding_profiles: dict[str, list[dict[str, Any]]] = {}
        for value in result.mappings().all():
            dms_encoding_profiles.setdefault(value.profile_type, []).append(dict(value))

    return {
        EncodingProfileType.IMAGE: _hydrate_image_dms_encoding_profile(
            dms_encoding_profiles.get(EncodingProfileType.IMAGE.value, [])
        ),
        EncodingProfileType.AUDIO: _hydrate_audio_dms_encoding_profile(
            dms_encoding_profiles.get(EncodingProfileType.AUDIO.value, [])
        ),
        EncodingProfileType.METADATA: _hydrate_metadata_dms_encoding_profile(
            dms_encoding_profiles.get(EncodingProfileType.METADATA.value, [])
        ),
        EncodingProfileType.VIDEO: _hydrate_video_dms_encoding_profile(
            dms_encoding_profiles.get(EncodingProfileType.VIDEO.value, [])
        ),
        EncodingProfileType.VIDEO_IMAGE: _hydrate_image_dms_encoding_profile(
            dms_encoding_profiles.get(EncodingProfileType.VIDEO_IMAGE.value, []),
        ),
    }