from __future__ import annotations

import json
import random
from pathlib import Path

from src.checksums import break_iban, break_luhn, break_national_id, make_iban, make_luhn, make_national_id
from src.domain import (
    DEFAULT_SEED,
    DEV_TEMPLATES,
    LAB_EMAIL_DOMAIN,
    N_VARIANTS,
    TEST_TEMPLATES,
    DocFormat,
    EntityType,
    Family,
    Language,
    Split,
)
from src.normalize import fold_digits
from src.schemas import GoldMeta, GoldSpan, LabDocument, Scenario


EN_FIRST = ["Ava", "Noah", "Leila", "Omar", "Helen", "Nima"]
EN_LAST = ["Labian", "Fixture"]
FA_FIRST = ["سارا", "نیما", "لیلا", "امید"]
FA_LAST = ["نمونه‌ای", "آزمایشی"]


class Builder:
    def __init__(self) -> None:
        self.parts: list[str] = []
        self.spans: list[GoldSpan] = []

    def add(self, text: str) -> "Builder":
        self.parts.append(text)
        return self

    def pii(self, text: str, entity_type: EntityType, language: str = "en") -> "Builder":
        start = len("".join(self.parts))
        self.parts.append(text)
        self.spans.append(GoldSpan(start=start, end=start + len(text), entity_type=entity_type, surface=text, language=language))
        return self

    def text(self) -> str:
        return "".join(self.parts)


def to_persian_digits(value: str) -> str:
    table = str.maketrans("0123456789", "۰۱۲۳۴۵۶۷۸۹")
    return value.translate(table)


def _person(rng: random.Random, lang: str) -> tuple[str, str, str]:
    if lang == "fa":
        first, last = rng.choice(FA_FIRST), rng.choice(FA_LAST)
        return first, last, f"{first} {last}"
    first, last = rng.choice(EN_FIRST), rng.choice(EN_LAST)
    return first, last, f"{first} {last}"


def _email(first: str, last: str, index: int) -> str:
    slug = f"{fold_digits(first)}.{fold_digits(last)}{index:02d}".encode("ascii", "ignore").decode("ascii")
    if not slug or slug.startswith("."):
        slug = f"user{index:02d}"
    slug = "".join(ch if ch.isalnum() or ch == "." else "x" for ch in slug)
    return f"{slug}@{LAB_EMAIL_DOMAIN}"


def _phone(rng: random.Random) -> str:
    return f"0912{rng.randint(1000000, 9999999)}"


def _employee(index: int) -> str:
    return f"ARIA-24{index:03d}"


def _en_support_email(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "en")
    email = _email(first, last, index)
    phone = _phone(rng)
    emp = _employee(index)
    builder = Builder()
    builder.add("From: ").pii(name, EntityType.PERSON).add(" <").pii(email, EntityType.EMAIL).add(">\n")
    builder.add("Phone: ").pii(phone, EntityType.PHONE).add("\n")
    builder.add("Employee: ").pii(emp, EntityType.EMPLOYEE_ID).add("\n")
    builder.add(f"Please reset the laboratory mailbox for {first}. Ticket ORD-2024-{index:04d}. Version 2.4.1.\n")
    return LabDocument(
        doc_id=f"DLP-EN-EMAIL-{index:02d}",
        template="en_support_email",
        family=Family.EN_SUPPORT_EMAIL.value,
        split=Split.DEVELOPMENT,
        language=Language.EN,
        format=DocFormat.TEXT,
        title="English support mailbox",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=[f"ORD-2024-{index:04d}", "2.4.1"],
        description="English support email with name, mailbox, phone, and employee id.",
        description_fa="ایمیل پشتیبانی انگلیسی با نام، صندوق، تلفن و شناسه کارمند.",
    )


def _fa_hr_letter(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "fa")
    nid = make_national_id(rng)
    phone = _phone(rng)
    email = _email("user", last, index)
    nid_fa = to_persian_digits(nid)
    phone_fa = to_persian_digits(phone)
    builder = Builder()
    builder.add("خانم ").pii(name, EntityType.PERSON, "fa").add("،\n")
    builder.add("کد\u200cملی ").pii(nid_fa, EntityType.IR_NATIONAL_ID, "fa").add("\n")
    builder.add("تلفن همراه ").pii(phone_fa, EntityType.PHONE, "fa").add("\n")
    builder.add("ایمیل ").pii(email, EntityType.EMAIL).add("\n")
    builder.add(f"شماره پیگیری INV-1403-{index:04d} و نسخه ۳٫۲٫۱ فقط ارجاع داخلی‌اند.\n")
    return LabDocument(
        doc_id=f"DLP-FA-HR-{index:02d}",
        template="fa_hr_letter",
        family=Family.FA_HR_LETTER.value,
        split=Split.DEVELOPMENT,
        language=Language.FA,
        format=DocFormat.TEXT,
        title="Persian HR letter",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=[f"INV-1403-{index:04d}"],
        description="Persian HR note with ZWNJ, Persian digits, national id, and phone.",
        description_fa="نامه منابع انسانی با نیم‌فاصله، رقم فارسی، کد ملی و تلفن.",
    )


def _mixed_invoice_csv(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "en")
    email = _email(first, last, index)
    phone = _phone(rng)
    invoice = f"INV-2024-{1000 + index}"
    bad_nid = break_national_id(make_national_id(rng))
    builder = Builder()
    builder.add("invoice_id,customer,email,phone,lookup\n")
    builder.add(f"{invoice},").pii(name, EntityType.PERSON).add(",").pii(email, EntityType.EMAIL)
    builder.add(",").pii(phone, EntityType.PHONE).add(f",{bad_nid}\n")
    return LabDocument(
        doc_id=f"DLP-CSV-INV-{index:02d}",
        template="mixed_invoice_csv",
        family=Family.MIXED_INVOICE_CSV.value,
        split=Split.DEVELOPMENT,
        language=Language.MIXED,
        format=DocFormat.CSV,
        title="Invoice CSV",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=[invoice, bad_nid],
        description="CSV with a customer row and a checksum-failing lookup number.",
        description_fa="سی‌اس‌وی مشتری با شماره جست‌وجوی بدون checksum معتبر.",
    )


def _en_onboarding(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "en")
    card = make_luhn(rng)
    iban = make_iban(rng)
    email = _email(first, last, index)
    builder = Builder()
    builder.add("Name: ").pii(name, EntityType.PERSON).add("\n")
    builder.add("Work email: ").pii(email, EntityType.EMAIL).add("\n")
    builder.add("Travel advance test PAN: ").pii(card, EntityType.CREDIT_CARD).add("\n")
    builder.add("Payroll IBAN: ").pii(iban, EntityType.IBAN).add("\n")
    builder.add("ISBN 978-3-16-148410-0 is a catalog example, not an account.\n")
    return LabDocument(
        doc_id=f"DLP-EN-ONB-{index:02d}",
        template="en_onboarding",
        family=Family.EN_ONBOARDING.value,
        split=Split.DEVELOPMENT,
        language=Language.EN,
        format=DocFormat.TEXT,
        title="Onboarding worksheet",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=["978-3-16-148410-0", "9783161484100"],
        description="Onboarding sheet with test PAN and IBAN plus an ISBN hard negative.",
        description_fa="برگه ورود با کارت و شبا آزمایشی و ISBN به‌عنوان منفی سخت.",
    )


def _fa_contract_notice(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "fa")
    nid = make_national_id(rng)
    phone = to_persian_digits(_phone(rng))
    invalid = break_national_id(make_national_id(rng))
    builder = Builder()
    builder.add("موضوع: اخطار قراردادی\n")
    builder.add("نام: ").pii(name, EntityType.PERSON, "fa").add("\n")
    builder.add("کد ملی ").pii(nid, EntityType.IR_NATIONAL_ID, "fa").add("\n")
    builder.add("تلفن ").pii(phone, EntityType.PHONE, "fa").add("\n")
    builder.add(f"کد ملی {invalid} در سامانه پذیرفته نشد و برای بازبینی مانده است.\n")
    builder.add("تاریخ ۱۴۰۳/۰۵/۱۲ و نسخه ۱.۰.۰ ارجاع سند هستند.\n")
    return LabDocument(
        doc_id=f"DLP-FA-CTR-{index:02d}",
        template="fa_contract_notice",
        family=Family.FA_CONTRACT_NOTICE.value,
        split=Split.TEST,
        language=Language.FA,
        format=DocFormat.TEXT,
        title="Persian contract notice",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=[invalid, "1403/05/12", "۱۴۰۳/۰۵/۱۲", "1.0.0"],
        description="Persian contract with a failed national-id left for review.",
        description_fa="اخطار قراردادی با کد ملی نامعتبر برای بازبینی.",
    )


def _en_pdf_memo(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "en")
    email = _email(first, last, index)
    phone = _phone(rng)
    builder = Builder()
    builder.add("Internal memo\n")
    builder.add("Author: ").pii(name, EntityType.PERSON).add("\n")
    builder.add("Contact: ").pii(email, EntityType.EMAIL).add(" / ").pii(phone, EntityType.PHONE).add("\n")
    builder.add("Mr. Protocol is the software module, not a person.\n")
    return LabDocument(
        doc_id=f"DLP-PDF-MEMO-{index:02d}",
        template="en_pdf_memo",
        family=Family.EN_PDF_MEMO.value,
        split=Split.TEST,
        language=Language.EN,
        format=DocFormat.PDF,
        title="PDF memo",
        body=builder.text(),
        metadata={"author": name, "keywords": email, "title": f"Memo {index}"},
        gold_spans=builder.spans,
        gold_meta=[
            GoldMeta(field="author", entity_type=EntityType.PERSON, surface=name),
            GoldMeta(field="keywords", entity_type=EntityType.EMAIL, surface=email),
        ],
        hard_negatives=["Mr. Protocol"],
        description="Text PDF whose metadata also repeats the author mailbox.",
        description_fa="پی‌دی‌اف متنی که فراداده هم نام و ایمیل را تکرار می‌کند.",
    )


def _hardneg_catalog(rng: random.Random, index: int) -> LabDocument:
    bad_card = break_luhn(make_luhn(rng))
    bad_iban = break_iban(make_iban(rng))
    bad_nid = break_national_id(make_national_id(rng))
    body = (
        f"Catalog row {index}\n"
        f"ISBN 978-0-306-40615-7\n"
        f"Invoice {bad_nid}\n"
        f"Card-like {bad_card}\n"
        f"IBAN-like {bad_iban}\n"
        f"Mr. Protocol handler v2.4.1\n"
        f"Date 2026/09/21 SKU-9{index:03d}\n"
    )
    return LabDocument(
        doc_id=f"DLP-HARDNEG-{index:02d}",
        template="hardneg_catalog",
        family=Family.HARDNEG_CATALOG.value,
        split=Split.TEST,
        language=Language.EN,
        format=DocFormat.TEXT,
        title="Hard-negative catalog",
        body=body,
        gold_spans=[],
        hard_negatives=[bad_card, bad_iban, bad_nid, "Mr. Protocol", "2.4.1", "978-0-306-40615-7"],
        description="Lookalikes that must not be redacted: failed checksums, ISBN, protocol title.",
        description_fa="شبیه‌سازی‌هایی که نباید پوشانده شوند: checksum نامعتبر، شابک، عنوان پروتکل.",
    )


def _mixed_ticket(rng: random.Random, index: int) -> LabDocument:
    first, last, name = _person(rng, "en")
    fa_first, fa_last, fa_name = _person(rng, "fa")
    email = _email(first, last, index)
    phone = _phone(rng)
    nid = make_national_id(rng)
    invoice = f"INV-MIX-{index:04d}"
    builder = Builder()
    builder.add("ticket_id,reporter,email,phone,national_id\n")
    builder.add(f"{invoice},").pii(name, EntityType.PERSON).add(" / ").pii(fa_name, EntityType.PERSON, "fa")
    builder.add(",").pii(email, EntityType.EMAIL).add(",").pii(phone, EntityType.PHONE)
    builder.add(",").pii(nid, EntityType.IR_NATIONAL_ID, "fa").add("\n")
    return LabDocument(
        doc_id=f"DLP-TICKET-{index:02d}",
        template="mixed_ticket",
        family=Family.MIXED_TICKET.value,
        split=Split.TEST,
        language=Language.MIXED,
        format=DocFormat.CSV,
        title="Mixed-language ticket CSV",
        body=builder.text(),
        gold_spans=builder.spans,
        hard_negatives=[invoice],
        description="Mixed English/Persian ticket row.",
        description_fa="ردیف تیکت دوزبانه.",
    )


BUILDERS = {
    "en_support_email": _en_support_email,
    "fa_hr_letter": _fa_hr_letter,
    "mixed_invoice_csv": _mixed_invoice_csv,
    "en_onboarding": _en_onboarding,
    "fa_contract_notice": _fa_contract_notice,
    "en_pdf_memo": _en_pdf_memo,
    "hardneg_catalog": _hardneg_catalog,
    "mixed_ticket": _mixed_ticket,
}


def generate_documents(seed: int = DEFAULT_SEED) -> list[LabDocument]:
    rng = random.Random(seed)
    docs: list[LabDocument] = []
    for template, builder in BUILDERS.items():
        for index in range(1, N_VARIANTS + 1):
            docs.append(builder(rng, index))
            assert docs[-1].template == template
    return docs


def documents_by_id(seed: int = DEFAULT_SEED) -> dict[str, LabDocument]:
    return {item.doc_id: item for item in generate_documents(seed)}


def scenarios(seed: int = DEFAULT_SEED) -> list[Scenario]:
    docs = generate_documents(seed)

    def ids(*templates: str) -> list[str]:
        return [item.doc_id for item in docs if item.template in templates]

    return [
        Scenario(
            scenario_id="S01",
            title="English mailbox and invoice CSV",
            description="Development templates: support email plus invoice CSV.",
            description_fa="قالب‌های توسعه: ایمیل پشتیبانی و سی‌اس‌وی فاکتور.",
            doc_ids=ids("en_support_email", "mixed_invoice_csv"),
            split="development",
        ),
        Scenario(
            scenario_id="S02",
            title="Persian HR and onboarding",
            description="Persian digits / ZWNJ HR letter plus English onboarding with test PAN and IBAN.",
            description_fa="نامه منابع انسانی با رقم فارسی و نیم‌فاصله به‌همراه برگه ورود.",
            doc_ids=ids("fa_hr_letter", "en_onboarding"),
            split="development",
        ),
        Scenario(
            scenario_id="S03",
            title="Hard negatives",
            description="Failed checksums, ISBN, Mr. Protocol, versions. Policy should not over-redact.",
            description_fa="checksum نامعتبر، شابک، آقای پروتکل و نسخه. سیاست نباید بیش‌پوشانی کند.",
            doc_ids=ids("hardneg_catalog"),
            split="test",
        ),
        Scenario(
            scenario_id="S04",
            title="PDF memo and Persian contract",
            description="Text PDF with metadata PII plus a Persian contract that keeps invalid national IDs for review.",
            description_fa="پی‌دی‌اف متنی با فراداده حساس و قرارداد فارسی با کد ملی نامعتبر برای بازبینی.",
            doc_ids=ids("en_pdf_memo", "fa_contract_notice"),
            split="test",
        ),
        Scenario(
            scenario_id="S05",
            title="Full 80-document catalog",
            description="Template-disjoint development/test split, seed 24.",
            description_fa="تفکیک قالب توسعه/آزمون، بذر ۲۴.",
            doc_ids=[item.doc_id for item in docs],
            split="all",
        ),
    ]


def scenario_by_id(scenario_id: str, seed: int = DEFAULT_SEED) -> Scenario:
    return next(item for item in scenarios(seed) if item.scenario_id == scenario_id)


def write_examples(folder: Path, seed: int = DEFAULT_SEED) -> None:
    folder.mkdir(parents=True, exist_ok=True)
    docs = generate_documents(seed)
    (folder / "documents.jsonl").write_text(
        "\n".join(item.model_dump_json() for item in docs) + "\n",
        encoding="utf-8",
        newline="\n",
    )
    (folder / "scenarios.jsonl").write_text(
        "\n".join(item.model_dump_json() for item in scenarios(seed)) + "\n",
        encoding="utf-8",
        newline="\n",
    )
    schema = {
        "schema_id": "aria.dlp.lab_document.v1",
        "fields": [
            "doc_id",
            "template",
            "split",
            "language",
            "format",
            "body",
            "gold_spans",
            "gold_meta",
            "hard_negatives",
        ],
        "entity_types": [item.value for item in EntityType],
        "notes": "Synthetic only. Addresses use aria-lab.test. PANs are Luhn-valid test numbers.",
    }
    (folder / "schema.json").write_text(json.dumps(schema, indent=2), encoding="utf-8", newline="\n")
    split_map = {
        "development_templates": sorted(DEV_TEMPLATES),
        "test_templates": sorted(TEST_TEMPLATES),
        "rule": "Split is by document template, not random rows.",
        "n_documents": len(docs),
        "seed": seed,
    }
    (folder / "splits.json").write_text(json.dumps(split_map, indent=2), encoding="utf-8", newline="\n")
    gold = [
        {
            "doc_id": item.doc_id,
            "spans": [span.model_dump() for span in item.gold_spans],
            "meta": [meta.model_dump() for meta in item.gold_meta],
        }
        for item in docs
    ]
    (folder / "gold_spans.json").write_text(json.dumps(gold, indent=2, ensure_ascii=False), encoding="utf-8", newline="\n")
    protocol = """# AriaDLP laboratory protocol

Synthetic bilingual DLP corpus. Seed 24. Split by template.

## What is labeled

Person names from a closed laboratory lexicon, mailbox addresses on `aria-lab.test`,
Iranian mobile numbers, checksum-valid national IDs, Luhn-valid test PANs, IBANs,
and `ARIA-24xxx` employee ids.

## Hard negatives

Invoice / SKU tokens, ISBN, semantic versions, `Mr. Protocol`, dates, and numbers
that fail national-ID / Luhn / IBAN checks.

## PDF

`en_pdf_memo` is a generated text PDF. Gold includes body spans and metadata fields.
Acceptance is content removal plus metadata wipe, not drawing a rectangle.

## Limits

This corpus does not prove production recall. Unknown items stay on the review list.
"""
    (folder / "protocol.md").write_text(protocol, encoding="utf-8", newline="\n")
    feature = """# Feature card

- Task: span detection and reversible laboratory redaction
- Languages: English, Persian (digits, ZWNJ)
- Formats: text, CSV, text PDF (≤10 pages)
- Baseline: ASCII regex without checksum
- Policy: Presidio-style recognizer registry + checksum + lexicon
- Split: template-disjoint
"""
    (folder / "feature_card.md").write_text(feature, encoding="utf-8", newline="\n")