"""Model for Match Audio.

This model is used to retrieve results from a process that matches audio from asset_final records
with publicly released audio.
"""

import json
from typing import Any

from assets import config
from assets.connectors.dynamodb import ddb_connector


def _get_match_audio_results(asset_final_ids: list[int]) -> list[dict[str, Any]]:
    """Get match audio results from dynamo."""
    match_audio_results = ddb_connector.batch_get_items(
        config.MATCH_AUDIO_DYNAMODB_TABLE_NAME,
        "asset_final_id",
        asset_final_ids,
        "asset_final_id,matches",
    )
    queried_asset_final_ids = set(asset_final_ids)
    found_asset_final_ids = {
        match_audio_result["asset_final_id"]
        for match_audio_result in match_audio_results
    }
    not_found_asset_final_ids = queried_asset_final_ids - found_asset_final_ids
    for not_found_asset_final_id in not_found_asset_final_ids:
        match_audio_results.append(
            {
                "asset_final_id": not_found_asset_final_id,
                "matches": "null",
            }
        )

    return match_audio_results


def _filter_match_audio_result(matches: list[dict[str, Any]]) -> list[dict[str, Any]]:
    """Filter match audio result."""
    filtered_matches = []
    for match in matches:
        label = match.get("label")
        if label and label.lower().startswith("orchard - "):
            continue

        rights_claim = match.get("rights_claim")
        if rights_claim:
            include_match = True
            for claim in rights_claim:
                name = claim.get("distributor", {}).get("name")
                if name and name.lower() == "the orchard enterprises":
                    include_match = False
                    break
            if not include_match:
                continue

        filtered_matches.append(match)

    return filtered_matches


def _format_match_audio_result(
    track_id: int, asset_final_id: int, matching_result: dict[str, Any]
) -> dict[str, Any]:
    """Format match audio result."""
    if not matching_result:
        return {
            "track_id": track_id,
            "asset_final_id": asset_final_id,
            "code": "WARNING_UNCHECKED_AUDIO",
        }

    if not matching_result["matches"]:
        filtered_matches = None
    else:
        filtered_matches = _filter_match_audio_result(matching_result["matches"])

    if not filtered_matches:
        return {
            "track_id": track_id,
            "asset_final_id": asset_final_id,
            "code": "PASS_NO_MATCHES",
        }

    return {
        "track_id": track_id,
        "asset_final_id": asset_final_id,
        "code": "WARNING_MATCHES_FOUND",
        "matches": filtered_matches,
    }


def get_match_audio_results(
    asset_final_id_to_track_id: dict[int, int],
) -> list[dict[str, Any]]:
    """Get match audio results for asset_final items."""
    asset_final_ids = list(asset_final_id_to_track_id.keys())

    match_audio_results = _get_match_audio_results(asset_final_ids)
    return [
        _format_match_audio_result(
            track_id=asset_final_id_to_track_id[match_audio_result["asset_final_id"]],
            asset_final_id=int(match_audio_result["asset_final_id"]),
            matching_result=json.loads(match_audio_result["matches"]),
        )
        for match_audio_result in match_audio_results
    ]