"""Tests for transcoding creating logic module."""

from typing import Any

import pytest
from flexmock import flexmock
from owsresponse import response

from transcoding import config
from transcoding.constants import error
from transcoding.logic import create_transcoding, transcoding_order
from transcoding.models import (
    preset as preset_model,
    transcoding_rule as transcoding_rule,
)
from transcoding.utils import transcoding_rule_constructor

from tests.testutils import seed


@pytest.fixture
def input_create_transcoding_fixture() -> dict[str, Any]:
    """Fixture for input params for transcoding workflow starting."""
    return {
        "input_bucket": "ows-transcoding-raw",
        "input_key": "4e6e4670-03f4-4a34-8d92-123123dc.wav",
        "status_topic_alias": "custom_topic_alias",
        "preset_id": 5,
        "preset_alias": "youtube",
    }


@pytest.fixture
def result_create_transcoding_fixture() -> dict[str, Any]:
    """Return response data for post transcoding module."""
    source_transcoding_rules = seed.transcoding_rule_seed_data[-2:]
    source_asset_metadata = {
        "channels": 2,
        "codec": "pcm",
        "bit_rate": 1411200,
        "sample_rate": 44100,
        "bit_depth": 16,
        "container": "wave",
    }
    transformed_rules = transcoding_rule_constructor.construct_rules(
        transcoding_rules=source_transcoding_rules,
        source_asset_metadata=source_asset_metadata,
    )
    preset = seed.preset_seed_data[-1]
    output_bucket = preset["output_bucket"]
    sns_topic = preset["output_bucket"]
    return {
        "preset": response.Response(preset),
        "output_bucket": output_bucket,
        "sns_topic": sns_topic,
        "rules": response.Response(source_transcoding_rules),
        "metadata_extractor": source_asset_metadata,
        "transformed_rules": transformed_rules,
        "job_validation": response.Response(transformed_rules),
    }


def test_create_transcoding_by_preset_success_with_metadata(
    input_create_transcoding_fixture: dict[str, Any],
    result_create_transcoding_fixture: dict[str, Any],
) -> None:
    """Test for successful starting transcoding workflow by preset."""
    # data preparation
    expected_message = "transcoding_order_creation_result"
    # mocking
    (
        flexmock(preset_model)
        .should_receive("get_preset_by_alias")
        .with_args(input_create_transcoding_fixture["preset_alias"])
        .and_return(result_create_transcoding_fixture["preset"])
    )

    (
        flexmock(transcoding_rule)
        .should_receive("get_transcoding_rule_by_input_parameters_filter")
        .with_args(
            input_create_transcoding_fixture["preset_id"],
            result_create_transcoding_fixture["metadata_extractor"],
        )
        .and_return(result_create_transcoding_fixture["rules"])
    )

    (
        flexmock(create_transcoding)
        .should_receive("create_transcoding")
        .with_args(
            input_create_transcoding_fixture["input_bucket"],
            input_create_transcoding_fixture["input_key"],
            result_create_transcoding_fixture["rules"].message,
            result_create_transcoding_fixture["output_bucket"],
            input_create_transcoding_fixture["preset_id"],
            input_create_transcoding_fixture["status_topic_alias"],
            result_create_transcoding_fixture["metadata_extractor"],
        )
        .and_return(response.Response(expected_message))
    )
    # test function call
    result = create_transcoding.create_transcoding_by_preset(
        input_create_transcoding_fixture["input_bucket"],
        input_create_transcoding_fixture["input_key"],
        input_create_transcoding_fixture["preset_alias"],
        input_create_transcoding_fixture["status_topic_alias"],
        result_create_transcoding_fixture["metadata_extractor"],
    )
    # checking
    assert result
    assert result.message == expected_message


@pytest.mark.parametrize("not_found_response_key", ["preset", "rules"])
def test_create_transcoding_by_preset_not_found_failure(
    not_found_response_key: str,
    input_create_transcoding_fixture: dict[str, Any],
    result_create_transcoding_fixture: dict[str, Any],
) -> None:
    """Test for failure call of create_transcoding_by_preset."""
    # data preparation
    result_create_transcoding_fixture[not_found_response_key] = (
        response.create_not_found_response()
    )
    # mocking
    (
        flexmock(preset_model)
        .should_receive("get_preset_by_alias")
        .with_args(input_create_transcoding_fixture["preset_alias"])
        .and_return(result_create_transcoding_fixture["preset"])
    )

    (
        flexmock(transcoding_rule)
        .should_receive("get_transcoding_rule_by_input_parameters_filter")
        .with_args(
            input_create_transcoding_fixture["preset_id"],
            result_create_transcoding_fixture["metadata_extractor"],
        )
        .and_return(result_create_transcoding_fixture["rules"])
    )
    # test function call
    result = create_transcoding.create_transcoding_by_preset(
        input_create_transcoding_fixture["input_bucket"],
        input_create_transcoding_fixture["input_key"],
        input_create_transcoding_fixture["preset_alias"],
        input_create_transcoding_fixture["status_topic_alias"],
        result_create_transcoding_fixture["metadata_extractor"],
    )
    # checking
    assert not result
    assert result.status == 404


def test_create_transcoding_by_preset_empty_rule_list_failure(
    input_create_transcoding_fixture: dict[str, Any],
    result_create_transcoding_fixture: dict[str, Any],
) -> None:
    """Test for failure of create_transcoding_by_preset with empty rules."""
    # data preparation
    error_message = error.ERROR_MESSAGE_TRANSCODING_RULES_NOT_FOUND
    # mocking
    (
        flexmock(preset_model)
        .should_receive("get_preset_by_alias")
        .with_args(input_create_transcoding_fixture["preset_alias"])
        .and_return(result_create_transcoding_fixture["preset"])
    )

    (
        flexmock(transcoding_rule)
        .should_receive("get_transcoding_rule_by_input_parameters_filter")
        .with_args(
            input_create_transcoding_fixture["preset_id"],
            result_create_transcoding_fixture["metadata_extractor"],
        )
        .and_return(response.Response(message=[]))
    )

    # test function call
    result = create_transcoding.create_transcoding_by_preset(
        input_create_transcoding_fixture["input_bucket"],
        input_create_transcoding_fixture["input_key"],
        input_create_transcoding_fixture["preset_alias"],
        input_create_transcoding_fixture["status_topic_alias"],
        result_create_transcoding_fixture["metadata_extractor"],
    )
    # checking
    assert not result
    assert result.errors["message"] == error_message


@pytest.mark.parametrize(
    "input_bucket, expected_bucket",
    [("youtube", "youtube"), (None, config.TRANSCODED_ASSETS_BUCKET_NAME)],
)
def test_create_transcoding_success(
    input_bucket: str,
    expected_bucket: str,
    input_create_transcoding_fixture: dict[str, Any],
    result_create_transcoding_fixture: dict[str, Any],
) -> None:
    """Test for successful starting transcoding workflow."""
    # data preparation
    expected_message = "transcoding_order_creation_result"
    # mocking
    (
        flexmock(transcoding_order)
        .should_receive("create")
        .with_args(
            input_create_transcoding_fixture["input_bucket"],
            input_create_transcoding_fixture["input_key"],
            expected_bucket,
            result_create_transcoding_fixture["transformed_rules"],
            input_create_transcoding_fixture["status_topic_alias"],
            input_create_transcoding_fixture["preset_id"],
        )
        .and_return(response.Response(expected_message))
    )
    # test function call
    result = create_transcoding.create_transcoding(
        input_bucket=input_create_transcoding_fixture["input_bucket"],
        input_key=input_create_transcoding_fixture["input_key"],
        source_rules=result_create_transcoding_fixture["rules"].message,
        output_bucket=input_bucket,
        preset_id=input_create_transcoding_fixture["preset_id"],
        status_topic_alias=input_create_transcoding_fixture["status_topic_alias"],
        source_metadata=result_create_transcoding_fixture["metadata_extractor"],
    )
    # checking
    assert result
    assert result.message == expected_message