"""Lambda set_product function module."""

from typing import Any

from common.connectors.graphql import obo_graphql as graphql_common
from common.schemas.ingestion import Event, ProductInfo
from lambdacommon.common_config import logger

from src.connectors import graphql
from src.constants import PricingTypes
from src.exceptions import CreateProductException
from src.logic import get_product


def handle(
    product_info: ProductInfo,
    ingestion_id: str,
    execution_arn: str,
    correlation_id: str,
    identity_uuid: str,
) -> ProductInfo:
    """
    Checks if a product exists by its product_code and account data. Updates the existing
    product if one is found. Create a new product otherwise, set pricing data for the product.

    Raises:
        CreateProductException: If product creation or update fails.
        DuplicateProductCodeException: If a product with the same product_code already exists.
    """
    product, project = product_info.product, product_info.project
    if not product.vendor_id or not product.vendor_uuid:
        error = f"Vendor data is unfilled for Product<product_code={product.release_reference}>."
        logger.error(f"{error}.\n{product}")
        raise CreateProductException(error)

    if product.subaccount_id and not product.subaccount_uuid:
        error = f"Subaccount data is inconsistent for Product<product_code={product.release_reference}>."
        logger.error(f"{error}.\n{product}")
        raise CreateProductException(error)

    if not project.bulk_session_ingestion_project_id:
        error = f"Bulk Session Ingestion Project ID is missing for Project<project_id={project.project_id}>."
        logger.error(f"{error}.\n{project}")
        raise CreateProductException(error)

    graphql.init(correlation_id, identity_uuid)

    get_product_result = get_product(product)
    if get_product_result:
        product.product_id = get_product_result.product_id
        product.upc = get_product_result.upc

        graphql.update_product(product)
    else:
        create_product_result = graphql.create_product(
            product,
            project.project_id,  # type: ignore
            product.vendor_id,
            product.subaccount_id,
        )

        product.product_id = create_product_result.product_id
        product.upc = create_product_result.upc

    result = graphql_common.upsert_bulk_session_ingestion_product(
        bulk_session_ingestion_id=ingestion_id,
        bulk_session_ingestion_project_id=project.bulk_session_ingestion_project_id,
        execution_arn=execution_arn,
        product_code=product.release_reference,
        product_id=product.product_id,
        upc=product.upc,
    )

    ingestion_product_id = result.id if result else None
    product_info.product.ingestion_product_id = ingestion_product_id

    if not ingestion_product_id:
        error = (
            f"Failed to upsert Bulk Session Ingestion Product for "
            f"Product<product_code={product.release_reference}>."
        )
        logger.error(error)
        raise CreateProductException(error)

    logger.info(f"Bulk Session Ingestion Product <{ingestion_product_id}> was updated.")

    graphql.update_product_pricing(product, PricingTypes.ALBUM)
    logger.info(f"Pricing for product <{product.product_id}> (album) was set.")

    graphql.update_product_pricing(product, PricingTypes.TRACK)
    logger.info(f"Pricing for product <{product.product_id}> (track) was set.")

    return product_info


def handler(event_data: dict[str, Any], context: Any) -> dict[str, Any]:
    """
    Lambda entry point.

    Args:
        event_data: Lambda event payload (should look like event.shadow.json)
        context: Lambda context.
    """
    event = Event(**event_data)
    product_info = event.product_info
    ingestion_id = event.bulk_session_ingestion_id
    execution_arn = event.execution_arn
    correlation_id = event.correlation_id
    identity_uuid = event.identity_uuid
    assert execution_arn

    event.product_info = handle(
        product_info, ingestion_id, execution_arn, correlation_id, identity_uuid
    )
    return event.model_dump()