"""Tests for BaseMixin."""

import pytest
from sqlalchemy import select
from sqlalchemy.orm import Session

from abacus_models.core.errors import ERROR_ENTITY_DOES_NOT_EXIST

from tests.conftest import (
    TestModelCompositeKey,
    TestModelFull,
    TestModelMinimal,
    TestModelWithDefaultFilter,
    TestModelWithDefaultOrder,
)


class TestGetById:
    """Tests for BaseMixin.get_by_id classmethod."""

    def test_get_by_id_returns_object(self, session, sample_full_model):
        """Test get_by_id returns the correct object."""
        result = TestModelFull.get_by_id(session, sample_full_model.id)
        assert result is not None
        assert result.id == sample_full_model.id
        assert result.name == sample_full_model.name

    def test_get_by_id_none_id_returns_none(self, session):
        """Test get_by_id returns None when ID is None."""
        result = TestModelFull.get_by_id(session, None)
        assert result is None

    def test_get_by_id_nonexistent_returns_none(self, session):
        """Test get_by_id returns None for non-existent ID."""
        result = TestModelFull.get_by_id(session, 99999)
        assert result is None

    def test_get_by_id_with_connection(self, connection, user_context):
        """Test get_by_id works with Connection executor."""
        # Connection.get() doesn't exist in SQLAlchemy 2.0
        # This test verifies the Executor type alias accepts Connection
        # but actual get_by_id requires Session for the .get() method

        # Create a Session from connection to test
        with Session(connection) as session:
            model = TestModelFull(name='Connection Test')
            session.add(model)
            session.flush()
            model_id = model.id

            # Test get_by_id with session (which is what works)
            result = TestModelFull.get_by_id(session, model_id)
            assert result is not None
            assert result.name == 'Connection Test'

    def test_get_by_id_minimal_model(self, session, sample_minimal_model):
        """Test get_by_id works with minimal model."""
        result = TestModelMinimal.get_by_id(session, sample_minimal_model.id)
        assert result is not None
        assert result.id == sample_minimal_model.id


class TestGetByIdOrError:
    """Tests for BaseMixin.get_by_id_or_error classmethod."""

    def test_get_by_id_or_error_returns_object(self, session, sample_full_model):
        """Test get_by_id_or_error returns the correct object."""
        result = TestModelFull.get_by_id_or_error(session, sample_full_model.id)
        assert result is not None
        assert result.id == sample_full_model.id

    def test_get_by_id_or_error_raises_on_none_id(self, session):
        """Test get_by_id_or_error raises ValueError when ID is None."""
        with pytest.raises(ValueError) as exc_info:
            TestModelFull.get_by_id_or_error(session, None)
        error_msg = str(exc_info.value)
        assert 'TestModelFull' in error_msg
        assert 'does not exist' in error_msg

    def test_get_by_id_or_error_raises_on_nonexistent(self, session):
        """Test get_by_id_or_error raises ValueError for non-existent ID."""
        with pytest.raises(ValueError) as exc_info:
            TestModelFull.get_by_id_or_error(session, 99999)
        error_msg = str(exc_info.value)
        assert 'TestModelFull' in error_msg
        assert '99999' in error_msg

    def test_get_by_id_or_error_message_format(self, session):
        """Test get_by_id_or_error error message follows expected format."""
        with pytest.raises(ValueError) as exc_info:
            TestModelFull.get_by_id_or_error(session, 12345)

        expected = ERROR_ENTITY_DOES_NOT_EXIST.format(
            object_type='TestModelFull', object_id=12345
        )
        assert str(exc_info.value) == expected


class TestGetClassName:
    """Tests for BaseMixin.get_class_name classmethod."""

    def test_get_class_name_returns_name(self):
        """Test get_class_name returns the class name."""
        assert TestModelFull.get_class_name() == 'TestModelFull'
        assert TestModelMinimal.get_class_name() == 'TestModelMinimal'
        assert TestModelCompositeKey.get_class_name() == 'TestModelCompositeKey'

    def test_get_class_name_on_instance(self, sample_full_model):
        """Test get_class_name can be called on instance."""
        assert sample_full_model.get_class_name() == 'TestModelFull'


class TestRepr:
    """Tests for BaseMixin.__repr__ method."""

    def test_repr_single_pk(self, session, sample_full_model):
        """Test __repr__ with single primary key."""
        repr_str = repr(sample_full_model)
        assert repr_str.startswith('<TestModelFull(')
        assert f'id: {sample_full_model.id}' in repr_str
        assert repr_str.endswith('>')

    def test_repr_composite_pk(self, session):
        """Test __repr__ with composite primary key."""
        model = TestModelCompositeKey(id1=1, id2=2, name='Test')
        session.add(model)
        session.commit()

        repr_str = repr(model)
        assert repr_str.startswith('<TestModelCompositeKey(')
        assert 'id1: 1' in repr_str
        assert 'id2: 2' in repr_str
        assert repr_str.endswith('>')

    def test_repr_minimal_model(self, sample_minimal_model):
        """Test __repr__ with minimal model."""
        repr_str = repr(sample_minimal_model)
        assert repr_str.startswith('<TestModelMinimal(')
        assert f'id: {sample_minimal_model.id}' in repr_str

    def test_repr_unsaved_model(self):
        """Test __repr__ with unsaved model (None PK)."""
        model = TestModelFull(name='Unsaved')
        repr_str = repr(model)
        assert repr_str.startswith('<TestModelFull(')
        assert 'id: None' in repr_str


class TestCompositeKeySupport:
    """Tests for composite key handling in BaseMixin."""

    def test_get_by_id_with_composite_key_dict(self, session):
        """Test get_by_id with composite key using dict."""
        model = TestModelCompositeKey(id1=10, id2=20, name='Composite')
        session.add(model)
        session.commit()

        # get_by_id accepts single PK value, so composite keys need dict
        result = TestModelCompositeKey.get_by_id(session, {'id1': 10, 'id2': 20})
        assert result is not None
        assert result.id1 == 10
        assert result.id2 == 20
        assert result.name == 'Composite'

    def test_get_by_id_with_composite_key_tuple(self, session):
        """Test get_by_id with composite key using tuple."""
        model = TestModelCompositeKey(id1=30, id2=40, name='Tuple Test')
        session.add(model)
        session.commit()

        # Try tuple format
        result = TestModelCompositeKey.get_by_id(session, (30, 40))
        # Based on SQLAlchemy Session.get() behavior, tuple should work
        assert result is not None
        assert result.id1 == 30
        assert result.id2 == 40

    def test_get_by_id_composite_key_partial_raises_error(self, session):
        """Test get_by_id with only one key of composite raises InvalidRequestError."""
        from sqlalchemy.exc import InvalidRequestError

        model = TestModelCompositeKey(id1=50, id2=60, name='Partial')
        session.add(model)
        session.commit()

        # Partial key should raise error from SQLAlchemy
        with pytest.raises(InvalidRequestError, match='Incorrect number of values'):
            TestModelCompositeKey.get_by_id(session, 50)

    def test_get_by_id_or_error_composite_key_raises_with_details(self, session):
        """Test get_by_id_or_error with composite key has descriptive error."""
        with pytest.raises(ValueError) as exc_info:
            TestModelCompositeKey.get_by_id_or_error(session, {'id1': 99, 'id2': 88})

        error_msg = str(exc_info.value)
        assert 'TestModelCompositeKey' in error_msg
        # Check that the error message contains info about the composite key
        assert '99' in error_msg or 'id1' in error_msg


class TestBaseMixinEdgeCases:
    """Tests for edge cases and boundary conditions."""

    def test_repr_with_string_pk(self, session, user_context):
        """Test __repr__ with string primary key if such models exist."""
        # TestModelFull uses integer PK, but test string representation
        model = TestModelFull(name='String PK Test')
        session.add(model)
        session.flush()

        repr_str = repr(model)
        # Should handle string conversion properly
        assert isinstance(repr_str, str)
        assert 'TestModelFull' in repr_str

    def test_repr_with_special_characters_in_name(self, session, user_context):
        """Test __repr__ with special characters in model data."""
        model = TestModelFull(name='Test with \'quotes\' and "double quotes"')
        session.add(model)
        session.flush()

        repr_str = repr(model)
        # Should not break with special characters
        assert isinstance(repr_str, str)
        assert 'TestModelFull' in repr_str

    def test_get_class_name_consistency(self, session, sample_full_model):
        """Test get_class_name returns same value as __class__.__name__."""
        assert (
            sample_full_model.get_class_name() == sample_full_model.__class__.__name__
        )
        assert TestModelFull.get_class_name() == TestModelFull.__name__

    def test_get_by_id_with_zero_id(self, session, user_context):
        """Test get_by_id with ID of 0 (valid but edge case)."""
        # Most auto-increment starts at 1, but 0 might be valid in some schemas
        result = TestModelFull.get_by_id(session, 0)
        # Should return None if doesn't exist, not raise error
        assert result is None

    def test_get_by_id_with_negative_id(self, session):
        """Test get_by_id with negative ID."""
        result = TestModelFull.get_by_id(session, -1)
        # Should handle gracefully
        assert result is None

    def test_get_by_id_or_error_with_string_id_type_mismatch(self, session):
        """Test get_by_id_or_error with wrong type for ID."""
        # If model expects int but gets string
        with pytest.raises((ValueError, TypeError)):
            # This might raise ValueError from our code or TypeError from SQLAlchemy
            TestModelFull.get_by_id_or_error(session, 'not_an_int')


class TestUpdateAttributes:
    """Tests for BaseMixin.update_attributes instance method."""

    def test_update_single_attribute(self, session, sample_full_model):
        """Test updating a single attribute."""
        result = sample_full_model.update_attributes(session, name='Updated Name')
        assert result.name == 'Updated Name'
        assert result is sample_full_model

    def test_update_multiple_attributes(self, session, sample_minimal_model):
        """Test updating multiple attributes at once."""
        sample_minimal_model.update_attributes(session, name='New Name')
        assert sample_minimal_model.name == 'New Name'

    def test_update_nonexistent_attribute_raises(self, session, sample_full_model):
        """Test updating a nonexistent attribute raises AttributeError."""
        with pytest.raises(AttributeError, match='has no attribute'):
            sample_full_model.update_attributes(session, nonexistent='value')

    def test_update_returns_self(self, session, sample_full_model):
        """Test update_attributes returns the instance for chaining."""
        result = sample_full_model.update_attributes(session, name='Chained')
        assert result is sample_full_model

    def test_update_with_no_kwargs(self, session, sample_full_model):
        """Test update_attributes with no kwargs is a no-op."""
        original_name = sample_full_model.name
        sample_full_model.update_attributes(session)
        assert sample_full_model.name == original_name


class TestCount:
    """Tests for BaseMixin.count classmethod."""

    def test_count_all(self, session, user_context):
        """Test counting all rows."""
        session.add(TestModelFull(name='A'))
        session.add(TestModelFull(name='B'))
        session.add(TestModelFull(name='C'))
        session.commit()

        assert TestModelFull.count(session) == 3

    def test_count_with_filter(self, session, user_context):
        """Test counting with a where clause."""
        session.add(TestModelFull(name='Alice'))
        session.add(TestModelFull(name='Bob'))
        session.add(TestModelFull(name='Alice'))
        session.commit()

        assert TestModelFull.count(session, TestModelFull.name == 'Alice') == 2

    def test_count_with_multiple_filters(self, session):
        """Test counting with multiple where clauses."""
        session.add(TestModelMinimal(name='X'))
        session.add(TestModelMinimal(name='Y'))
        session.add(TestModelMinimal(name='Z'))
        session.commit()

        result = TestModelMinimal.count(
            session,
            TestModelMinimal.name != 'X',
            TestModelMinimal.name != 'Z',
        )
        assert result == 1

    def test_count_empty_table(self, session):
        """Test counting an empty table."""
        assert TestModelMinimal.count(session) == 0


class TestDefaultFilter:
    """Tests for BaseMixin.default_filter classmethod."""

    def test_default_filter_without_implementation_returns_unfiltered(
        self, session, user_context
    ):
        """Test that calling default_filter without implementing _get_default_filter returns unfiltered statement."""
        # Create test data
        model1 = TestModelFull(name='Model 1')
        model2 = TestModelFull(name='Model 2')
        session.add_all([model1, model2])
        session.commit()

        # default_filter should return all records when no filter is defined
        stmt = TestModelFull.default_filter()
        results = session.execute(stmt).scalars().all()

        assert len(results) == 2
        assert model1 in results
        assert model2 in results

    def test_default_filter_creates_new_statement(self, session):
        """Test default_filter creates a new select statement."""
        # Create test data
        active1 = TestModelWithDefaultFilter(name='Active 1', is_active=1)
        active2 = TestModelWithDefaultFilter(name='Active 2', is_active=1)
        inactive = TestModelWithDefaultFilter(name='Inactive', is_active=0)
        session.add_all([active1, active2, inactive])
        session.commit()

        # Test default_filter creates new statement
        stmt = TestModelWithDefaultFilter.default_filter()
        results = session.execute(stmt).scalars().all()

        assert len(results) == 2
        assert active1 in results
        assert active2 in results
        assert inactive not in results

    def test_default_filter_applies_to_existing_statement(self, session):
        """Test default_filter can be applied to an existing select statement."""
        # Create test data
        active1 = TestModelWithDefaultFilter(name='Active X', is_active=1)
        active2 = TestModelWithDefaultFilter(name='Active Y', is_active=1)
        inactive = TestModelWithDefaultFilter(name='Inactive X', is_active=0)
        session.add_all([active1, active2, inactive])
        session.commit()

        # Create base statement with additional filter
        base_stmt = select(TestModelWithDefaultFilter).where(
            TestModelWithDefaultFilter.name.like('%X%')
        )
        stmt = TestModelWithDefaultFilter.default_filter(base_stmt)
        results = session.execute(stmt).scalars().all()

        # Should only get Active X (active + name contains X)
        assert len(results) == 1
        assert results[0].name == 'Active X'

    def test_default_filter_with_none_returns_active_only(self, session):
        """Test default_filter with None stmt parameter."""
        # Create test data
        active = TestModelWithDefaultFilter(name='Active', is_active=1)
        inactive = TestModelWithDefaultFilter(name='Inactive', is_active=0)
        session.add_all([active, inactive])
        session.commit()

        # Explicitly pass None (should behave same as no argument)
        stmt = TestModelWithDefaultFilter.default_filter(None)
        results = session.execute(stmt).scalars().all()

        assert len(results) == 1
        assert results[0] == active

    def test_default_filter_preserves_joins(self, session):
        """Test default_filter preserves joins from existing statement."""
        # Create test data
        active = TestModelWithDefaultFilter(name='Active', is_active=1)
        inactive = TestModelWithDefaultFilter(name='Inactive', is_active=0)
        session.add_all([active, inactive])
        session.commit()

        # Create statement with ordering
        base_stmt = select(TestModelWithDefaultFilter).order_by(
            TestModelWithDefaultFilter.name.desc()
        )
        stmt = TestModelWithDefaultFilter.default_filter(base_stmt)
        results = session.execute(stmt).scalars().all()

        # Should only get active records, ordered by name descending
        assert len(results) == 1
        assert results[0] == active

    def test_default_filter_multiple_calls(self, session):
        """Test that default_filter can be called multiple times (though redundant)."""
        # Create test data
        active = TestModelWithDefaultFilter(name='Active', is_active=1)
        session.add(active)
        session.commit()

        # Apply default filter twice (redundant but should work)
        stmt = TestModelWithDefaultFilter.default_filter()
        stmt = TestModelWithDefaultFilter.default_filter(stmt)
        results = session.execute(stmt).scalars().all()

        assert len(results) == 1
        assert results[0] == active


class TestDefaultOrder:
    """Tests for BaseMixin.default_order classmethod."""

    def test_default_order_without_implementation_returns_unordered(
        self, session, user_context
    ):
        """Test that calling default_order without implementing _get_default_order returns unordered statement."""
        # Create test data
        model1 = TestModelFull(name='Zebra')
        model2 = TestModelFull(name='Apple')
        session.add_all([model1, model2])
        session.commit()

        # default_order should return records in insertion order when no ordering is defined
        stmt = TestModelFull.default_order()
        results = session.execute(stmt).scalars().all()

        assert len(results) == 2
        # Order may vary, just check both are present
        assert model1 in results
        assert model2 in results

    def test_default_order_creates_new_statement(self, session):
        """Test default_order creates a new select statement with ordering."""
        # Create test data
        model1 = TestModelWithDefaultOrder(name='Charlie', priority=1)
        model2 = TestModelWithDefaultOrder(name='Alice', priority=3)
        model3 = TestModelWithDefaultOrder(name='Bob', priority=3)
        session.add_all([model1, model2, model3])
        session.commit()

        # Test default_order creates new statement with ordering
        stmt = TestModelWithDefaultOrder.default_order()
        results = session.execute(stmt).scalars().all()

        assert len(results) == 3
        # Should be ordered by priority desc, then name asc
        assert results[0].name == 'Alice'  # priority 3, name Alice
        assert results[1].name == 'Bob'  # priority 3, name Bob
        assert results[2].name == 'Charlie'  # priority 1

    def test_default_order_applies_to_existing_statement(self, session):
        """Test default_order can be applied to an existing select statement."""
        # Create test data
        model1 = TestModelWithDefaultOrder(name='Zebra', priority=1)
        model2 = TestModelWithDefaultOrder(name='Apple', priority=2)
        model3 = TestModelWithDefaultOrder(name='Mango', priority=2)
        session.add_all([model1, model2, model3])
        session.commit()

        # Create base statement with filter
        base_stmt = select(TestModelWithDefaultOrder).where(
            TestModelWithDefaultOrder.priority >= 2
        )
        stmt = TestModelWithDefaultOrder.default_order(base_stmt)
        results = session.execute(stmt).scalars().all()

        # Should only get priority >= 2, ordered by priority desc, name asc
        assert len(results) == 2
        assert results[0].name == 'Apple'
        assert results[1].name == 'Mango'

    def test_default_order_with_none_returns_ordered(self, session):
        """Test default_order with None stmt parameter."""
        # Create test data
        model1 = TestModelWithDefaultOrder(name='Zebra', priority=5)
        model2 = TestModelWithDefaultOrder(name='Apple', priority=10)
        session.add_all([model1, model2])
        session.commit()

        # Explicitly pass None (should behave same as no argument)
        stmt = TestModelWithDefaultOrder.default_order(None)
        results = session.execute(stmt).scalars().all()

        assert len(results) == 2
        # Priority desc
        assert results[0] == model2
        assert results[1] == model1

    def test_default_order_preserves_filters(self, session):
        """Test default_order preserves filters from existing statement."""
        # Create test data
        model1 = TestModelWithDefaultOrder(name='Apple', priority=1)
        model2 = TestModelWithDefaultOrder(name='Zebra', priority=5)
        model3 = TestModelWithDefaultOrder(name='Mango', priority=10)
        session.add_all([model1, model2, model3])
        session.commit()

        # Create statement with where clause
        base_stmt = select(TestModelWithDefaultOrder).where(
            TestModelWithDefaultOrder.priority > 1
        )
        stmt = TestModelWithDefaultOrder.default_order(base_stmt)
        results = session.execute(stmt).scalars().all()

        # Should only get priority > 1, ordered correctly
        assert len(results) == 2
        assert results[0].name == 'Mango'  # priority 10
        assert results[1].name == 'Zebra'  # priority 5

    def test_default_order_can_combine_with_default_filter(self, session):
        """Test that default_order can be combined with default_filter."""
        # Create test data
        active1 = TestModelWithDefaultFilter(name='Zebra', is_active=1)
        active2 = TestModelWithDefaultFilter(name='Apple', is_active=1)
        inactive = TestModelWithDefaultFilter(name='Banana', is_active=0)
        session.add_all([active1, active2, inactive])
        session.commit()

        # Combine filter and order
        stmt = TestModelWithDefaultFilter.default_filter()
        stmt = stmt.order_by(TestModelWithDefaultFilter.name.asc())
        results = session.execute(stmt).scalars().all()

        # Should get only active, ordered by name
        assert len(results) == 2
        assert results[0].name == 'Apple'
        assert results[1].name == 'Zebra'