"""Build the release files from the internal v3 lexicon.

    python build_lexicon.py path/to/gem_lexicon_v3.json ../data

The internal file maps word -> {w, f, n, g, p}; each pattern p keeps up to
three HornMorpho segs (degem=False), the v3 rules that shaped it, and whether a
native speaker's tap put it first. Every pattern that has segs is re-derived
here with gemination.py (v3 rules on), and the script stops if any seg
disagrees with the stored positions, so the release cannot drift from the
extractor it ships with. Patterns that exist only because of a native tap
(data/native_taps.json) have no segs.

Writes gemination_lexicon_v3.jsonl, gemination_lexicon_v3.csv and stats.json.
Field definitions are in the dataset card (README.md).
"""
import collections
import csv
import json
import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parent))
import gemination as G

src, out = Path(sys.argv[1]), Path(sys.argv[2])
out.mkdir(parents=True, exist_ok=True)
lex = json.load(open(src, encoding="utf-8"))
taps = {t["word"] for t in json.load(open(out / "native_taps.json", encoding="utf-8"))["items"]}
VERSION = "v3"

rows = []
for w, d in lex.items():
    readings = []
    for p in d["p"]:
        derived = [G.reading_gemination(w, {"seg": s}) for s in p["segs"]]
        bad = [g for g in derived if g["pos"] != p["pos"]]
        if bad:
            sys.exit(f"extractor disagrees with stored pattern for {w}: {bad[0]} vs {p['pos']}")
        if not derived and not p.get("native"):
            sys.exit(f"pattern without segs that is not a native tap: {w} {p['pos']}")
        first = derived[0] if derived else {"sources": ["native"] * len(p["pos"])}
        readings.append({
            "positions": p["pos"],
            "letters": [w[i] for i in p["pos"]],
            "sources": first["sources"],
            "marked": G.mark(w, p["pos"]),
            "root_frequency": p["freq"],
            "pos_tags": p["pos_tags"],
            "alignment_ok": p["ok"],
            "rules": p.get("rules", []),
            "native": bool(p.get("native")),
            "segs": p["segs"],
        })
    analyzed = d["n"] > 0 and bool(readings)
    top = readings[0] if readings else None
    rows.append({
        "word": w,
        "frequency": d["f"],
        "analyzed": analyzed,
        "n_readings": d["n"],
        "n_patterns": len(readings),
        "geminates": top["positions"] if top else [],
        "marked": top["marked"] if top else w,
        "ambiguous": len(readings) > 1,
        "alignment_failed": any(not r["alignment_ok"] for r in readings),
        "no_geminate_any_reading": analyzed and all(not r["positions"] for r in readings),
        "native_checked": w in taps,
        "readings": readings,
    })
rows.sort(key=lambda r: (-r["frequency"], r["word"]))

with open(out / f"gemination_lexicon_{VERSION}.jsonl", "w", encoding="utf-8") as f:
    for r in rows:
        f.write(json.dumps(r, ensure_ascii=False) + "\n")


def join(readings, fn):
    return "|".join(fn(r) for r in readings)


cols = ["word", "frequency", "analyzed", "n_readings", "n_patterns", "ambiguous", "alignment_failed",
        "no_geminate_any_reading", "top_positions", "top_letters", "top_sources", "top_marked",
        "all_positions", "all_sources", "all_marked", "all_root_frequency", "all_pos_tags", "top_rules", "native_checked"]
with open(out / f"gemination_lexicon_{VERSION}.csv", "w", encoding="utf-8", newline="") as f:
    wr = csv.writer(f)
    wr.writerow(cols)
    for r in rows:
        rs = r["readings"]
        t = rs[0] if rs else {"positions": [], "letters": [], "sources": [], "marked": r["word"]}
        wr.writerow([r["word"], r["frequency"], int(r["analyzed"]), r["n_readings"], r["n_patterns"],
                     int(r["ambiguous"]), int(r["alignment_failed"]), int(r["no_geminate_any_reading"]),
                     " ".join(map(str, t["positions"])), " ".join(t["letters"]), " ".join(t["sources"]), t["marked"],
                     join(rs, lambda x: " ".join(map(str, x["positions"]))),
                     join(rs, lambda x: " ".join(x["sources"])),
                     join(rs, lambda x: x["marked"]),
                     join(rs, lambda x: str(x["root_frequency"])),
                     join(rs, lambda x: " ".join(x["pos_tags"])),
                     " ".join(t.get("rules", [])), int(r["native_checked"])])

T = sum(r["frequency"] for r in rows)
A = [r for r in rows if r["analyzed"]]


def share(sel):
    return {"types": len(sel), "tokens": sum(r["frequency"] for r in sel),
            "token_share": round(sum(r["frequency"] for r in sel) / T, 4)}


top_n = collections.defaultdict(list)
for r in A:
    top_n[len(r["geminates"])].append(r)
src_types, src_tokens = collections.Counter(), collections.Counter()
for r in A:
    for s in r["readings"][0]["sources"]:
        src_types[s] += 1
        src_tokens[s] += r["frequency"]
stats = {
    "word_types": len(rows), "corpus_tokens": T,
    "analyzed": share(A), "not_analyzed": share([r for r in rows if not r["analyzed"]]),
    "ambiguous": share([r for r in rows if r["ambiguous"]]),
    "alignment_failed": share([r for r in rows if r["alignment_failed"]]),
    "no_geminate_any_reading": share([r for r in rows if r["no_geminate_any_reading"]]),
    "geminate_in_top_reading": share([r for r in A if r["geminates"]]),
    "geminate_in_any_reading": share([r for r in A if any(x["positions"] for x in r["readings"])]),
    "two_or_more_in_top_reading": share([r for r in A if len(r["geminates"]) >= 2]),
    "top_reading_geminate_count": {k: share(v) for k, v in sorted(top_n.items())},
    "top_reading_sources": {"geminates_over_types": dict(src_types), "geminates_token_weighted": dict(src_tokens)},
    "top_reading_shaped_by_rule": {name: share([r for r in rows if r["readings"] and name in r["readings"][0]["rules"]])
                                   for name in ("causative_glottal", "relative_m_light", "relative_exist")},
    "native_checked": share([r for r in rows if r["native_checked"]]),
}
json.dump(stats, open(out / "stats.json", "w", encoding="utf-8"), ensure_ascii=False, indent=1)
print(json.dumps(stats, ensure_ascii=False, indent=1))