"""Test for transcoding rule model."""

from typing import Any
from unittest import mock

import pytest
from sqlalchemy.exc import SQLAlchemyError

from transcoding.constants import error
from transcoding.models import transcoding_rule

from tests.testutils import db, seed


@pytest.fixture
def valid_transcoding_rule_filter_data() -> dict[str, Any]:
    """Get valid data for get_transcoding_rule_by_input_parameters_filter."""
    existed_rule = seed.transcoding_rule_for_specified_filter
    return {
        "preset_id": existed_rule["preset_id"],
        "filter": {
            "container": existed_rule["input_container"],
            "channels": existed_rule["input_channels"],
            "sample_rate": 88200,
            "codec": existed_rule["input_codec"],
        },
    }


@db.test_schema
def test_get_transcoding_rules_by_preset_id_success() -> None:
    """Test successful get of existing transcoding_rule entry."""
    # data preparation
    expected_result = seed.transcoding_rule_seed_data[-2:]  # get last 2 items
    preset_id = expected_result[0]["preset_id"]
    # test function call
    response = transcoding_rule.get_transcoding_rules_by_preset_id(preset_id=preset_id)
    # checking
    assert response
    assert response.status == 200
    assert response.message == expected_result


@db.test_schema
def test_get_transcoding_rules_by_preset_id_failure() -> None:
    """Test get_transcoding_rules_by_preset_id db failure."""
    # data preparation
    error_mock = SQLAlchemyError(500)
    package_path = "transcoding.connectors.mysql.db_session"
    # mocking
    with mock.patch(package_path, side_effect=error_mock):
        # test function call
        response = transcoding_rule.get_transcoding_rules_by_preset_id(preset_id=0)
        # checking
        assert response.status == 500


@db.test_schema
def test_get_transcoding_rule_by_input_parameters_filter_success(
    valid_transcoding_rule_filter_data: dict[str, Any],
) -> None:
    """Test successful of get_transcoding_rule_by_input_parameters_filter."""
    expected_result = [seed.transcoding_rule_for_specified_filter]
    # test function call
    response = transcoding_rule.get_transcoding_rule_by_input_parameters_filter(
        preset_id=valid_transcoding_rule_filter_data["preset_id"],
        input_params_filters=valid_transcoding_rule_filter_data["filter"],
    )
    # checking
    assert response
    assert response.status == 200
    assert response.message == expected_result


@db.test_schema
def test_get_transcoding_rule_by_input_parameters_filter_not_found() -> None:
    """Test get_transcoding_rules not found."""
    # data preparation
    not_existed_id = len(seed.transcoding_rule_seed_data[1]) + 1
    test_filter = {"channels": 2}
    # test function call
    response = transcoding_rule.get_transcoding_rule_by_input_parameters_filter(
        preset_id=not_existed_id, input_params_filters=test_filter
    )
    # checking
    assert response
    assert response.message == []


@db.test_schema
def test_get_transcoding_rule_by_input_parameters_filter_empty_filter() -> None:
    """Test failure of get_transcoding_rule_by_input_parameters_filter."""
    # data preparation
    expected_error = error.ERROR_INVALID_TRANSCODING_RULE_FILTER_MESSAGE.format(
        transcoding_rule.INPUT_AUDIO_META_PARAMETERS
    )
    preset_id = len(seed.transcoding_rule_seed_data[1]) - 1
    test_filter = {"key": 2}
    # test function call
    response = transcoding_rule.get_transcoding_rule_by_input_parameters_filter(
        preset_id=preset_id, input_params_filters=test_filter
    )
    # checking
    assert not response
    assert response.status == 500
    assert response.errors["message"] == expected_error


@db.test_schema
def test_get_transcoding_rule_by_input_parameters_filter_db_failure() -> None:
    """Test failure of get_transcoding_rule_by_input_parameters_filter."""
    # data preparation
    error_mock = SQLAlchemyError(500)
    package_path = "transcoding.connectors.mysql.db_session"
    # mocking
    with mock.patch(package_path, side_effect=error_mock):
        # test function call
        response = transcoding_rule.get_transcoding_rule_by_input_parameters_filter(
            preset_id=0, input_params_filters={}
        )
        # checking
        assert response.status == 500