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

import json
from http.client import INTERNAL_SERVER_ERROR, NOT_FOUND, OK
from typing import Any

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

from video.exceptions import ProductOwnershipError, ReleaseNotFound
from video.models.ows import product as product_model

product_id = 12
test_response = {"yum": "yummy"}


def test_generate_placeholder_upc_success(mocker: MockerFixture) -> None:
    """Test generate_placeholder_upc success."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = OK
    ows_product_response._content = json.dumps({"placeholder_upc": "12"}).encode()

    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )
    get_product_response = product_model.generate_placeholder_upc()

    assert get_product_response == "12"


def test_generate_placeholder_upc_failure(mocker: MockerFixture) -> None:
    """Test generate_placeholder_upc failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.generate_placeholder_upc()


def test_check_product_ownership_no_creds(mocker: MockerFixture) -> None:
    """Test check product ownership no credentials."""
    product_model.check_product_ownership(1)


def test_check_product_ownership_success(mocker: MockerFixture) -> None:
    """Test check product ownership success."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = OK
    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )

    product_model.check_product_ownership(1, 1, 2)


def test_check_product_ownership_not_found(mocker: MockerFixture) -> None:
    """Test check product ownership raises ReleaseNotFound on 404."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = NOT_FOUND
    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )

    with pytest.raises(ReleaseNotFound):
        product_model.check_product_ownership(1, 1, 2)


def test_check_product_ownership_forbidden(mocker: MockerFixture) -> None:
    """Test check product ownership raises ProductOwnershipError on non-404 failure."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = INTERNAL_SERVER_ERROR
    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )

    with pytest.raises(ProductOwnershipError):
        product_model.check_product_ownership(1, 1, 2)


def test_check_product_code_exists_true(mocker: MockerFixture) -> None:
    """Test check product code exists returns True when code is in use."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = OK
    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )

    assert product_model.check_product_code_exists(1, "vendor", 12, 100) is True


def test_check_product_code_exists_false(mocker: MockerFixture) -> None:
    """Test check product code exists returns False when code is not in use."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = NOT_FOUND
    mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )

    assert product_model.check_product_code_exists(1, "vendor", 12, 100) is False


def test_create_subgenre_success(mocker: MockerFixture) -> None:
    """Test create_subgenre success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.create_subgenre(product_id, {})

    assert product_response == test_response


def test_create_subgenre_failure(mocker: MockerFixture) -> None:
    """Test create_subgenre failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.create_subgenre(product_id, {})


def test_update_subgenre_success(mocker: MockerFixture) -> None:
    """Test update_subgenre success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.update_subgenre(product_id, {})

    assert product_response == test_response


def test_update_subgenre_failure(mocker: MockerFixture) -> None:
    """Test update_subgenre failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.update_subgenre(product_id, {})


def test_delete_subgenre_success(mocker: MockerFixture) -> None:
    """Test delete_subgenre success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_model.delete_subgenre(product_id)  # no return value


def test_delete_subgenre_failure(mocker: MockerFixture) -> None:
    """Test delete_subgenre failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.delete_subgenre(product_id)


def test_get_subgenre_success(mocker: MockerFixture) -> None:
    """Test get_subgenre success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.get_subgenre(product_id)

    assert product_response == test_response


def test_get_subgenre_not_found(mocker: MockerFixture) -> None:
    """Test get_subgenre returns None when not found."""
    not_found_response = requests.Response()
    not_found_response.status_code = NOT_FOUND
    not_found_response._content = json.dumps({}).encode()
    mocker.patch.object(
        request,
        "process",
        return_value=not_found_response,
        autospec=True,
    )
    assert product_model.get_subgenre(product_id) == {}


def test_get_subgenre_failure(mocker: MockerFixture) -> None:
    """Test get_subgenre raises on upstream error."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.get_subgenre(product_id)


def test_create_contributor_success(mocker: MockerFixture) -> None:
    """Test create_contributor success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.create_contributor(product_id, {})

    assert product_response == test_response


def test_create_contributor_failure(mocker: MockerFixture) -> None:
    """Test create_contributor failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.create_contributor(product_id, {})


def test_update_artist_success(mocker: MockerFixture) -> None:
    """Test update_artist success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.update_artist(product_id, {})

    assert product_response == test_response


def test_update_artist_failure(mocker: MockerFixture) -> None:
    """Test update_artist failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.update_artist(product_id, {})


def test_delete_contributors_success(mocker: MockerFixture) -> None:
    """Test delete_contributors success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_model.delete_contributors(product_id)  # no return value


def test_delete_contributors_failure(mocker: MockerFixture) -> None:
    """Test delete_contributors failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.delete_contributors(product_id)


def test_get_artist_success(mocker: MockerFixture) -> None:
    """Test get_artist success."""
    mocker.patch.object(
        request,
        "process",
        return_value=_successful_test_response(),
        autospec=True,
    )
    product_response = product_model.get_artist(product_id)

    assert product_response == test_response


def test_get_artist_failure(mocker: MockerFixture) -> None:
    """Test get_artist failure."""
    mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    with pytest.raises(HTTPError):
        product_model.get_artist(product_id)


def _error_response() -> requests.Response:
    ows_product_response = requests.Response()
    ows_product_response.status_code = INTERNAL_SERVER_ERROR
    ows_product_response._content = json.dumps(test_response).encode()
    return ows_product_response


def _successful_test_response() -> requests.Response:
    ows_product_response = requests.Response()
    ows_product_response.status_code = OK
    ows_product_response._content = json.dumps(test_response).encode()
    return ows_product_response


@pytest.mark.parametrize("mark_used", [True, False])
def test_get_provisioned_upc_success(mocker: MockerFixture, mark_used: Any) -> None:
    """Test get_provisioned_upc success."""
    ows_product_response = requests.Response()
    ows_product_response.status_code = OK
    ows_product_response._content = json.dumps({"upc": "123456789012"}).encode()

    mock_request_obj = mocker.patch.object(
        request,
        "process",
        return_value=ows_product_response,
        autospec=True,
    )
    get_product_response = product_model.get_provisioned_upc(mark_used)

    expected_post_payload = {"mark_used": mark_used}
    post_payload = mock_request_obj.call_args[1]["json"]

    assert get_product_response == "123456789012"
    assert post_payload == expected_post_payload


@pytest.mark.parametrize("mark_used", [True, False])
def test_get_provisioned_upc_failure(mocker: MockerFixture, mark_used: Any) -> None:
    """Test get_provisioned_upc failure."""
    mock_request_obj = mocker.patch.object(
        request,
        "process",
        return_value=_error_response(),
        autospec=True,
    )
    expected_post_payload = {"mark_used": mark_used}

    with pytest.raises(HTTPError):
        product_model.get_provisioned_upc(mark_used)

    post_payload = mock_request_obj.call_args[1]["json"]
    assert post_payload == expected_post_payload