"""Tests for asset_status."""

from typing import Any

import pytest
from flexmock import flexmock
from owsresponse import response

from transcoding.connectors import ows_assets
from transcoding.logic import asset_status
from transcoding.models import (
    transcoding_job as transcoding_job_model,
    transcoding_order as transcoding_order_model,
)

TRANSCODING_ORDER_ID = 10
TRANSCODING_JOB_ID = 20


@pytest.fixture
def transcoding_order_fixture() -> dict[str, Any]:
    """Return transcoding order data."""
    return {
        "transcoding_order_id": 10,
        "input_bucket": "test_input_bucket",
        "input_key": "test_input_key",
    }


def test_create_final_status_message_with_all_fields(
    transcoding_order_fixture: dict[str, Any],
) -> None:
    """Test creating final status message with all fields."""
    final_assets = [{"key": "output.wav", "bucket": "output-bucket"}]
    status = "completed"
    status_description = "Success"

    result = asset_status._create_final_status_message(
        final_assets, status, status_description, transcoding_order_fixture
    )

    assert isinstance(result, dict)
    assert result["status"] == status
    assert result["result_assets"] == final_assets
    assert result["status_details"] == status_description
    assert result["input"]["bucket"] == "test_input_bucket"
    assert result["input"]["key"] == "test_input_key"


def test_create_final_status_message_without_optional_fields(
    transcoding_order_fixture: dict[str, Any],
) -> None:
    """Test creating final status message without optional fields."""
    result = asset_status._create_final_status_message(
        [], "error", "", transcoding_order_fixture
    )

    assert isinstance(result, dict)
    assert result["status"] == "error"
    assert "result_assets" not in result
    assert "status_details" not in result
    assert result["input"]["bucket"] == "test_input_bucket"
    assert result["input"]["key"] == "test_input_key"


@pytest.fixture
def update_asset_final_status_args() -> dict[str, Any]:
    """Return args for update_asset_final_status."""
    return {
        "transcoding_job_id": TRANSCODING_JOB_ID,
        "status": "completed",
        "status_description": "Success",
        "final_assets": [{"key": "output.wav", "bucket": "output-bucket"}],
    }


@pytest.fixture
def update_asset_final_status_mocks() -> dict[str, Any]:
    """Return subcall mocks for update_asset_final_status."""
    return {
        "get_transcoding_job": response.Response(
            {
                "transcoding_job_id": TRANSCODING_JOB_ID,
                "transcoding_order_id": TRANSCODING_ORDER_ID,
            }
        ),
        "get_transcoding_order": response.Response(
            {
                "transcoding_order_id": TRANSCODING_ORDER_ID,
                "input_key": "some_input_key",
                "input_bucket": "some_input_bucket",
            }
        ),
        "post_asset_final_status": True,
    }


def test_update_asset_final_status_success(
    update_asset_final_status_args: dict[str, Any],
    update_asset_final_status_mocks: dict[str, Any],
) -> None:
    """Test for success of update_asset_final_status."""
    (
        flexmock(transcoding_job_model)
        .should_receive("get_transcoding_job_by_id")
        .with_args(transcoding_job_id=TRANSCODING_JOB_ID)
        .and_return(update_asset_final_status_mocks["get_transcoding_job"])
        .once()
    )

    (
        flexmock(transcoding_order_model)
        .should_receive("get_transcoding_order")
        .with_args(transcoding_order_id=TRANSCODING_ORDER_ID)
        .and_return(update_asset_final_status_mocks["get_transcoding_order"])
        .once()
    )

    expected_message = {
        "status": "completed",
        "result_assets": update_asset_final_status_args["final_assets"],
        "status_details": "Success",
        "input": {"bucket": "some_input_bucket", "key": "some_input_key"},
    }

    (
        flexmock(ows_assets)
        .should_receive("post_asset_final_status")
        .with_args(
            "some_input_key",
            "completed",
            "Success",
            update_asset_final_status_args["final_assets"],
            expected_message,
        )
        .and_return(update_asset_final_status_mocks["post_asset_final_status"])
        .once()
    )

    result = asset_status.update_asset_final_status(**update_asset_final_status_args)
    assert result


@pytest.mark.parametrize(
    "failing_mock", ["get_transcoding_job", "get_transcoding_order"]
)
def test_update_asset_final_status_subcall_failure(
    update_asset_final_status_args: dict[str, Any],
    update_asset_final_status_mocks: dict[str, Any],
    failing_mock: str,
) -> None:
    """Test for subcall failure of update_asset_final_status."""
    error_message = "fatal_error_%s" % failing_mock
    error_response = response.create_fatal_response(error_message)
    update_asset_final_status_mocks[failing_mock] = error_response

    (
        flexmock(transcoding_job_model)
        .should_receive("get_transcoding_job_by_id")
        .and_return(update_asset_final_status_mocks["get_transcoding_job"])
    )

    (
        flexmock(transcoding_order_model)
        .should_receive("get_transcoding_order")
        .and_return(update_asset_final_status_mocks["get_transcoding_order"])
    )

    (
        flexmock(ows_assets)
        .should_receive("post_asset_final_status")
        .and_return(update_asset_final_status_mocks["post_asset_final_status"])
    )

    result = asset_status.update_asset_final_status(**update_asset_final_status_args)
    assert not result
    assert result.errors["message"] == error_message


def test_update_asset_final_status_with_none_parameters(
    update_asset_final_status_mocks: dict[str, Any],
) -> None:
    """Test update_asset_final_status handles None parameters correctly."""
    (
        flexmock(transcoding_job_model)
        .should_receive("get_transcoding_job_by_id")
        .with_args(transcoding_job_id=TRANSCODING_JOB_ID)
        .and_return(update_asset_final_status_mocks["get_transcoding_job"])
        .once()
    )

    (
        flexmock(transcoding_order_model)
        .should_receive("get_transcoding_order")
        .with_args(transcoding_order_id=TRANSCODING_ORDER_ID)
        .and_return(update_asset_final_status_mocks["get_transcoding_order"])
        .once()
    )

    expected_message = {
        "status": "error",
        "input": {"bucket": "some_input_bucket", "key": "some_input_key"},
    }

    (
        flexmock(ows_assets)
        .should_receive("post_asset_final_status")
        .with_args("some_input_key", "error", "", [], expected_message)
        .and_return(True)
        .once()
    )

    result = asset_status.update_asset_final_status(
        TRANSCODING_JOB_ID,
        "error",
        None,
        None,
    )
    assert result