"""Approval logic."""

from product_review.logic.vapi import vapi_apply_revisions_if_applicable
from product_review.models import approval as approval_model
from product_review.models import (
    canned_response_history as canned_response_history_model,
)
from product_review.models import ows_product_digital
from product_review.models import review_queue as review_queue_model
from product_review.models import splitio as splitio_model
from product_review.util import sfn
from product_review.util.db import db_transaction
from product_review.util.review_queue_item import get_review_queue_item_for_update
from product_review.util.validation import (
    block_invalid_approval,
    create_review_validation_history,
)


@db_transaction
def approve_review_queue_item(review_queue_id, note, user_id, created_datetime=None):
    """Update state to approved."""
    review_queue_item = review_queue_model.validate_for_completion(review_queue_id)
    review_queue_model.approve(review_queue_item)
    approval_model.approve(
        review_queue_id,
        note=note,
        user_id=user_id,
        created_datetime=created_datetime,
    )


def save_approval(review_queue_item, note):
    """Save an approval."""
    # Save records for this service
    review_queue_model.approve(review_queue_item)
    approval_model.approve(review_queue_item.review_queue_id, note=note)
    return vapi_apply_revisions_if_applicable(review_queue_item.review_queue_id)


def apply_revisions_if_applicable(review_queue_id):
    """Apply revisions to a product via legacy vapi."""
    return {"applied_in_legacy": vapi_apply_revisions_if_applicable(review_queue_id)}


def approve_via_workflow(review_queue_id, user_uuid, note, canned_response_id, tracks, canned_response_ids):
    """Save an item as applying and trigger the workflow to save the approval."""
    spotify_watchlist_feature_enabled = splitio_model.is_enabled_pdp_auth_check('content_review_spotify_watchlist')
    with db_transaction:
        item = get_review_queue_item_for_update(review_queue_id)
        product_validation_result = ows_product_digital.validate_product(
            item.product_id
        )
        block_invalid_approval(
            product_validation_result, note, canned_response_id, tracks,
            canned_response_ids, spotify_watchlist_feature_enabled
        )
        create_review_validation_history(
            item.review_queue_id, item.product_id, product_validation_result
        )
        if tracks:
            for track in tracks:
                canned_response_history_model.create_canned_response_history(
                    review_queue_id,
                    track.get('canned_response_id'),
                    track.get("track_id")
                )
        response_ids = (
            canned_response_ids
            if spotify_watchlist_feature_enabled
            else [canned_response_id] if canned_response_id else []
        )
        for response_id in response_ids:
            canned_response_history_model.create_canned_response_history(
                review_queue_id, response_id
            )
        review_queue_model.change_status(item, review_queue_model.STATUS.APPLYING)
    sfn.create_complete_review_sfn_execution(item, "approve", user_uuid, note)