#!/usr/bin/env python3
"""Driver: Lean-Workbook (proved rows) -> lean2zig units -> batched `zig test` differential check -> stats.

  ZIG_BIN=<zig 0.17.0> python3 tools/lean2zig/run.py [--limit N] [--batch 150] [--jobs 2] [--stage translate|check|report]

Data goes to the gitignored out/lean2zig/. Resumable: translation is cached by translator hash, each batch result by batch hash.
Source of statements: any jsonl with {id, formal_statement} (see load_rows); default is the proved rows of internlm/Lean-Workbook.
"""
import os, sys, re, json, time, hashlib, subprocess, shutil, argparse, collections, itertools
from concurrent.futures import ThreadPoolExecutor
from multiprocessing import Pool

HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.abspath(os.path.join(HERE, '..', '..'))
sys.path.insert(0, HERE)
import lean2zig as L

OUT = os.path.join(ROOT, 'out', 'lean2zig')
ZIG = os.environ.get('ZIG_BIN') or shutil.which('zig')


def sha(*paths):
    h = hashlib.sha1()
    for p in paths:
        h.update(open(p, 'rb').read())
    return h.hexdigest()[:12]


def load_rows(limit=None):
    import pandas as pd
    from huggingface_hub import hf_hub_download
    p = hf_hub_download('internlm/Lean-Workbook', 'wkbk_1009.parquet', repo_type='dataset', local_dir=os.path.join(OUT, 'hf'))
    df = pd.read_parquet(p)
    n_in = len(df)
    df = df[df.status == 'proved']
    n_proved = len(df)
    seen, rows = {}, []
    for i, s in zip(df.id.tolist(), df.formal_statement.tolist()):
        key = L.statement_text(s)
        if key in seen:
            continue
        seen[key] = i
        rows.append({'id': i, 'src': s})
    rows.sort(key=lambda r: r['id'])
    if limit:
        rows = rows[:limit]
    return n_in, n_proved, rows


def _tr(r):
    try:
        u = L.translate(r['id'], r['src'])
    except Exception as e:  # a converter bug must not take the run down; counted as its own reason
        return {'id': r['id'], 'reasons': ['internal_error:%s' % type(e).__name__]}
    if isinstance(u, L.Rejected):
        return {'id': r['id'], 'reasons': u.reasons}
    return {'id': r['id'], 'fn': u.fn, 'text': u.text, 'heavy': u.heavy, 'sides': u.sides, 'nparams': u.nparams, 'nhyps': u.nhyps}


def translate_all(rows, jobs):
    with Pool(jobs) as pool:
        return pool.map(_tr, rows, chunksize=64)


# ---------------------------------------------------------------- zig batches
HEADER = 'const std = @import("std");\nconst lean = @import("lean.zig");\n\n'
ERR = re.compile(r'^(?P<file>[^\s:]+\.zig):(?P<line>\d+):(?P<col>\d+): error: (?P<msg>.*)$')
TESTLINE = re.compile(r'^\d+/\d+ \S+?\.test\.(?P<name>.+?)\.\.\.(?P<res>OK|SKIP|FAIL \((?P<err>\w+)\))')


def run_zig(path, timeout=150):
    """zig test in its own process group, so a timeout also kills the test binary zig spawned."""
    import signal
    p = subprocess.Popen([ZIG, 'test', os.path.basename(path), '--cache-dir', os.path.join(OUT, 'zcache'),
                          '--global-cache-dir', os.path.join(OUT, 'zglobal')],
                         cwd=os.path.dirname(path), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, start_new_session=True)
    try:
        out, _ = p.communicate(timeout=timeout)
    except subprocess.TimeoutExpired:
        os.killpg(p.pid, signal.SIGKILL)
        p.communicate()
        return None
    return out.decode('utf8', 'replace')


def check_group(args):
    """Check a list of units in one zig file; returns {fn: (status, detail)}. Falls back to bisection on timeout/compile trouble."""
    units, workdir, tag = args
    os.makedirs(workdir, exist_ok=True)
    shutil.copy(os.path.join(HERE, 'lean.zig'), os.path.join(workdir, 'lean.zig'))
    result = {}
    live = list(units)
    for attempt in range(6):
        if not live:
            break
        text, spans, line = HEADER, {}, HEADER.count('\n') + 1
        for u in live:
            chunk = u['text'] + '\n'
            spans[u['fn']] = (line, line + chunk.count('\n') - 1)
            text += chunk
            line += chunk.count('\n')
        path = os.path.join(workdir, '%s.zig' % tag)
        open(path, 'w').write(text)
        out = run_zig(path)
        if out is None:  # timeout: bisect
            if len(live) == 1:
                result[live[0]['fn']] = ('timeout', '')
                return result
            h = len(live) // 2
            result.update(check_group((live[:h], workdir, tag + 'a')))
            result.update(check_group((live[h:], workdir, tag + 'b')))
            return result
        errs = [m for m in (ERR.match(l) for l in out.splitlines()) if m]
        if errs and not any(TESTLINE.match(l) for l in out.splitlines()):
            bad = {}
            for m in errs:
                ln = int(m['line'])
                if os.path.basename(m['file']) != os.path.basename(path):
                    continue
                for fn, (a, b) in spans.items():
                    if a <= ln <= b:
                        bad.setdefault(fn, m['msg'][:160])
            if bad:
                for fn, msg in bad.items():
                    result[fn] = ('compile', msg)
                live = [u for u in live if u['fn'] not in bad]
                continue
            # unmappable compile failure: isolate per unit
            if len(live) == 1:
                result[live[0]['fn']] = ('compile', (errs[0]['msg'] if errs else out[:160])[:160])
                return result
            h = len(live) // 2
            result.update(check_group((live[:h], workdir, tag + 'a')))
            result.update(check_group((live[h:], workdir, tag + 'b')))
            return result
        seen = {}
        for l in out.splitlines():
            m = TESTLINE.match(l)
            if m:
                seen[m['name']] = ('pass', '') if m['res'] in ('OK',) else ('skip', '') if m['res'] == 'SKIP' else ('fail', m['err'])
        if len(seen) < len(live):  # the run died (panic / crash) before finishing: isolate
            if len(live) == 1:
                result[live[0]['fn']] = ('crash', out[-200:])
                return result
            h = len(live) // 2
            result.update(check_group((live[:h], workdir, tag + 'a')))
            result.update(check_group((live[h:], workdir, tag + 'b')))
            return result
        for u in live:
            result[u['fn']] = seen[u['fn']]
        return result
    for u in live:
        result.setdefault(u['fn'], ('compile', 'unresolved after retries'))
    return result


def counterexample(u):
    """Re-run a mismatching unit with a printing assertion; returns the failing vector as text."""
    m = re.search(r'tally\.admit\((.*), \.\{ (.*?) \}\);', u['text'])
    names = [x.strip() for x in m.group(2).split(',')] if m else []
    if not names:
        return ''
    fmt = ', '.join('%s={d}' % n for n in names)
    t = u['text'].replace('        try tally.admit(%s, ' % m.group(1),
                          '        if (!(%s) and !lean.skipped()) { std.debug.print("CE %s\\n", .{ %s }); return error.TestUnexpectedResult; }\n        try tally.admit(%s, ' % (m.group(1), fmt, ', '.join(names), m.group(1)))
    wd = os.path.join(OUT, 'ce')
    os.makedirs(wd, exist_ok=True)
    shutil.copy(os.path.join(HERE, 'lean.zig'), os.path.join(wd, 'lean.zig'))
    p = os.path.join(wd, 'ce.zig')
    open(p, 'w').write(HEADER + t)
    out = run_zig(p, 120) or ''
    for l in out.splitlines():
        i = l.find('CE ')
        if i >= 0 and '=' in l[i:]:
            return l[i + 3:]
    return ''


def check_all(units, batch, jobs):
    bdir = os.path.join(OUT, 'batches')
    os.makedirs(bdir, exist_ok=True)
    groups = [units[i:i + batch] for i in range(0, len(units), batch)]
    results, todo = {}, []
    for gi, g in enumerate(groups):
        key = hashlib.sha1((sha(os.path.join(HERE, 'lean.zig')) + ''.join(u['text'] for u in g)).encode()).hexdigest()[:12]
        cache = os.path.join(bdir, 'b%05d.%s.json' % (gi, key))
        if os.path.exists(cache):
            results.update(json.load(open(cache)))
        else:
            todo.append((gi, g, cache))
    print('batches: %d total, %d cached, %d to run' % (len(groups), len(groups) - len(todo), len(todo)), flush=True)
    t0 = time.time()

    def work(item):
        gi, g, cache = item
        r = check_group((g, os.path.join(OUT, 'work%d' % (gi % jobs)), 'b%05d' % gi))
        json.dump(r, open(cache, 'w'))
        return r

    done = 0
    with ThreadPoolExecutor(jobs) as ex:
        for r in ex.map(work, todo):
            results.update(r)
            done += 1
            if done % 5 == 0 or done == len(todo):
                print('  %d/%d batches, %.0fs' % (done, len(todo), time.time() - t0), flush=True)
    return results


# ---------------------------------------------------------------- twin check (same normalisation as lean-v2-review/shape_audit.py)
KW = set('const var pub fn return if else while for switch struct and or orelse try comptime inline break continue true false undefined'.split())
TY = re.compile(r'^(u|i)\d+$|^usize$|^isize$|^bool$|^type$')


def shape(text):
    body = '\n'.join(l for l in text.split('\n') if not l.lstrip().startswith('///'))
    toks = re.findall(r'@\w+|[A-Za-z_]\w*|0x[0-9a-fA-F]+|\d+|\+%|-%|\*%|<<|>>|==|!=|<=|>=|\S', body)
    return [x if (x in KW or x.startswith('@')) else 'T' if TY.match(x) else 'N' if x[0].isdigit() else 'ID' if re.match(r'[A-Za-z_]', x) else x for x in toks]


def twin_rate(texts, thr=0.9):
    """Pairs with 5-gram Jaccard >= thr (inverted index over grams, exact). Returns (units with a twin, pairs, greedy keep-first kept)."""
    G = []
    for t in texts:
        s = shape(t)
        G.append({tuple(s[i:i + 5]) for i in range(max(len(s) - 4, 1))})
    idx = collections.defaultdict(list)
    twin, npairs, dropped = set(), 0, set()
    for i, g in enumerate(G):
        cand = collections.Counter()
        for gram in g:
            for j in idx[gram]:
                cand[j] += 1
        for j, c in cand.items():
            gj = G[j]
            if c / (len(g) + len(gj) - c) >= thr:
                npairs += 1
                twin.update((i, j))
                if j not in dropped:
                    dropped.add(i)  # greedy keep-first: i is dropped if an earlier kept unit is its twin
        for gram in g:
            idx[gram].append(i)
    return len(twin), npairs, len(G) - len(dropped)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('--limit', type=int)
    ap.add_argument('--batch', type=int, default=150)
    ap.add_argument('--jobs', type=int, default=2)
    ap.add_argument('--tag', default='full')
    ap.add_argument('--stats-out')
    a = ap.parse_args()
    os.makedirs(OUT, exist_ok=True)
    t0 = time.time()
    n_in, n_proved, rows = load_rows(a.limit)
    print('rows in %d, proved %d, unique proved statements %d' % (n_in, n_proved, len(rows)), flush=True)
    tr = translate_all(rows, a.jobs)
    print('translated in %.1fs' % (time.time() - t0), flush=True)
    rej = [t for t in tr if 'reasons' in t]
    ok = [t for t in tr if 'text' in t]
    # unique function names (ids differ, camel names could still collide)
    seenfn = set()
    for u in ok:
        base, n = u['fn'], 1
        while u['fn'] in seenfn:
            n += 1
            u['fn'] = base + str(n)
        if u['fn'] != base:
            u['text'] = u['text'].replace(base, u['fn'])
        seenfn.add(u['fn'])
    t1 = time.time()
    res = check_all(ok, a.batch, a.jobs)
    print('zig check %.0fs' % (time.time() - t1), flush=True)
    status = collections.Counter()
    mism, kept, drops, sub = [], [], collections.Counter(), collections.Counter()
    for u in ok:
        st, det = res[u['fn']]
        if st == 'pass':
            kept.append(u); status['pass'] += 1
        elif st == 'fail' and det in ('TooFewVectors', 'NoVector', 'OnlySkipped'):
            status[det] += 1; drops['hypotheses rarely satisfiable'] += 1; sub[det] += 1
        elif st == 'fail':
            status['mismatch'] += 1; drops['semantic mismatch'] += 1; mism.append(u)
        else:
            status[st] += 1; drops['zig %s' % st] += 1
    for u in mism[:12]:
        u['ce'] = counterexample(u)
    # reasons
    primary = collections.Counter(t['reasons'][0] for t in rej)
    allr = collections.Counter(r for t in rej for r in set(t['reasons']))
    sole = collections.Counter(t['reasons'][0] for t in rej if len(set(t['reasons'])) == 1)
    def fam(r):
        return r.split(':')[0]
    stats = {
        'rows_in': n_in, 'proved_rows': n_proved, 'unique_proved_statements': len(rows),
        'parsed_and_emitted': len(ok), 'rejected_at_parse': len(rej),
        'reject_primary': dict(primary.most_common()), 'reject_any': dict(allr.most_common()), 'reject_sole_blocker': dict(sole.most_common()),
        'check': dict(status), 'dropped': dict(drops), 'dropped_detail': dict(sub), 'kept': len(kept),
        'compile_errors': collections.Counter(res[u['fn']][1] for u in ok if res[u['fn']][0] == 'compile').most_common(15),
        'mismatches': [{'id': u['id'], 'text': u['text'], 'ce': u.get('ce', '')} for u in mism[:12]],
        'translator_sha': sha(os.path.join(HERE, 'lean2zig.py'), os.path.join(HERE, 'lean.zig')),
        'seconds': round(time.time() - t0),
    }
    tb = sum(len(u['text'].encode()) for u in kept)
    stats['units_kept_bytes'] = tb
    stats['units_kept_tokens_est'] = round(tb / 3.27)
    tw, pairs, kept_after = twin_rate([u['text'] for u in kept])
    stats['twin'] = {'units_with_twin': tw, 'pairs': pairs, 'rate': round(tw / max(1, len(kept)), 4), 'kept_after_greedy_gate': kept_after}
    # same measure on the theorem functions alone (doc comment and test block removed): the test block is shared boilerplate
    tw2, pairs2, kept2 = twin_rate([L.body_of(u['text']) for u in kept])
    stats['twin_functions_only'] = {'units_with_twin': tw2, 'pairs': pairs2, 'rate': round(tw2 / max(1, len(kept)), 4), 'kept_after_greedy_gate': kept2}
    import random
    rnd = random.Random(7)
    stats['samples'] = [{'id': u['id'], 'text': u['text']} for u in rnd.sample(kept, min(5, len(kept)))]
    fam = collections.Counter()
    for t in rej:
        fam[t['reasons'][0].split(':')[0]] += 1
    stats['reject_primary_by_family'] = dict(fam.most_common())
    json.dump(stats, open(os.path.join(OUT, 'stats_%s.json' % a.tag), 'w'), ensure_ascii=False, indent=1)
    with open(os.path.join(OUT, 'units_%s.jsonl' % a.tag), 'w') as f:
        for u in kept:
            f.write(json.dumps({'id': u['id'], 'fn': u['fn'], 'text': u['text']}, ensure_ascii=False) + '\n')
    with open(os.path.join(OUT, 'rejected_%s.jsonl' % a.tag), 'w') as f:
        for t in rej:
            f.write(json.dumps(t, ensure_ascii=False) + '\n')
    print(json.dumps({k: v for k, v in stats.items() if k not in ('reject_any', 'reject_sole_blocker', 'mismatches')}, ensure_ascii=False, indent=1)[:4000])


if __name__ == '__main__':
    main()