"""Tests for product logic."""

import config
import pytest
from src.constants.urls import OWS_PROJECT_ERROR
from src.logic import product


def test_prepare_doc_delete(mocker, product_delete_input, product_document_fixture):
    """Test prepare_doc successfully."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture

    result = product.prepare_doc(product_delete_input)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "delete",
        "_id": product_delete_input["data"]["release_id"],
        "doc_as_upsert": True,
    }


def test_prepare_doc_update(mocker, product_update_input, product_document_fixture):
    """Test prepare_doc successfully."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture

    result = product.prepare_doc(product_update_input)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_update_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_product_soft_delete(mocker, product_update_input, product_document_fixture):
    """Test prepare_doc successfully."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture
    delete_event = product_update_input.copy()
    delete_event["data"]["deletions"] = "Y"

    result = product.prepare_doc(delete_event)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_update_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_product_incompatible(mocker, product_delete_input):
    """Test prepare cloudsearch document with incompatible format."""
    delete_event = product_delete_input.copy()
    del delete_event["type"]
    doc = product.prepare_doc(delete_event)
    assert doc is None


def test_prepare_doc_insert(mocker, product_insert_input, product_document_fixture):
    """Test prepare_doc successfully."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture

    result = product.prepare_doc(product_insert_input)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_insert_input["data"]["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_product_exclusion(mocker, product_insert_input, product_document_fixture):
    """Test prepare_doc successfully."""
    insert_input = product_insert_input.copy()
    insert_input["data"]["release_id"] = 1982836  # from PRODUCT_SKIP_LIST
    ows_response = product_document_fixture.copy()
    ows_response["release_id"] = 1982836
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = ows_response

    result = product.prepare_doc(insert_input)
    assert result is None


@pytest.mark.parametrize("table_name", ["release_correction", "release_approval_queue"])
def test_prepare_doc_product_add_release_correction_approval(
    mocker, product_document_fixture, table_name, product_insert_input
):
    """Test prepare cloudsearch document for release correction and approval."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture
    event = product_insert_input.copy()
    event["type"] = "delete"
    event["table"] = table_name

    doc = product.prepare_doc(event)
    assert doc == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_document_fixture["release_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_product_error(mocker, product_insert_input):
    """Test prepare cloudsearch document ows-product error."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.side_effect = Exception(OWS_PROJECT_ERROR)

    with pytest.raises(Exception, match=OWS_PROJECT_ERROR):
        product.prepare_doc(product_insert_input)


def test_prepare_doc_from_track_additional_isrc(
    mocker, track_additional_isrc_insert_input, product_document_fixture, get_track_by_tuid_fixture
):
    """Test prepare_doc_from_track_additional_isrc successfully."""
    mocked_track = mocker.patch("src.logic.product.ows_track.get_track_by_tuid")
    mocked_track.return_value = get_track_by_tuid_fixture
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture

    result = product.prepare_doc_from_track_additional_isrc(track_additional_isrc_insert_input)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": get_track_by_tuid_fixture["product_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }
    mocked_track.assert_called_once_with(track_additional_isrc_insert_input["data"]["track_id"])


def test_prepare_doc_from_track_additional_isrc_no_data(mocker, track_additional_isrc_insert_input):
    """Test prepare_doc_from_track_additional_isrc returns None when data is missing."""
    event = track_additional_isrc_insert_input.copy()
    del event["data"]
    result = product.prepare_doc_from_track_additional_isrc(event)
    assert result is None


def test_prepare_doc_from_track_additional_isrc_no_track_id(
    mocker, track_additional_isrc_insert_input
):
    """Test prepare_doc_from_track_additional_isrc returns None when track_id is missing."""
    event = track_additional_isrc_insert_input.copy()
    event["data"] = {}
    result = product.prepare_doc_from_track_additional_isrc(event)
    assert result is None


def test_prepare_doc_from_track_additional_isrc_bad_track(
    mocker, track_additional_isrc_insert_input
):
    """Test prepare_doc_from_track_additional_isrc returns None when track has no product_id."""
    mocked_track = mocker.patch("src.logic.product.ows_track.get_track_by_tuid")
    mocked_track.return_value = {}
    result = product.prepare_doc_from_track_additional_isrc(track_additional_isrc_insert_input)
    assert result is None


def test_prepare_doc_from_product_additional_upc(
    mocker, product_additional_upc_insert_input, product_document_fixture
):
    """Test prepare_doc_from_product_additional_upc successfully."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture

    result = product.prepare_doc_from_product_additional_upc(product_additional_upc_insert_input)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_additional_upc_insert_input["data"]["product_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_from_product_additional_upc_indexes_any_type(
    mocker, product_additional_upc_insert_input, product_document_fixture
):
    """Any recording type re-indexes the product, so new types flow in automatically."""
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture
    event = product_additional_upc_insert_input.copy()
    event["data"] = {**event["data"], "type": "sony360"}

    result = product.prepare_doc_from_product_additional_upc(event)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": product_additional_upc_insert_input["data"]["product_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }


def test_prepare_doc_from_product_additional_upc_no_product_id(product_additional_upc_insert_input):
    """Missing product_id returns None."""
    event = product_additional_upc_insert_input.copy()
    event["data"] = {**event["data"], "product_id": None}
    assert product.prepare_doc_from_product_additional_upc(event) is None


def test_prepare_doc_from_track_additional_isrc_indexes_any_type(
    mocker, track_additional_isrc_insert_input, product_document_fixture, get_track_by_tuid_fixture
):
    """Any recording type re-indexes the product, so new types flow in automatically."""
    mocked_track = mocker.patch("src.logic.product.ows_track.get_track_by_tuid")
    mocked_track.return_value = get_track_by_tuid_fixture
    mocked_ows = mocker.patch("src.logic.product.ows_product.get_product_document")
    mocked_ows.return_value = product_document_fixture
    event = track_additional_isrc_insert_input.copy()
    event["data"] = {**event["data"], "type": "sony360"}

    result = product.prepare_doc_from_track_additional_isrc(event)
    assert result == {
        "_index": config.PRODUCT_INDEX_NAME,
        "_op_type": "update",
        "_id": get_track_by_tuid_fixture["product_id"],
        "doc": product_document_fixture,
        "doc_as_upsert": True,
    }