"""Tests for database models."""

from datetime import datetime

from quber.db.models import Base, Document, ExtractedTable


class TestBase:
    """Tests for the Base declarative base."""

    def test_base_is_declarative_base(self):
        """Test that Base is a valid declarative base."""
        assert hasattr(Base, "metadata")
        assert hasattr(Base, "registry")


class TestDocument:
    """Tests for the Document model."""

    def test_document_creation(self):
        """Test creating a Document instance."""
        doc = Document(
            filename="test.pdf",
            extraction_date=datetime.now(),
            total_pages=10,
            total_tables=5,
            executive_summary="Test summary",
            model_provider="anthropic",
            model="claude-3-5-sonnet-20241022",
        )

        assert doc.filename == "test.pdf"
        assert doc.total_pages == 10
        assert doc.total_tables == 5
        assert doc.executive_summary == "Test summary"
        assert doc.model_provider == "anthropic"
        assert doc.model == "claude-3-5-sonnet-20241022"

    def test_document_with_defaults(self):
        """Test creating a Document with minimal fields."""
        doc = Document(filename="minimal.pdf", extraction_date=datetime.now())

        assert doc.filename == "minimal.pdf"
        assert doc.total_pages is None
        assert doc.total_tables is None
        assert doc.executive_summary is None
        assert doc.model_provider is None
        assert doc.model is None

    def test_document_repr(self):
        """Test Document __repr__ method."""
        doc = Document(filename="test.pdf", extraction_date=datetime.now(), total_tables=5)
        doc.id = 1

        repr_str = repr(doc)
        assert "Document" in repr_str
        assert "id=1" in repr_str
        assert "test.pdf" in repr_str
        assert "tables=5" in repr_str

    def test_document_tables_relationship(self):
        """Test that Document has tables relationship."""
        doc = Document(filename="test.pdf", extraction_date=datetime.now())

        # Tables should be an empty list initially
        assert hasattr(doc, "tables")
        assert isinstance(doc.tables, list)
        assert len(doc.tables) == 0

    def test_document_table_name(self):
        """Test that Document has correct table name."""
        assert Document.__tablename__ == "documents"


class TestExtractedTable:
    """Tests for the ExtractedTable model."""

    def test_extracted_table_creation(self):
        """Test creating an ExtractedTable instance."""
        table = ExtractedTable(
            document_id=1,
            table_id=0,
            page_number=1,
            procedural_title="Table 1",
            llm_title="Test Table",
            llm_description="A test table",
            table_markdown="| Header |\n| ----- |\n| Data |",
            headers={"headers": ["Header"]},
            table_metadata={"key": "value"},
        )

        assert table.document_id == 1
        assert table.table_id == 0
        assert table.page_number == 1
        assert table.procedural_title == "Table 1"
        assert table.llm_title == "Test Table"
        assert table.llm_description == "A test table"
        assert table.table_markdown == "| Header |\n| ----- |\n| Data |"
        assert table.headers == {"headers": ["Header"]}
        assert table.table_metadata == {"key": "value"}

    def test_extracted_table_with_minimal_fields(self):
        """Test creating an ExtractedTable with only required fields."""
        table = ExtractedTable(document_id=1, table_id=0, page_number=1)

        assert table.document_id == 1
        assert table.table_id == 0
        assert table.page_number == 1
        assert table.procedural_title is None
        assert table.llm_title is None
        assert table.llm_description is None
        assert table.table_markdown is None

    def test_extracted_table_with_embeddings(self):
        """Test creating an ExtractedTable with embeddings."""
        # Create dummy embedding (1024 dims for bge-large-en-v1.5)
        embedding = [0.1] * 1024

        table = ExtractedTable(
            document_id=1,
            table_id=0,
            page_number=1,
            llm_title="Test",
            llm_description="Description",
            title_embedding=embedding,
            description_embedding=embedding,
        )

        assert table.title_embedding == embedding
        assert table.description_embedding == embedding

    def test_extracted_table_repr(self):
        """Test ExtractedTable __repr__ method."""
        table = ExtractedTable(document_id=1, table_id=0, page_number=5)
        table.id = 10

        repr_str = repr(table)
        assert "ExtractedTable" in repr_str
        assert "id=10" in repr_str
        assert "document_id=1" in repr_str
        assert "table_id=0" in repr_str
        assert "page=5" in repr_str

    def test_extracted_table_document_relationship(self):
        """Test that ExtractedTable has document relationship."""
        table = ExtractedTable(document_id=1, table_id=0, page_number=1)

        # Document relationship should be accessible
        assert hasattr(table, "document")

    def test_extracted_table_table_name(self):
        """Test that ExtractedTable has correct table name."""
        assert ExtractedTable.__tablename__ == "extracted_tables"

    def test_extracted_table_unique_constraint(self):
        """Test that ExtractedTable has unique constraint on document_id + table_id."""
        # Check that the unique constraint exists
        constraints = [c for c in ExtractedTable.__table_args__ if hasattr(c, "name")]
        constraint_names = [c.name for c in constraints]

        assert "uq_document_table" in constraint_names