"""L1: tht memory save-one -- targeted upsert via the writer key (spec D11).

The D11 deviation: instead of a full vectorstore resync (tht memory index / sync),
a remote workstation with a writer key can push a SINGLE promoted decision to
pgvector as a one-row upsert. This test pins the pure core of that behavior:
- exactly one VectorRecord is built for the chosen decision_seq
- the writer.upsert_records is called once with a single row
- writer.sync is NEVER called (that is the full-resync path)
"""
from datetime import UTC, datetime
from unittest.mock import MagicMock

from tht.adapters.vector.qdrant import point_id
from tht.memory import MemoryRecord, memory_vector_record_for_decision, save_one_memory
from tht.vectorstore.records import qdrant_payload


def _record(seq: int = 7, **kw) -> MemoryRecord:
    base = {
        "id": "mem-0007",
        "ts": datetime(2025, 1, 1, tzinfo=UTC),
        "session_id": "s1",
        "decision_seq": seq,
        "type": "concept_clarified",
        "subject": "paziente attivo",
        "detail": "flag_attivo = TRUE",
        "rationale": "r",
        "question_context": "dammi i pazienti",
        "tables": [],
        "concepts": ["paziente attivo"],
    }
    base.update(kw)
    return MemoryRecord(**base)


# --- memory_vector_record_for_decision (single-record filter) ------------------

def test_single_record_built_for_decision_seq():
    records = [_record(seq=7), _record(seq=8, id="mem-0008")]
    vr = memory_vector_record_for_decision(records, decision_seq=7)
    assert vr is not None
    assert vr.id == "memory:mem-0007"  # memory_vector_records prefix
    assert vr.kind == "memory"
    assert "pazienti" in vr.content


def test_returns_none_for_unknown_decision_seq():
    records = [_record(seq=7)]
    assert memory_vector_record_for_decision(records, decision_seq=999) is None


# --- save_one_memory (the D11 orchestrator: single upsert, never sync) ---------

def test_save_one_calls_upsert_with_single_row_never_sync():
    records = [_record(seq=7)]
    writer = MagicMock()
    writer.upsert.return_value = 1
    embedder = MagicMock()
    embedder.embed_documents.return_value = [[0.1] * 8]

    upserted = save_one_memory(records, decision_seq=7, store=writer, embedder=embedder)

    assert upserted == 1
    writer.sync.assert_not_called()  # the whole point of D11: no full resync
    writer.upsert.assert_called_once()
    args = writer.upsert.call_args
    # table is memory, exactly one row
    assert args[0][0] == "memory"
    rows = args[0][1]
    assert len(rows) == 1
    assert rows[0].record.id == "memory:mem-0007"
    assert rows[0].embedding


def test_save_one_no_record_for_seq_is_noop():
    records = [_record(seq=7)]
    writer = MagicMock()
    embedder = MagicMock()
    upserted = save_one_memory(records, decision_seq=42, store=writer, embedder=embedder)
    assert upserted == 0
    writer.upsert.assert_not_called()
    writer.sync.assert_not_called()
    embedder.embed_documents.assert_not_called()


def test_save_one_uses_writer_key_for_upsert():
    """The upsert must flow through the writer client (writer key), not a reader.
    Verified indirectly: save_one_memory takes the writer as its client argument."""
    records = [_record(seq=7)]
    writer = MagicMock()
    writer.upsert.return_value = 1
    embedder = MagicMock()
    embedder.embed_documents.return_value = [[0.0] * 4]
    save_one_memory(records, decision_seq=7, store=writer, embedder=embedder)
    # one upsert call, single row, table=memory
    assert writer.upsert.call_count == 1


def test_save_one_preserves_semantic_point_identity_fields():
    records = [_record(seq=7)]
    writer = MagicMock()
    writer.existing_hashes.return_value = {}
    writer.upsert.return_value = 1
    embedder = MagicMock()
    embedder.embed_documents.return_value = [[0.0] * 4]

    save_one_memory(records, decision_seq=7, store=writer, embedder=embedder)

    row = writer.upsert.call_args.args[1][0]
    payload = qdrant_payload(
        row.record,
        content_hash=row.content_hash,
        workspace_id="psd-clinical",
        workspace_revision="a" * 40,
    )

    assert point_id("psd-clinical", "memory", row.record.id) == point_id(
        "psd-clinical", "memory", "memory:mem-0007"
    )
    assert payload["kind"] == "memory"
    assert payload["workspace_id"] == "psd-clinical"
    assert payload["workspace_revision"] == "a" * 40