"""Test create track metadata logic."""

from typing import Any

import pytest
from pytest_mock import MockerFixture
from werkzeug.exceptions import BadRequest, NotFound

from video.logic import track as track_logic
from video.models.ows import track as ows_track
from video.models.sql import queries
from video.models.sql.classes import track, track_video

video_data = {
    "duration_minutes": 27,
    "duration_seconds": 10,
    "fps": 30,
    "resolution": "SD",
    "aspect_ratio": "10:7",
    "color": "color",
    "channel": "2",
    "closed_caption_exists": 0,
    "closed_caption_reason_id": 1,
}

video_track_metadata = [
    {
        "track_id": 123,
        "duration_minutes": 1,
        "duration_seconds": 0,
        "closed_caption_exists": 0,
        "closed_caption_reason_id": 1,
        "color": "color",
        "channel": "2",
        "fps": "30",
        "resolution": "1080HD",
        "aspect_ratio": "16:9",
    },
    {
        "track_id": 456,
        "duration_minutes": 2,
        "duration_seconds": 0,
        "closed_caption_exists": 0,
        "closed_caption_reason_id": 1,
        "color": "color",
        "channel": "2",
        "fps": "25",
        "resolution": "1080HD",
        "aspect_ratio": "16:9",
    },
]


@pytest.mark.parametrize(
    (
        "expected_track_id",
        "track_video_upsert_response",
        "video_data",
        "expected_response",
    ),
    [
        pytest.param(
            1234,
            {**video_data, "track_id": 1234},
            video_data,
            {**video_data, "track_id": 1234},
            id="test success",
        ),
    ],
)
def test_create_track_metadata(
    mocker: MockerFixture,
    expected_track_id: Any,
    track_video_upsert_response: Any,
    video_data: Any,
    expected_response: Any,
) -> None:
    """Test create track metadata success."""
    product_id = 12345

    mocker.patch.object(ows_track, "get_track_id", return_value=expected_track_id)
    mocker.patch.object(track, "upsert", return_value={})
    mocker.patch.object(track_video, "upsert", return_value=track_video_upsert_response)

    create_metadata_response = track_logic.create_track_metadata(product_id, video_data)

    assert create_metadata_response == expected_response


@pytest.mark.parametrize(
    ("track_ids", "expected_tuids", "expected_video_track_metadata"),
    [
        pytest.param(
            None,
            [123, 456],
            video_track_metadata,
            id="test tracks metadata for video product",
        ),
        pytest.param(
            [123],
            [123, 456],
            video_track_metadata[0],
            id="test tracks metadata for video product using track_id",
        ),
    ],
)
def test_get_tracks_metadata_success(
    mocker: MockerFixture,
    track_ids: Any,
    expected_tuids: Any,
    expected_video_track_metadata: Any,
) -> None:
    """Test get tracks metadata success."""
    product_id = 12345

    mocker.patch.object(ows_track, "get_track_ids", return_value=expected_tuids)
    mocker.patch.object(
        queries, "get_video_tracks_metadata", return_value=expected_video_track_metadata
    )

    result = track_logic.get_tracks_metadata(product_id, track_ids)

    assert result == expected_video_track_metadata


def test_get_tracks_metadata_no_tracks(mocker: MockerFixture) -> None:
    """Test get tracks metadata when no tracks are found."""
    mocker.patch.object(ows_track, "get_track_ids", return_value=[])

    with pytest.raises(NotFound):
        track_logic.get_tracks_metadata(12345, None)


def test_get_tracks_metadata_no_video_track(mocker: MockerFixture) -> None:
    """Test get tracks metadata when no video track metadata is found."""
    mocker.patch.object(ows_track, "get_track_ids", return_value=[123, 456])
    mocker.patch.object(queries, "get_video_tracks_metadata", return_value=None)

    with pytest.raises(NotFound):
        track_logic.get_tracks_metadata(12345, None)


def test_get_tracks_metadata_invalid_tuid(mocker: MockerFixture) -> None:
    """Test get tracks metadata when an invalid tuid is provided."""
    mocker.patch.object(ows_track, "get_track_ids", return_value=[123, 456])

    with pytest.raises(BadRequest):
        track_logic.get_tracks_metadata(12345, [789])