"""Lambda get-asset-locations."""

import json
from os.path import splitext
from typing import Any

import boto3

from src.config import AUDIO_ASSET_TYPES, S3_BUCKET, VIDEO_ASSET_TYPES
from src.ows_assets import get_music_assets_for_products
from src.ows_clients import ows_client
from src.ows_track import get_tracks_for_product
from src.ows_video import get_video_assets_for_products

s3 = boto3.resource("s3")


def handler(event: Any, context: Any) -> dict[str, str | int]:
    """Lambda entry point."""
    product_ids = list(map(int, event["product_ids"]))
    asset_types = event["asset_types"]
    execution_name = event["execution_name"]
    export_id = event["export_id"]
    part_index = int(event["part_index"])

    music_products: dict[int, list[Any]] = {}
    video_products: dict[int, list[Any]] = {}

    ows_track_response = get_tracks_for_product(ows_client, product_ids)
    track_data = json.loads(ows_track_response.content.decode("utf-8"))
    for track in track_data["items"]:
        if track["track_type"] == "music":
            music_products.setdefault(track["product_id"], [])
            music_products[track["product_id"]].append(track)
        elif track["track_type"] == "video":
            video_products.setdefault(track["product_id"], [])
            video_products[track["product_id"]].append(track)

    asset_locations: list[dict[str, str]] = []
    music_assets = get_music_assets(
        set(music_products.keys()), set(asset_types).intersection(AUDIO_ASSET_TYPES)
    )
    add_asset_locations(music_assets, music_products, asset_locations)

    video_assets = get_video_assets(
        set(video_products.keys()), set(asset_types).intersection(VIDEO_ASSET_TYPES)
    )
    add_asset_locations(video_assets, video_products, asset_locations)

    upload_to_s3(
        f"{export_id}/{execution_name}/asset_locations_{part_index}.json",
        json.dumps(
            {"execution_name": execution_name, "asset_locations": asset_locations}
        ),
    )

    return {
        "execution_name": execution_name,
        "export_id": export_id,
        "part_index": part_index,
    }


def upload_to_s3(filename: str, json_data: str) -> None:
    s3.Object(S3_BUCKET, filename).put(Body=json_data, ContentType="application/json")


def get_music_assets(product_ids: set[int], asset_types: set[str]) -> Any | None:
    if not product_ids or not asset_types:
        return None

    ows_assets_response = get_music_assets_for_products(
        ows_client, product_ids, asset_types
    )
    if ows_assets_response.status_code != 200:
        return None

    return json.loads(ows_assets_response.content.decode("utf-8"))


def get_video_assets(product_ids: set[int], asset_types: set[str]) -> Any | None:
    if not product_ids or not asset_types:
        return None

    ows_video_response = get_video_assets_for_products(
        ows_client, product_ids, asset_types
    )
    if ows_video_response.status_code != 200:
        return None

    return json.loads(ows_video_response.content.decode("utf-8"))


def add_asset_locations(
    assets: Any | None,
    products: dict[int, list[Any]],
    asset_locations: list[dict[str, str]],
) -> None:
    if not assets:
        return

    for asset in assets:
        if not asset["tuid"] and asset["asset_type"].lower() == "tif":
            track = products[asset["product_id"]][0]
            asset_locations.append(
                {
                    "source": "/".join([asset["s3_bucket"], asset["s3_key"]]),
                    "destination": "/".join(
                        [
                            str(track["upc"]),
                            str(track["upc"]) + splitext(asset["s3_key"])[1],
                        ]
                    ),
                }
            )
        else:
            for track in products[asset["product_id"]]:
                if track["tuid"] != asset["tuid"]:
                    continue

                asset_locations.append(
                    {
                        "source": "/".join([asset["s3_bucket"], asset["s3_key"]]),
                        "destination": "/".join(
                            [
                                str(track["upc"]),
                                "_".join(
                                    [
                                        str(track["upc"]),
                                        str(track["volume_number"]),
                                        str(track["track_number"]),
                                    ]
                                )
                                + splitext(asset["s3_key"])[1],
                            ]
                        ),
                    }
                )