"""Test Release."""

from typing import Any

import pytest
from pytest_mock import MockerFixture
from sqlalchemy import select, text

from video.connectors import mysql
from video.models.ows import product as ows_product
from video.models.sql.classes import release as release_class

from tests.unit import ar_db_utils


def _seed_project(project_id: int) -> None:
    """Seed a minimal project row using INSERT IGNORE to bypass unknown NOT NULL columns."""
    with mysql.ar_db_session(turn_off_foreign_key_constraint=True) as session:
        session.execute(
            text("INSERT IGNORE INTO `project` (project_id) VALUES (:project_id)"),
            {"project_id": project_id},
        )


@ar_db_utils.test_schema
@pytest.mark.parametrize(
    ("test_description", "release_id", "upc", "project_id"),
    [
        ("test success", 123, 123456789, 456),
        ("test release id as None", None, 123456789, 456),
    ],
)
def test_releases(
    test_description: Any,
    release_id: Any,
    upc: Any,
    project_id: Any,
    snapshot: Any,
) -> None:
    """Test Release."""
    releases = release_class.Release(
        release_id=release_id,
        upc=upc,
        project_id=project_id,
    )
    ar_db_utils.seed_models([releases])
    with mysql.ar_db_session() as session:
        db_result = session.execute(
            select(release_class.Release).where(
                release_class.Release.release_id == release_id
            )
        ).scalar_one_or_none()
        query_response = db_result.to_dict() if db_result else None

    assert query_response == snapshot


@ar_db_utils.test_schema
def test_create() -> None:
    """Test create."""
    _seed_project(456)
    release = release_class.create({"upc": 12, "project_id": 456})
    assert release["upc"] == 12


@ar_db_utils.test_schema
def test_delete() -> None:
    """Test delete."""
    _seed_project(456)
    release = release_class.create({"upc": 12, "project_id": 456})
    with mysql.ar_db_session() as session:
        release_class.delete_release(release["release_id"], session=session)
    release = release_class.get_by_id_with_vendor(release["release_id"])
    assert release == {}


@ar_db_utils.test_schema
def test_get_by_id_with_vendor() -> None:
    """Test get by id with vendor."""
    _seed_project(456)
    ar_db_utils.seed_models(
        [release_class.ArtistInfo(artist_id=12, vendor_id=13, entered_by=14)]
    )
    release = release_class.create({"upc": 12, "artist_id": 12, "project_id": 456})
    release = release_class.get_by_id_with_vendor(release["release_id"])
    assert release["vendor_id"] == 13


@ar_db_utils.test_schema
def test_update() -> None:
    """Test update."""
    _seed_project(456)
    release = release_class.create({"upc": 12, "project_id": 456})
    release_id = release["release_id"]
    release = release_class.update(release_id, {"release_name": "porridge"})
    assert release["release_name"] == "porridge"


@ar_db_utils.test_schema
def test_get_by_upc() -> None:
    """Test get by upc."""
    _seed_project(456)
    release_class.create({"upc": 12, "project_id": 456})
    release = release_class.get_by_upc(12)
    assert release["upc"] == 12


@ar_db_utils.test_schema
def test_get() -> None:
    """Test get."""
    _seed_project(456)
    release = release_class.create({"upc": 12, "project_id": 456})
    release_id = release["id"]
    assert release_class.get(release_id)["upc"] == release["upc"]


@ar_db_utils.test_schema
def test_get_upc_by_product_id() -> None:
    """Test get_upc_by_product_id."""
    _seed_project(456)
    release = release_class.create({"upc": 12, "project_id": 456})
    retrieved_release = release_class.get_upc_by_product_id(release["release_id"])
    assert retrieved_release["upc"] == 12


def test_get_upc(mocker: MockerFixture) -> None:
    """Test get_upc."""
    mocker.patch.object(
        ows_product,
        "get_provisioned_upc",
        return_value="123",
    )

    mocker.patch.object(
        release_class,
        "_log_upc_provisioner_success",
        return_value="Assigned UPC 123 from upc provisioner",
    )

    mock_session = mocker.MagicMock()
    provisioned_upc = release_class.get_upc(session=mock_session)

    assert provisioned_upc == "123"


@ar_db_utils.test_schema
def test_get_upc_provisioner_fails(mocker: MockerFixture) -> None:
    """Test get_upc calls stored procedure when provisioner fails."""
    mocker.patch.object(
        ows_product,
        "get_provisioned_upc",
        side_effect=Exception("error generating upc"),
    )

    mocker.patch.object(
        release_class,
        "_log_upc_provisioner_error",
        return_value="Could not get provisioned UPC",
    )

    reserved_upc = "012345678901"
    mock_upc_response = mocker.MagicMock()
    mock_upc_response.scalar = mocker.MagicMock(return_value=reserved_upc)
    session = mocker.MagicMock()
    session.execute = mocker.MagicMock(return_value=mock_upc_response)

    upc = release_class.get_upc(session=session)
    session.execute.assert_called_once()
    (call_arg,), _ = session.execute.call_args
    assert str(call_arg) == release_class.RESERVE_UPC

    assert upc == reserved_upc