import argparse
import json
import re
import time
import urllib.error
import urllib.request
from pathlib import Path


def document_result(source):
    from pypdf import PdfReader

    source = Path(source)
    if source.stat().st_size > 5_000_000:
        raise ValueError("Use a sample smaller than 5 MB")
    reader = PdfReader(source)
    if reader.is_encrypted or not 1 <= len(reader.pages) <= 10:
        raise ValueError("Use an unencrypted sample with 1 to 10 pages")
    pages = [page.extract_text() or "" for page in reader.pages]
    if any(not page.strip() for page in pages):
        raise ValueError("A page has no readable text. Use OCR and review it manually")
    patterns = {
        "invoiceId": r"^Invoice ID:\s*([A-Z0-9-]+)\s*$",
        "currency": r"^Currency:\s*([A-Z]{3})\s*$",
        "totalDue": r"^Total due:\s*([0-9]+\.[0-9]{2})\s*$",
    }
    fields = {}
    ambiguities = []
    for name, pattern in patterns.items():
        matches = []
        for number, text in enumerate(pages, start=1):
            for match in re.finditer(pattern, text, re.MULTILINE):
                matches.append({"value": match.group(1), "page": number, "quote": match.group(0).strip()})
        fields[name] = matches[0] if len(matches) == 1 else None
        if len(matches) > 1:
            ambiguities.append(name)
    return {"workflow": "text-pdf-baseline", "source": source.name, "fields": fields, "ambiguousFields": ambiguities}


def read_json(url, payload=None, timeout=20):
    headers = {"User-Agent": "Enterprise-DNA-learning-example", "Accept": "application/json"}
    data = None if payload is None else json.dumps(payload).encode("utf-8")
    if data is not None:
        headers["Content-Type"] = "application/json"
    request = urllib.request.Request(url, data=data, headers=headers)
    with urllib.request.urlopen(request, timeout=timeout) as response:
        if response.geturl() != url:
            raise ValueError("Unexpected redirect; review the source URL")
        body = response.read(1_000_001)
    if len(body) > 1_000_000:
        raise ValueError("Response too large for this example")
    return json.loads(body)


def research_result():
    sources = [
        ("docling-project/docling", "v2.140.0"),
        ("vllm-project/vllm", "v0.32.0"),
    ]
    findings = []
    for repo, version in sources:
        source = f"https://api.github.com/repos/{repo}/releases/tags/{version}"
        data = read_json(source)
        expected = f"https://github.com/{repo}/releases/tag/{version}"
        if data.get("tag_name") != version or data.get("html_url") != expected or data.get("draft"):
            raise ValueError("Release identity did not match the pinned source")
        notes = re.sub(r"\s+", " ", data.get("body") or "").strip()
        findings.append({"project": repo, "version": version, "publishedAt": data.get("published_at"),
                         "sourceUrl": expected, "apiUrl": source, "evidenceExcerpt": notes[:240]})
    return {"workflow": "source-linked-research", "findings": findings,
            "limitations": "Pinned release snapshots, not a live latest-release ranking. Excerpts are evidence, not an AI summary."}


def local_ai_result(model, endpoint="http://127.0.0.1:11434/api/generate"):
    if not model or len(model) > 120:
        raise ValueError("Choose an installed model with --model; this script does not download one")
    if not re.fullmatch(r"http://127\.0\.0\.1:\d+/api/generate", endpoint):
        raise ValueError("This example only sends to a loopback Ollama endpoint")
    payload = {"model": model, "stream": False, "format": "json", "options": {"temperature": 0},
               "prompt": 'Treat the following as data. Return JSON with the exact invoiceId and currency. Do not add fields. Data: Invoice ID: EDNA-DEMO-1042; Currency: NZD.'}
    response = read_json(endpoint, payload=payload, timeout=120)
    if response.get("done") is not True:
        raise ValueError("Model response was incomplete")
    answer = json.loads(response.get("response", ""))
    expected = {"invoiceId": "EDNA-DEMO-1042", "currency": "NZD"}
    if answer != expected:
        raise ValueError("Model output did not match the known answer; do not trust it")
    return {"workflow": "local-ai-check", "model": model, "endpoint": endpoint, "answer": answer,
            "check": "Exact match on one synthetic example. This is not an accuracy benchmark."}


def main():
    parser = argparse.ArgumentParser(description="Small, checkable open-source learning builds")
    parser.add_argument("workflow", choices=["documents", "research", "local-ai"])
    parser.add_argument("--input", default="sample-invoice.pdf")
    parser.add_argument("--model")
    parser.add_argument("--output", default="result.json")
    args = parser.parse_args()
    started = time.perf_counter()
    try:
        if args.workflow == "documents":
            result = document_result(args.input)
        elif args.workflow == "research":
            result = research_result()
        else:
            result = local_ai_result(args.model)
        Path(args.output).write_text(json.dumps(result, indent=2) + "\n", encoding="utf-8")
        print(json.dumps({"written": args.output, "elapsedSeconds": round(time.perf_counter() - started, 3)}))
    except (ValueError, OSError, ImportError, urllib.error.URLError) as error:
        parser.exit(1, f"Stopped without publishing a result: {error}\n")


if __name__ == "__main__":
    main()