"""Test validation utils."""

import json
from contextlib import nullcontext as does_not_raise
from unittest.mock import call

import pytest

from product_review.api import db
from product_review.models import ows_product_digital as ows_product_digital_model
from product_review.models import (
    review_validation_history as review_validation_history_model,
)
from product_review.models import splitio as splitio_model
from product_review.util import validation as validation_util


@pytest.mark.parametrize(
    (
        "test_description",
        "is_enabled_prevent_approval_with_blockers",
        "note",
        "canned_response_id",
        "tracks",
        "expected_is_product_valid_calls",
        "is_product_valid_result",
        "expected_select_potential_audio_infringement_track_warnings_calls",
        "select_potential_audio_infringement_track_warnings_result",
        "expected_raise",
        "canned_response_ids",
        "spotify_watchlist_feature_enabled",
    ),
    [
        (
            "prevent_approval_with_blockers disabled and no potential_audio_infringement track warning",  # noqa: E501
            False,
            None,
            None,
            [],
            [call("product_validation_result")],
            False,
            [call("product_validation_result")],
            [],
            does_not_raise(),
            [],
            False,
        ),
        (
            "Product errors block approval.",
            True,
            None,
            None,
            [],
            [call("product_validation_result")],
            False,
            [],
            ["potential_audio_infringement_track_warning"],
            pytest.raises(
                Exception,
                match=json.dumps(
                    {
                        "status": 400,
                        "code": "product_errors_block_approval",
                        "message": "product_validation_result",
                    }
                ),
            ),
            [],
            False,
        ),
        (
            "Has potential_audio_infringement track warning with approval note and track approval reasons are None.",  # noqa: E501
            True,
            "because",
            None,
            None,
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 121,
                "warning": "potential_audio_infringement_track_warning"
            }],
            pytest.raises(
                Exception,
                match=json.dumps(
                    {
                        "status": 400,
                        "code": "track_approval_reasons_required",  # noqa: E501
                        "message": "Due to potential audio infringement, track approval reasons are required for all tracks with the warning.",  # noqa: E501
                    }
                ),
            ),
            [],
            False,
        ),
        (
            "Has potential_audio_infringement track warning with approval note and no track approval reasons.",  # noqa: E501
            True,
            "because",
            None,
            [],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 123,
                "warning": "potential_audio_infringement_track_warning"
            }],
            pytest.raises(
                Exception,
                match=json.dumps(
                    {
                        "status": 400,
                        "code": "track_approval_reasons_required",  # noqa: E501
                        "message": "Due to potential audio infringement, track approval reasons are required for all tracks with the warning.",  # noqa: E501
                    }
                ),
            ),
            [],
            False,
        ),
        (
            "Has potential_audio_infringement track warning with approval note and has track approval reasons.",  # noqa: E501
            True,
            "because",
            None,
            [{"track_id": 123, "canned_response_id": 66}],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 123,
                "warning": "potential_audio_infringement_track_warning"
            }],
            does_not_raise(),
            [],
            False,
        ),
        (
            "Has potential_audio_infringement track warning w/ bulk approval canned response.",  # noqa: E501
            True,
            None,
            121,
            [],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 123,
                "warning": "potential_audio_infringement_track_warning"
            }],
            does_not_raise(),
            [],
            False,
        ),
        (
            "Has potential_audio_infringement track warning w/ bulk approval canned response using canned_response_ids and spotify watchlist enabled.",  # noqa: E501
            True,
            None,
            None,
            [],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 123,
                "warning": "potential_audio_infringement_track_warning"
            }],
            does_not_raise(),
            [121],
            True,
        ),
        (
            "Has potential_audio_infringement track warning w/ bulk approval note.",  # noqa: E501
            True,
            "Bulk approved",
            None,
            [],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [{
                "track_id": 123,
                "warning": "potential_audio_infringement_track_warning"
            }],
            does_not_raise(),
            [],
            False,
        ),
        (
            "Valid approval.",
            True,
            None,
            None,
            [],
            [call("product_validation_result")],
            True,
            [call("product_validation_result")],
            [],
            does_not_raise(),
            [],
            False,
        ),
    ],
)
def test_block_invalid_approval(
    mocker,
    test_description,
    is_enabled_prevent_approval_with_blockers,
    note,
    canned_response_id,
    tracks,
    expected_is_product_valid_calls,
    is_product_valid_result,
    expected_select_potential_audio_infringement_track_warnings_calls,
    select_potential_audio_infringement_track_warnings_result,
    expected_raise,
    canned_response_ids,
    spotify_watchlist_feature_enabled,
):
    """Test _block_invalid_approval."""
    mocker.patch.object(
        splitio_model,
        "is_enabled_prevent_approval_with_blockers",
        return_value=is_enabled_prevent_approval_with_blockers,
    )
    mocker.patch.object(
        ows_product_digital_model,
        "is_product_valid",
        return_value=is_product_valid_result,
    )
    mocker.patch.object(
        ows_product_digital_model,
        "select_potential_audio_infringement_track_warnings",
        return_value=select_potential_audio_infringement_track_warnings_result,
    )

    result = None
    with expected_raise:
        result = validation_util.block_invalid_approval(
            "product_validation_result", note, canned_response_id, tracks,
            canned_response_ids, spotify_watchlist_feature_enabled,
        )

    assert (
        ows_product_digital_model.is_product_valid.mock_calls
        == expected_is_product_valid_calls
    )
    assert (
        ows_product_digital_model.select_potential_audio_infringement_track_warnings.mock_calls  # noqa: E501
        == expected_select_potential_audio_infringement_track_warnings_calls
    )

    assert result is None


@pytest.mark.parametrize(
    (
        "test_description",
        "mock_review_queue_id",
        "mock_product_id",
        "mock_validation_results",
        "expected_result",
    ),
    [
        (
            "create record filter by valid code",
            2,
            4444,
            {
                "is_valid": True,
                "errors": [],
                "warnings": [],
                "tracks": {
                    "111": {
                        "is_valid": True,
                        "tuid": 111,
                        "errors": [],
                        "warnings": [{"code": "HELLO", "reason": "reason_1"}],
                    },
                    "222": {
                        "is_valid": True,
                        "tuid": 222,
                        "errors": [],
                        "warnings": [{"code": "HELLO", "reason": "reason_1"}],
                    },
                    "125": {
                        "is_valid": True,
                        "tuid": 125,
                        "errors": [],
                        "warnings": [
                            {
                                "code": "POTENTIAL_AUDIO_INFRINGEMENT",
                                "reason": '[{"key1":"anything2"}]',
                            }
                        ],
                    },
                },
            },
            {
                "total_count": 3,
                "data": [
                    {
                        "expected_track_id": 125,
                        "expected_validation_code": "POTENTIAL_AUDIO_INFRINGEMENT",
                        "expected_details": [{"key1": "anything2"}],
                    }
                ],
            },
        ),
    ],
)
def test_create_review_validation_history(
    test_description,
    mock_review_queue_id,
    mock_product_id,
    mock_validation_results,
    expected_result,
):
    """Test create review validation history."""
    validation_util.create_review_validation_history(
        mock_review_queue_id, mock_product_id, mock_validation_results
    )
    db.session.commit()
    results, total_count = review_validation_history_model.get_history(
        mock_review_queue_id
    )
    assert total_count == expected_result["total_count"], results
    if expected_result["data"]:
        expected_data = expected_result["data"][0]
        assert results[2].track_id == expected_data["expected_track_id"]
        assert results[2].validation_code == expected_data["expected_validation_code"]
        assert results[2].details == expected_data["expected_details"]