"""ows-product model tests."""

import json
from http.client import INTERNAL_SERVER_ERROR, NOT_FOUND, OK
from unittest.mock import MagicMock

import pytest
import requests
from flask import g
from owsrequest import request
from pytest_mock import MockerFixture
from requests.exceptions import HTTPError

from video.api import app
from video.models.ows import track as track_model


def test_model_create_product_tracks_success(mocker: MockerFixture) -> None:
    """Test create product tracks success."""
    product_id = 12
    response = requests.Response()
    response.status_code = OK
    response._content = json.dumps({}).encode()
    expected_json = {
        "product_id": 12,
        "track_name": "Unnamed Video Track",
        "volume_number": 1,
        "track_type": "video",
    }

    mocker.patch.object(request, "process", return_value=response, autospec=True)
    create_track_response = track_model.create_track(product_id)

    assert create_track_response == {}
    assert request.process.call_args_list[0][1]["json"] == expected_json


def test_model_create_product_tracks_failure(mocker: MockerFixture) -> None:
    """Test create product tracks failure."""
    product_id = 12
    response = requests.Response()
    response.status_code = INTERNAL_SERVER_ERROR
    response._content = json.dumps({}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    with pytest.raises(HTTPError):
        track_model.create_track(product_id)


def test_model_get_track_success(mocker: MockerFixture) -> None:
    """Test get track."""
    product_id = 12
    response_dict = {"hi": "bye"}
    response = requests.Response()
    response.status_code = OK
    response._content = json.dumps(response_dict).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    create_track_response = track_model.get_track(product_id)

    assert create_track_response == response_dict


def test_model_get_track_failure(mocker: MockerFixture) -> None:
    """Test get product tracks failure."""
    product_id = 12
    response = requests.Response()
    response.status_code = INTERNAL_SERVER_ERROR
    response._content = json.dumps({}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    with pytest.raises(HTTPError):
        track_model.get_track(product_id)


def test_get_track_ids(mocker: MockerFixture) -> None:
    """Test get track ids of the product."""
    product_id = 12
    response_dict = {
        "items": [
            {"tuid": 123},
            {"tuid": 456},
        ]
    }
    mocker.patch.object(
        track_model, "get_track", return_value=response_dict, autospec=True
    )
    track_ids = track_model.get_track_ids(product_id)
    assert track_ids == [123, 456]


def test_model_update_track_success(mocker: MockerFixture) -> None:
    """Test update track."""
    product_id = 12
    response_dict = {"hi": "bye"}
    response = requests.Response()
    response.status_code = OK
    response._content = json.dumps(response_dict).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    update_track_response = track_model.update_track(product_id, {})

    assert update_track_response == response_dict


def test_model_update_track_failure(mocker: MockerFixture) -> None:
    """Test update track failure."""
    product_id = 12
    response = requests.Response()
    response.status_code = INTERNAL_SERVER_ERROR
    response._content = json.dumps({}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    with pytest.raises(HTTPError):
        track_model.update_track(product_id, {})


def test_model_is_isrc_used_success(mocker: MockerFixture) -> None:
    """Test is_isrc_used success."""
    response = requests.Response()
    response.status_code = OK
    response._content = json.dumps({}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    track_response = track_model.is_isrc_used("1", "video")

    assert track_response == {}


def test_model_get_track_by_id_success(mocker: MockerFixture) -> None:
    """Test get track by id success."""
    response_dict = {"hi": "bye"}
    response = requests.Response()
    response.status_code = OK
    response._content = json.dumps(response_dict).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    get_track_by_id_response = track_model.get_track_by_id(1)

    assert get_track_by_id_response == response_dict


def test_model_get_track_by_id_failure(mocker: MockerFixture) -> None:
    """Test get track by id failure."""
    response = requests.Response()
    response.status_code = INTERNAL_SERVER_ERROR
    response._content = json.dumps({}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=response,
        autospec=True,
    )
    with pytest.raises(HTTPError):
        track_model.get_track_by_id(1)


def test_model_get_track_by_id_not_found(mocker: MockerFixture) -> None:
    """A deleted (404) track degrades to an empty dict and logs a warning."""
    response = requests.Response()
    response.status_code = NOT_FOUND
    response._content = json.dumps({}).encode()

    mocker.patch.object(request, "process", return_value=response, autospec=True)

    with app.test_request_context():
        g.log = MagicMock()
        get_track_by_id_response = track_model.get_track_by_id(1)
        g.log.warning.assert_called_once()

    assert get_track_by_id_response == {}