"""Tests for HiveTextRecognition model."""

from typing import Any
from unittest.mock import MagicMock

import pytest
import pytest_mock
from sqlalchemy.exc import IntegrityError, SQLAlchemyError

from assets.connectors import mysql
from assets.exceptions import HiveTextRecognitionExists
from assets.models.hive_text_recognition import (
    create_hive_text_recognition,
    get_hive_text_recognition_by_product,
)

from tests.unit.models import au_operations


@pytest.fixture
def hive_text_recognition_db_fixture(
    asset_upload_data_for_hive: list[dict[str, Any]],
    asset_final_data: list[dict[str, Any]],
    hive_text_recognition_data: list[dict[str, Any]],
) -> None:
    """Set up the hive_text_recognition table with related data."""
    au_operations.truncate_tables()
    au_operations.seed_asset_upload_table(asset_upload_data_for_hive)
    au_operations.seed_asset_final_table(asset_final_data)
    au_operations.seed_hive_text_recognition_table(hive_text_recognition_data)


@pytest.mark.parametrize(
    ("asset_final_id", "block_text", "session_side_effect", "expected_exception"),
    [
        pytest.param(999, "recognized text", None, None, id="success"),
        pytest.param(
            999,
            "recognized text",
            IntegrityError("duplicate", None, Exception()),
            HiveTextRecognitionExists,
            id="integrity_error",
        ),
        pytest.param(
            999,
            "recognized text",
            SQLAlchemyError("db error"),
            SQLAlchemyError,
            id="other_error",
        ),
    ],
)
def test_create_hive_text_recognition(
    mocker: pytest_mock.MockerFixture,
    asset_final_id: int,
    block_text: str,
    session_side_effect: Exception | None,
    expected_exception: type[Exception] | None,
) -> None:
    """Test create_hive_text_recognition with success, IntegrityError, and other error cases."""
    if session_side_effect is not None:
        mocker.patch.object(mysql, "au_db_session", side_effect=session_side_effect)
        assert expected_exception is not None
        with pytest.raises(expected_exception):
            create_hive_text_recognition(asset_final_id, block_text)
    else:
        mock_session = MagicMock()
        mock_ctx = MagicMock()
        mock_ctx.__enter__ = MagicMock(return_value=mock_session)
        mock_ctx.__exit__ = MagicMock(return_value=False)
        mocker.patch.object(mysql, "au_db_session", return_value=mock_ctx)

        create_hive_text_recognition(asset_final_id, block_text)

        mock_session.add.assert_called_once()


@pytest.mark.parametrize(
    ("product_id", "expected_result"),
    [
        pytest.param(
            1003,
            {"asset_final_id": 104, "block_text": "some extracted text"},
            id="valid_image_type_returns_result",
        ),
        pytest.param(
            1001,
            None,
            id="audio_asset_upload_type_returns_none",
        ),
        pytest.param(
            9999,
            None,
            id="no_asset_upload_record_returns_none",
        ),
    ],
)
def test_get_hive_text_recognition_by_product(
    hive_text_recognition_db_fixture: None,
    product_id: int,
    expected_result: dict[str, Any] | None,
) -> None:
    """Test get_hive_text_recognition_by_product with various product/asset combinations."""
    result = get_hive_text_recognition_by_product(product_id)
    assert result == expected_result