"""Integration tests for the ``property_overrides`` read adapter.

The reader is *faithful*: it returns the resolved enum-value snapshots exactly
as the finaliser wrote them, every ``(override_component, building_part)`` for
the Property, with no translation or gating. Verified against a real Postgres
(the ``db_engine`` fixture) because the value is in reading what was actually
persisted.
"""

from __future__ import annotations

from sqlalchemy import Engine
from sqlmodel import Session

from infrastructure.postgres.property_override_table import PropertyOverrideRow
from repositories.property.property_overrides_postgres_reader import (
    PropertyOverridesPostgresReader,
)


def _seed(
    session: Session,
    *,
    override_component: str,
    override_value: str,
    property_id: int = 1,
    portfolio_id: int = 1,
    building_part: int = 0,
) -> None:
    row = PropertyOverrideRow(
        property_id=property_id,
        portfolio_id=portfolio_id,
        building_part=building_part,
        override_component=override_component,
        override_value=override_value,
        original_spreadsheet_description="detached house",
    )
    session.add(row)


def test_reads_a_resolved_override_in_value_space(db_engine: Engine) -> None:
    # Arrange — the finaliser wrote one property_type override for the Property.
    with Session(db_engine) as session:
        _seed(
            session,
            property_id=42,
            override_component="property_type",
            override_value="House",
        )
        session.commit()

    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(42)

    # Assert — the stored enum value, untranslated.
    assert resolved.value("property_type", 0) == "House"


def test_returns_every_component_and_building_part_for_the_property(
    db_engine: Engine,
) -> None:
    # Arrange — three overrides across two building parts for the target Property,
    # plus an override for a *different* Property that must not leak in.
    with Session(db_engine) as session:
        _seed(
            session,
            property_id=7,
            building_part=0,
            override_component="property_type",
            override_value="House",
        )
        _seed(
            session,
            property_id=7,
            building_part=0,
            override_component="built_form_type",
            override_value="Detached",
        )
        _seed(
            session,
            property_id=7,
            building_part=1,
            override_component="wall_type",
            override_value="Solid brick, with internal insulation",
        )
        _seed(
            session,
            property_id=8,
            override_component="property_type",
            override_value="Flat",
        )
        session.commit()

    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(7)

    # Assert — all three of the Property's rows, faithfully; none from Property 8.
    assert len(resolved.rows) == 3
    assert resolved.value("property_type", 0) == "House"
    assert resolved.value("built_form_type", 0) == "Detached"
    assert resolved.value("wall_type", 1) == "Solid brick, with internal insulation"


def test_property_without_overrides_reads_empty(db_engine: Engine) -> None:
    # Arrange — nothing seeded for this Property.
    reader = PropertyOverridesPostgresReader(lambda: Session(db_engine))

    # Act
    resolved = reader.overrides_for(999)

    # Assert
    assert resolved.rows == ()
    assert resolved.value("property_type", 0) is None