"""Vapi apply logic."""

import json
from urllib import parse

from product_review.constants.localized_metadata import (
    LOCALIZABLE_PRODUCT_ARTIST_FIELDS,
    LOCALIZABLE_TRACK_ARTIST_FIELDS,
)
from product_review.models import ows_assets
from product_review.models import ows_product as ows_product_model
from product_review.models import ows_product_workflow
from product_review.models import ows_track as ows_track_model
from product_review.models import review_queue as review_queue_model
from product_review.models import vapi


def _format_release_and_track_localized_data(
    localized_product_fields, localized_track_fields
):
    release_revisions = (
        _urlencode_revision_info(localized_product_fields)
        if localized_product_fields
        else None
    )
    tracks_revisions = [
        _urlencode_revision_info(track_revisions)
        for track_revisions in localized_track_fields or []
    ] or None

    return {
        "release_revisions": release_revisions,
        "tracks_revisions": tracks_revisions,
    }


def vapi_apply_revisions_if_applicable(review_queue_id):
    """Apply revisions in VAPI if error corrections exist."""
    product_id = _get_product_id(review_queue_id)
    if not product_id:
        return False
    product_data = ows_product_model.get_product(product_id)
    if not product_data or product_data.get("status") != "in_content":
        return False
    revisions = ows_product_workflow.get_submitted_revisions(product_id)
    if not revisions:
        return False

    product_id = revisions["release_id"]
    ows_assets.validate_audio(product_id)
    vapi.approve_revised_product(product_id)
    ows_assets.apply_corrections(product_id)
    _save_revised_localized_fields(revisions)
    return True


def _save_revised_localized_fields(product_with_revisions):
    product_id = product_with_revisions["release_id"]

    revisions = product_with_revisions["items"]
    should_fetch_localized_product_fields = False
    should_fetch_localized_track_fields = False
    for revision in revisions:
        table_name = revision["table_name"]
        field_name = revision["field_name"]

        should_fetch_localized_product_fields = (
            should_fetch_localized_product_fields
            or (
                table_name == "releases"
                and field_name in LOCALIZABLE_PRODUCT_ARTIST_FIELDS
            )
        )
        should_fetch_localized_track_fields = should_fetch_localized_track_fields or (
            table_name == "track" and field_name in LOCALIZABLE_TRACK_ARTIST_FIELDS
        )

    localized_product_fields = None
    if should_fetch_localized_product_fields:
        localized_product_fields = _format_get_product_localization_response(
            ows_product_model.get_product_localization(product_id)
        )

    localized_track_fields = None
    if should_fetch_localized_track_fields:
        localized_track_fields = _format_get_tracks_on_product_response(
            ows_track_model.get_tracks_on_product(product_id)
        )

    release_and_track_localized_data = _format_release_and_track_localized_data(
        localized_product_fields, localized_track_fields
    )

    release_localized_revisions = release_and_track_localized_data["release_revisions"]
    tracks_localized_revisions = release_and_track_localized_data["tracks_revisions"]
    if release_localized_revisions:
        vapi.save_revised_localized_product_fields(release_localized_revisions)
    if tracks_localized_revisions:
        for track_revisions in tracks_localized_revisions:
            vapi.save_revised_localized_track_fields(track_revisions)


def _format_get_product_localization_response(get_product_localization_response):
    formatted_response = {
        "releaseId": get_product_localization_response["product_id"],
        "releaseName": [],
        "releaseArtist": {},
    }
    localizations = get_product_localization_response["items"]

    if not localizations:
        return None

    for localization in localizations:
        language_id = localization["language_id"]
        formatted_response["releaseName"].append(
            {
                "languageId": language_id,
                "value": localization["product_name"],
            }
        )

        map_input_field_to_output_field = {
            "primary_artist": "performer",
            "remixer": "remixer",
            "featuring": "featuring",
            "orchestra": "orchestra",
            "conductor": "conductor",
            "composer": "composer",
            "ensemble": "ensemble",
            "producer": "producer",
        }
        for input_field, output_field in map_input_field_to_output_field.items():
            if not localization.get(input_field):
                continue

            if not formatted_response["releaseArtist"].get(output_field):
                formatted_response["releaseArtist"][output_field] = {}
            formatted_response["releaseArtist"][output_field][language_id] = []

            for artist in localization.get(input_field).values():
                formatted_response["releaseArtist"][output_field][language_id].append(
                    {"artist": artist}
                )

    return formatted_response


def _format_get_tracks_on_product_response(get_tracks_on_product_response):
    formatted_response = []

    for track in get_tracks_on_product_response["items"]:
        track_id = track["tuid"]
        formatted_track = {"trackId": track_id, "trackArtist": {}}
        localizations = track["localizations"]

        if not localizations:
            continue

        for localization in localizations:
            language_id = localization["language_id"]

            for artist in localization["artists"]:
                artist_type = artist["type"]
                if not formatted_track["trackArtist"].get(artist_type):
                    formatted_track["trackArtist"][artist_type] = {}
                if not formatted_track["trackArtist"][artist_type].get(track_id):
                    formatted_track["trackArtist"][artist_type][track_id] = {}
                if not formatted_track["trackArtist"][artist_type][track_id].get(
                    language_id
                ):
                    formatted_track["trackArtist"][artist_type][track_id][
                        language_id
                    ] = []

                formatted_track["trackArtist"][artist_type][track_id][
                    language_id
                ].append({"artist": artist["name"]})

        formatted_response.append(formatted_track)

    return formatted_response or None


def _get_product_id(review_queue_id):
    """Return the product id for a review queue item."""
    review_queue_items, _ = review_queue_model.get_items(
        status=(review_queue_model.STATUS.NEW, review_queue_model.STATUS.APPLYING),
        review_queue_id=review_queue_id,
    )

    if not review_queue_items:
        return None

    return review_queue_items[0].product_id


def _urlencode_revision_info(revision_info):
    return parse.quote(json.dumps(revision_info).replace(" ", ""))