"""Run Florian's document-level continuity metrics on a downloaded OCR handoff.

Original references and OCR records are read-only. This preserves raw markup and
partial text; it does not implement the strict visible-page evaluation panel.
"""

from __future__ import annotations

import argparse
import importlib.util
import json
from collections import Counter, defaultdict
from pathlib import Path


def read_rows(path: Path):
    with path.open(encoding="utf-8") as stream:
        for line in stream:
            if line.strip():
                yield json.loads(line)


def read_selection(run: Path, method: str) -> dict[str, list[int]]:
    config = json.loads((run / "run-config.json").read_text(encoding="utf-8"))
    if method not in {value["id"] for value in config["methods"]}:
        raise ValueError(f"Method {method!r} is absent from {run}/run-config.json")
    pages = defaultdict(list)
    for row in read_rows(run / "pages.jsonl"):
        document, number = row["document_id"], row["page_number"]
        if not isinstance(document, str) or not document or any(c in document for c in "/\\\0"):
            raise ValueError("Invalid document ID in the saved selection")
        if document in {".", ".."} or type(number) is not int or number < 1:
            raise ValueError("Invalid physical page number or document ID")
        if number in pages[document]:
            raise ValueError(f"Duplicate selected page: {document}/{number}")
        pages[document].append(number)
    if not pages:
        raise ValueError("The saved selection is empty")
    return {document: sorted(numbers) for document, numbers in pages.items()}


def document_prediction(run: Path, method: str, document: str,
                        numbers: list[int]) -> tuple[str, Counter, bool]:
    texts, counts, complete = [], Counter(), True
    for number in numbers:
        folder = run / method / document / f"page-{number:04d}"
        result_path, text_path = folder / "result.json", folder / "transcription.md"
        if not result_path.exists():
            counts["missing_result"] += 1
            complete = False
            text = text_path.read_bytes().decode("utf-8") if text_path.exists() else ""
        else:
            record = json.loads(result_path.read_text(encoding="utf-8"))
            if (record["page"]["document_id"], record["page"]["page_number"]) != (document, number):
                raise ValueError(f"Page identity disagrees with selection: {result_path}")
            text = record.get("markdown")
            if text is not None and not isinstance(text, str):
                raise ValueError(f"Invalid nullable transcription: {result_path}")
            counts[record["outcome"]] += 1
            complete = complete and record.get("status") == "success"
            if text_path.exists():
                if text_path.read_bytes() != (text or "").encode("utf-8"):
                    raise ValueError(f"Consumer text disagrees with saved result: {text_path}")
            else:
                counts["missing_transcription_file"] += 1
                complete = False
            if text is None:
                counts["unavailable_text"] += 1
            text = text or ""
        texts.append(text)
    counts["complete_documents" if complete else "incomplete_documents"] += 1
    return "\n\n".join(texts) if any(texts) else "", counts, complete


def evaluate(bundle: Path, output: Path, methods: list[str], evaluator: Path) -> dict:
    bundle, output = bundle.resolve(), output.resolve()
    if output == bundle or output.is_relative_to(bundle):
        raise ValueError("Evaluation output must be outside the read-only bundle")
    selected = {}
    for value in methods:
        parts = value.split("/")
        if len(parts) != 2 or any(not p or p in {".", ".."} or "\\" in p for p in parts):
            raise ValueError("Each --method must be RUN/METHOD")
        run_name, method = parts
        if method in selected:
            raise ValueError("Prediction method names must be distinct")
        run = bundle / "runs" / run_name
        selected[method] = (run, read_selection(run, method))
    if not selected:
        raise ValueError("Select at least one method")
    selection = next(iter(selected.values()))[1]
    if any(pages != selection for _, pages in selected.values()):
        raise ValueError("Methods have different saved document/page selections")
    spec = importlib.util.spec_from_file_location("florian_evaluate", evaluator)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    output.mkdir(parents=True, exist_ok=False)
    counts = defaultdict(Counter)
    weighted, per_language, seen = defaultdict(Counter), {}, set()
    total_characters = 0
    for source in sorted((bundle / "inputs").glob("*/data.json")):
        language = source.parent.name
        folder = output / language
        folder.mkdir()
        documents, characters = 0, 0
        with (folder / "data.json").open("w", encoding="utf-8") as destination:
            for reference in read_rows(source):
                document = f"{language}--{reference['id'].removeprefix('<urn:uuid:').removesuffix('>')}"
                if document not in selection:
                    continue
                if document in seen:
                    raise ValueError(f"Duplicate reference document: {document}")
                seen.add(document)
                if not isinstance(reference["text"], str):
                    raise ValueError(f"Reference text is not a string: {document}")
                row = {"id": reference["id"], "text": reference["text"]}
                prediction = reference.get("docling_prediction")
                if prediction is not None and not isinstance(prediction, str):
                    raise ValueError(f"Invalid Docling prediction: {document}")
                row["docling_prediction"] = prediction if prediction is not None else ""
                counts["docling"]["unavailable_documents" if prediction is None else "observed_documents"] += 1
                for method, (run, pages) in selected.items():
                    prediction, page_counts, _ = document_prediction(run, method, document, pages[document])
                    row[f"{method}_prediction"] = prediction
                    counts[method].update(page_counts)
                destination.write(json.dumps(row, ensure_ascii=False, allow_nan=False) + "\n")
                documents += 1
                characters += len(reference["text"])
        if not documents:
            (folder / "data.json").unlink()
            folder.rmdir()
            continue
        if not characters:
            raise ValueError(f"No reference characters for language {language}")
        dataframe, tools = module.evaluate_folder(folder / "data.json")
        dataframe.write_ndjson(folder / "data.json")
        module.write_metrics_yaml(dataframe, tools, folder / "metrics.yaml")
        import yaml
        metrics = yaml.safe_load((folder / "metrics.yaml").read_text(encoding="utf-8"))
        for method, values in metrics.items():
            for name, score in values.items():
                weighted[method][name] += score * characters
        per_language[language] = {"documents": documents, "reference_characters": characters,
                                  "metrics": metrics}
        total_characters += characters
        print(json.dumps({"language": language, "documents": documents, "metrics": metrics}), flush=True)
    if seen != set(selection):
        raise ValueError(f"Missing references for {len(set(selection) - seen)} selected documents")
    if not total_characters:
        raise ValueError("No nonempty reference text was selected")
    summary = {"metrics": {method: {name: value / total_characters for name, value in values.items()}
                           for method, values in weighted.items()},
               "counts": {method: dict(values) for method, values in counts.items()},
               "selected_documents": len(selection), "selected_pages": sum(map(len, selection.values())),
               "reference_characters": total_characters, "per_language": per_language,
               "policy": "Raw page transcriptions joined in physical page order with two newlines. Partial and failed outputs retained; unavailable text contributes an explicitly counted empty hypothesis. Florian's NFC/case-folded document metrics, reference-character weighted. FinePDFs continuity diagnostics, not certified page-level ground truth."}
    (output / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2, allow_nan=False) + "\n", encoding="utf-8")
    return summary


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--bundle", type=Path, required=True, help="Extracted directory containing inputs/ and runs/")
    parser.add_argument("--output", type=Path, required=True, help="Fresh results directory outside the bundle")
    parser.add_argument("--method", action="append", required=True, help="RUN/METHOD; repeat for comparisons")
    parser.add_argument("--evaluator", type=Path, default=Path(__file__).with_name("florian_evaluate.py"))
    args = parser.parse_args()
    summary = evaluate(args.bundle, args.output, args.method, args.evaluator)
    print(json.dumps({key: value for key, value in summary.items() if key != "per_language"}, ensure_ascii=False))


if __name__ == "__main__":
    main()