"""Lambda test module."""

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

import pytest

from src import app
from src.constants import errors, general
from src.lambda_exceptions import LoggedException


@patch("src.app.create_transcoding_by_preset")
@patch("src.status.send_general_status")
def test_handler_success(send_general_status_mock: Any, create_transcoding_by_preset_mock: Any) -> None:
    """Test successful handler execution."""
    test_bucket = "test_bucket"
    test_key = "test_key.wav"
    event_mock = {
        "key": test_key,
        "bucket": test_bucket,
    }

    result = app.handler(event_mock, None)

    assert result == {"is_encoded": True}
    create_transcoding_by_preset_mock.assert_called_once_with(
        bucket=test_bucket,
        key=test_key,
        preset_alias=general.PRESET_ALIAS_PASSTHROUGH,
    )
    send_general_status_mock.assert_called_once_with(
        general.LAMBDA_NAME,
        general.TRIGGER_SPATIAL_TRANSCODING_COMPLETE_STATUS,
        test_key,
        bucket=test_bucket,
    )


@patch("src.app.capture_exception")
@patch("src.lambda_exceptions.notify_and_raise")
@patch("src.app.create_transcoding_by_preset")
def test_handler_failure_unexpected_error(
    create_transcoding_by_preset_mock: Any, notify_and_raise_mock: Any, capture_exception_mock: Any
) -> None:
    """Test handler raises LoggedException on unexpected error."""
    event_mock = {
        "key": "test_key.wav",
        "bucket": "test_bucket",
    }
    exc = Exception("Unexpected error")
    create_transcoding_by_preset_mock.side_effect = exc
    notify_and_raise_mock.side_effect = LoggedException("Unexpected error")

    with pytest.raises(LoggedException, match="Unexpected error"):
        app.handler(event_mock, None)

    capture_exception_mock.assert_called_once_with(exc)
    notify_and_raise_mock.assert_called_once_with(
        function=general.LAMBDA_NAME,
        error_status=general.TRIGGER_SPATIAL_TRANSCODING_ERROR_STATUS,
        error_code=errors.TRIGGER_SPATIAL_TRANSCODING_ERROR_CODE,
        bucket="test_bucket",
        filename="test_key.wav",
        error_params={"message": "Unexpected error"},
        input_params={"key": "test_key.wav", "bucket": "test_bucket"},
    )


@patch("owsrequest.request.process")
def test_create_transcoding_by_preset_success(process: Any) -> None:
    """Test create_transcoding_by_preset sends expected request payload."""
    process.return_value = Mock(status_code=200)

    result = app.create_transcoding_by_preset(
        bucket="qa-raw-assets",
        key="audio.wav",
        preset_alias="qa_spatial",
    )

    assert result
    assert process.call_args[1]["json"] == {
        "input": {
            "bucket": "qa-raw-assets",
            "key": "audio.wav",
            "metadata": {
                "channels": general.DEFAULT_METADATA_CHANNELS,
                "codec": general.DEFAULT_METADATA_CODEC,
                "container": general.DEFAULT_METADATA_CONTAINER,
                "sample_rate": general.DEFAULT_METADATA_SAMPLE_RATE,
                "bit_depth": general.DEFAULT_METADATA_BIT_DEPTH,
                "bit_rate": general.DEFAULT_METADATA_BIT_RATE,
            },
        },
    }


@patch("owsrequest.request.process")
def test_create_transcoding_by_preset_error_response(process: Any) -> None:
    """Test create_transcoding_by_preset raises on non-200 response."""
    process.return_value = Mock(status_code=500, text="fail")

    with pytest.raises(Exception, match="Failed to post transcoding"):
        app.create_transcoding_by_preset(
            bucket="qa-raw-assets",
            key="audio.wav",
            preset_alias="qa_spatial",
        )


@patch("src.app.capture_exception")
@patch("src.lambda_exceptions.notify_and_raise")
@patch("src.app.create_transcoding_by_preset")
def test_handler_logged_exception_propagates(
    create_transcoding_by_preset_mock: Any, notify_and_raise_mock: Any, capture_exception_mock: Any
) -> None:
    """Test handler re-raises LoggedException without calling capture_exception or notify_and_raise."""
    event_mock = {
        "key": "test_key.wav",
        "bucket": "test_bucket",
    }
    logged_exc = LoggedException("Already logged error")
    create_transcoding_by_preset_mock.side_effect = logged_exc

    with pytest.raises(LoggedException, match="Already logged error"):
        app.handler(event_mock, None)

    capture_exception_mock.assert_not_called()
    notify_and_raise_mock.assert_not_called()