"""Tests for transcoding job logic module."""

from typing import Any
from unittest.mock import MagicMock, patch

import pytest
from flexmock import flexmock
from owsresponse import response

from transcoding.logic import messaging, transcoding_job as transcoding_job_logic
from transcoding.models import (
    transcoding_job as transcoding_job_model,
)


@pytest.fixture
def transcoding_order_fixture() -> dict[str, Any]:
    """Return transcoding order body."""
    return {
        "transcoding_order_id": 1,
        "sns_topic": None,
        "input_bucket": "ows-transcoding-raw",
        "input_key": "c85cc331-c08f-46fd-906d-793ef224eb1f.wav",
        "preset_id": None,
    }


@pytest.fixture
def input_transcoding_job_fixture() -> dict[str, Any]:
    """Fixture for input params for transcoding job creation."""
    return {
        "output_bucket": "ows-transcoding-raw",
        "output_key": "4e6e4670-03f4-4a34-8d92-123123dc.wav",
        "container": "m4a",
        "channels": 4,
        "codec": "PCM",
        "sample_rate": 44100,
        "bit_rate": 1411200,
        "bit_depth": 16,
    }


@pytest.fixture
def transcoding_job_fixture(
    input_transcoding_job_fixture: dict[str, Any],
) -> dict[str, Any]:
    """Return transcoding job body."""
    return {
        "transcoding_job_id": 1,
        "transcoding_order_id": 1,
        "status": "requested",
        "description": None,
        "attempt": 3,
        "output_bucket": input_transcoding_job_fixture["output_bucket"],
        "output_key": input_transcoding_job_fixture["output_key"],
        "container": input_transcoding_job_fixture["container"],
        "channels": input_transcoding_job_fixture["channels"],
        "codec": input_transcoding_job_fixture["codec"],
        "sample_rate": input_transcoding_job_fixture["sample_rate"],
        "bit_rate": input_transcoding_job_fixture["bit_rate"],
        "bit_depth": input_transcoding_job_fixture["bit_depth"],
    }


def test_create_success(
    transcoding_order_fixture: dict[str, Any],
    input_transcoding_job_fixture: dict[str, Any],
    transcoding_job_fixture: dict[str, Any],
) -> None:
    """Test for creating transcoding job."""
    (
        flexmock(transcoding_job_logic)
        .should_receive("_generate_unique_filename")
        .with_args(input_transcoding_job_fixture["container"])
        .and_return(input_transcoding_job_fixture["output_key"])
    )

    (
        flexmock(transcoding_job_model)
        .should_receive("create_transcoding_job")
        .with_args(
            transcoding_order_fixture["transcoding_order_id"],
            input_transcoding_job_fixture,
        )
        .and_return(response.Response(transcoding_job_fixture))
    )

    (
        flexmock(messaging)
        .should_receive("send_transcoding_job_message")
        .with_args(transcoding_order_fixture, transcoding_job_fixture)
        .and_return(response.Response("ok"))
    )

    result = transcoding_job_logic.create(
        transcoding_order_fixture,
        input_transcoding_job_fixture["output_bucket"],
        input_transcoding_job_fixture,
    )

    assert result


def test_create_with_model_error(
    transcoding_order_fixture: dict[str, Any],
    input_transcoding_job_fixture: dict[str, Any],
) -> None:
    """Test for creating transcoding job."""
    (
        flexmock(transcoding_job_logic)
        .should_receive("_generate_unique_filename")
        .with_args(input_transcoding_job_fixture["container"])
        .and_return(input_transcoding_job_fixture["output_key"])
    )

    (
        flexmock(transcoding_job_model)
        .should_receive("create_transcoding_job")
        .with_args(
            transcoding_order_fixture["transcoding_order_id"],
            input_transcoding_job_fixture,
        )
        .and_return(response.create_fatal_response("error"))
    )

    result = transcoding_job_logic.create(
        transcoding_order_fixture,
        input_transcoding_job_fixture["output_bucket"],
        input_transcoding_job_fixture,
    )

    assert not result
    assert result.status == 500


def test_create_with_sqs_error(
    transcoding_order_fixture: dict[str, Any],
    input_transcoding_job_fixture: dict[str, Any],
    transcoding_job_fixture: dict[str, Any],
) -> None:
    """Test for creating transcoding job."""
    (
        flexmock(transcoding_job_logic)
        .should_receive("_generate_unique_filename")
        .with_args(input_transcoding_job_fixture["container"])
        .and_return(input_transcoding_job_fixture["output_key"])
    )

    (
        flexmock(transcoding_job_model)
        .should_receive("create_transcoding_job")
        .with_args(
            transcoding_order_fixture["transcoding_order_id"],
            input_transcoding_job_fixture,
        )
        .and_return(response.Response(transcoding_job_fixture))
    )

    (
        flexmock(messaging)
        .should_receive("send_transcoding_job_message")
        .with_args(transcoding_order_fixture, transcoding_job_fixture)
        .and_return(response.create_fatal_response("error"))
    )

    result = transcoding_job_logic.create(
        transcoding_order_fixture,
        input_transcoding_job_fixture["output_bucket"],
        input_transcoding_job_fixture,
    )

    assert not result
    assert result.status == 500


def test_get_transcoding_job_by_id(transcoding_job_fixture: dict[str, Any]) -> None:
    """Test call of get_transcoding_job_by_id for transcoding job."""
    # mocking
    (
        flexmock(transcoding_job_model)
        .should_receive("get_transcoding_job_by_id")
        .with_args(transcoding_job_fixture["transcoding_job_id"])
        .and_return(response.Response(transcoding_job_fixture))
    )
    # test function call
    result_response = transcoding_job_logic.get_transcoding_job_by_id(
        transcoding_job_fixture["transcoding_job_id"]
    )
    # checking
    assert result_response
    assert result_response.status == 200


@pytest.mark.parametrize(
    "input_container, expected_extension",
    [("flac", "flac"), ("wave", "wav"), ("mpeg-4", "m4a"), ("mpeg audio", "mp3")],
)
@patch("uuid.uuid4")
def test__generate_unique_filename(
    uuid_mock: MagicMock, input_container: str, expected_extension: str
) -> None:
    """Test for _generate_unique_filename call."""
    # data preparation
    expected_value = "test_mock.{}".format(expected_extension)
    # mocking
    uuid_mock.return_value = "test-mock"
    # test function call
    result = transcoding_job_logic._generate_unique_filename(input_container)
    # checking
    assert result == expected_value