"""Runtime Evidence lookup bound to the atomically active corpus generation."""

from tht.corpus.store import CorpusStore


class ActiveEvidenceSearcher:
    """Searcher facade that enforces ACTIVE generation predicates before LIMIT."""

    def __init__(self, corpus: CorpusStore, delegate):
        self.corpus = corpus
        self.delegate = delegate

    def search(self, embedding, top_n=10, kinds=None, metadata_filter=None):
        requested = set(kinds) if kinds is not None else {
            "schema_table", "schema_column", "evidence", "memory", "solved_question",
        }
        include_evidence = "evidence" in requested
        other_kinds = sorted(requested - {"evidence"})
        if not include_evidence:
            kwargs = {"top_n": top_n, "kinds": kinds}
            if metadata_filter is not None:
                kwargs["metadata_filter"] = metadata_filter
            return self.delegate.search(embedding, **kwargs)
        with self.corpus.writer_lock():
            hits = []
            if other_kinds:
                kwargs = {"top_n": top_n, "kinds": other_kinds}
                if metadata_filter is not None:
                    kwargs["metadata_filter"] = metadata_filter
                hits.extend(self.delegate.search(embedding, **kwargs))
            if include_evidence:
                manifest = self.corpus.active_manifest()
                workspace_id = manifest.metadata.get("workspace_id") if manifest else None
                if manifest is not None and isinstance(workspace_id, str):
                    by_generation: dict[str, list[str]] = {}
                    mapping = dict(manifest.metadata.get("document_generations", {}))
                    for document in manifest.documents:
                        generation = mapping.get(document.document_id, manifest.vector_generation)
                        if generation:
                            by_generation.setdefault(generation, []).append(document.document_id)
                    for generation, document_ids in sorted(by_generation.items()):
                        hits.extend(self.delegate.search(
                            embedding, top_n=top_n, kinds=["evidence"],
                            metadata_filter={
                                "vector_generation": generation,
                                "document_ids": sorted(document_ids),
                                "workspace_id": workspace_id,
                            },
                        ))
        return sorted(hits, key=lambda hit: (-hit.similarity, hit.id))[:top_n]


def active_searcher(cfg, delegate):
    corpus_root = cfg.paths.artifacts.parent / "corpus"
    return ActiveEvidenceSearcher(CorpusStore(corpus_root), delegate)


def resolve_evidence_file(
    store: CorpusStore, evidence_id: str, *, materialized_root=None,
) -> str:
    with store.writer_lock():
        manifest = store.active_manifest()
        if manifest is None:
            return ""
        for document in manifest.documents:
            frontmatter = document.metadata.get("frontmatter", {})
            identifiers = {document.document_id, document.source_id, str(frontmatter.get("id", ""))}
            if evidence_id in identifiers:
                root = materialized_root or (store.root / "runtime")
                filename = document.document_id.removeprefix("doc:") + ".md"
                path = store.materialize_document(
                    document.document_id, root / filename, generation=manifest.manifest_id,
                )
                return str(path) if path else ""
    return ""