"""Track logic."""

from typing import Any, Dict, Optional

import config
from lambdacommon.common_config import logger

from src.constants import fields
from src.logic.types import OpensearchBulkDocument
from src.models import ows_product, ows_track
from src.utils.document import cleanup_unicode, prepare_for_upload
from src.utils.parser import parse_spec_file


def prepare_doc(event: dict[str, Any]) -> Optional[OpensearchBulkDocument]:
    """Construct an Opensearch document for the track index.

    Args:
        event (dict): event with track data from Maxwell's

    Returns:
        dict: Opensearch document ready for upload

    """
    json_doc: Dict[str, Any] = {}
    doc_type = "update"
    event_type = event.get("type")
    if not event_type or event.get("_metadata"):
        logger.warning("An event with incompatible format received: %s", event)
        return None

    if event_type == "delete":
        doc_type = "delete"

    track_id = event["data"]["id"]
    release_id = event["data"]["release_id"] or 0

    if doc_type == "update":
        track = ows_track.get_track_artist_info(track_id)
        release = ows_product.get_release_info(release_id)
        # set defaults per data type
        json_doc = {
            "track_unique_id": track_id,
            "isrc": event["data"]["isrc"] or "",
            "release_id": release_id,
            "track_name": cleanup_unicode(event["data"]["track_name"]) or "",
            "version": event["data"]["version"] or "",
            "cd": event["data"]["cd"] or 0,
            "track_id": event["data"]["track_id"] or 0,
            "track_type": event["data"]["track_type"] or "",
            "original_file_name": cleanup_unicode(event["data"]["original_file_name"]) or "",
        }
        json_doc.update(track)
        json_doc.update(release)
    if release_id in fields.PRODUCT_EXCLUSION_LIST:
        # Delete the Opensearch record for exclusion list
        doc_type = "delete"

    doc: OpensearchBulkDocument = {
        "_index": config.TRACK_INDEX_NAME,
        "_op_type": doc_type,
        "_id": track_id,  # no prefix like CS key.
        "doc": json_doc,
        # with this it will do upsert and not return NOT_FOUND error.
        "doc_as_upsert": True,
    }
    logger.info(f"{doc_type} track with id {track_id}")
    return prepare_for_upload(parse_spec_file("tracks"), doc)


def prepare_release_tracks_docs(record_json: dict[str, Any]) -> list[OpensearchBulkDocument]:
    """Construct Opensearch documents for the all tracks of the release for track corpus.

    Args:
        record_json (dict): record_json with release data from Maxwell's

    Returns:
        list of dicts: Opensearch tracks documents ready for upload

    """
    tracks_json_docs = []
    old_release_data = record_json["old"]
    updated_release_data = record_json["data"]
    release_id = updated_release_data["release_id"]
    updated_release_status = updated_release_data.get("release_status")
    old_release_status = old_release_data.get("release_status")

    if (
        updated_release_status == fields.STATUS_IN_CONTENT
        and old_release_status == fields.STATUS_TRANSFER_TO_CONTENT
    ):
        tracks = ows_track.get_all_tracks_by_product_id(release_id)
        if tracks:
            release = ows_product.get_release_info(release_id)

        for track in tracks:
            track_data = {"track_unique_id": track["tuid"], "release_id": release_id}
            track_data.update(track)
            track_data.update(release)
            doc: OpensearchBulkDocument = {
                "_index": config.TRACK_INDEX_NAME,
                "_op_type": "update",
                "_id": track_data["track_unique_id"],  # no prefix like CS key.
                "doc": track_data,
                # with this it will do upsert and not return NOT_FOUND error.
                "doc_as_upsert": True,
            }
            parsed_doc = prepare_for_upload(parse_spec_file("tracks"), doc)
            if parsed_doc:
                tracks_json_docs.append(parsed_doc)

    return tracks_json_docs