#**************************************************************
#
#  Licensed to the Apache Software Foundation (ASF) under one
#  or more contributor license agreements.  See the NOTICE file
#  distributed with this work for additional information
#  regarding copyright ownership.  The ASF licenses this file
#  to you under the Apache License, Version 2.0 (the
#  "License"); you may not use this file except in compliance
#  with the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
#  Unless required by applicable law or agreed to in writing,
#  software distributed under the License is distributed on an
#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
#  KIND, either express or implied.  See the License for the
#  specific language governing permissions and limitations
#  under the License.
#
#**************************************************************

# usage: gate.py <tag> [--stages s,...] [--modes ext,strict] [--fixture-modes v00,v10,v11,ext,strict] [--prev DIR] [--jobs FILE] [--limit N] [--port P]
#                [--build mod,...] [--libs lib.dylib,...] [--stall SECONDS] [--force] [--crosscheck]
# The corpus regression gate as one resumable run in runs/gate-<tag>/. Stages, in order:
#   build     rebuild the modules (--build) and deliver them to the solver
#   refresh   copy the rebuilt libraries (--libs) from the solver into the app copy and verify them
#   corpus    save the job list in ODF 1.2 Extended (ext) and strict (strict) mode with the app copy
#   validate  validate.py and the checkers on the saved packages; kinds compared with baseline/ and --prev;
#             a checker that did not run, a shall finding of idcheck/pkgcheck/doctypecheck, or more formula findings than --prev fails
#   dump      reload every saved package and dump a fixed property set (dump7.py), with a stall watchdog
#   diff      dumps (diff7.py) and packages (cmp7.py) against --prev; differences not in gate-volatile.tsv are unexplained
#   fixtures  gate-fixtures.tsv saved in five version modes, reload checks, validation; results against --prev
# --jobs freezes the inputs (source<TAB>output lines; outputs are rewritten); default: --prev's list, else make-jobs.sh.
# Exit status 0 only if every stage that ran passed.
import argparse, collections, json, os, re, shutil, socket, subprocess, sys, threading, time

D = os.path.dirname(os.path.abspath(__file__))
PY = [sys.executable, "-I"]
STAGES = ["build", "refresh", "corpus", "validate", "dump", "diff", "fixtures"]
FIX_MODES = ["v00", "v10", "v11", "ext", "strict"]
DEFAULT_LIBS = "libxo.dylib,libsw.dylib,libsc.dylib,libsd.dylib,libsfx.dylib"


def listening(port):
    with socket.socket() as s:
        s.settimeout(0.5)
        return s.connect_ex(("localhost", port)) == 0


def kill_office(profile):
    subprocess.run(["pkill", "-f", "profile_" + profile], capture_output=True)
    time.sleep(2)


def run(cmd, log=None, timeout=None, cwd=None, env=None):
    """Runs cmd, appending its output to log; returns the exit code (124 on timeout)."""
    out = open(log, "a") if log else subprocess.DEVNULL
    try:
        return subprocess.run(cmd, stdout=out, stderr=subprocess.STDOUT, timeout=timeout, cwd=cwd, env=env).returncode
    except subprocess.TimeoutExpired:
        return 124
    finally:
        if log:
            out.close()


def read_jobs(path):
    return [tuple(l.rstrip("\n").split("\t")) for l in open(path) if l.strip()]


def rewrite_jobs(jobs, outdir):
    """Same sources, outputs moved into outdir."""
    return [(src, os.path.join(outdir, os.path.basename(out))) for src, out in jobs]


def read_volatile(path=os.path.join(D, "gate-volatile.tsv")):
    return {l.split("\t")[0]: l.rstrip("\n").split("\t")[1] for l in open(path) if l.strip() and not l.startswith("#")}


def classify(diff, volatile):
    """diff: diff7.py's result; returns (identical, volatile differing, unexplained differing)."""
    differing = sorted(k for k, v in diff.items() if v["ndiff"])
    vol = [k for k in differing if k in volatile]
    return len(diff) - len(differing), vol, [k for k in differing if k not in volatile]


def run_with_stall(cmd, progress, stall, poll=2.0, log=None):
    """Runs cmd until it exits or progress() has not changed for `stall` seconds (then kills it).
    Returns ('exit', returncode) or ('stalled', None)."""
    out = open(log, "a") if log else subprocess.DEVNULL
    p = subprocess.Popen(cmd, stdout=out, stderr=subprocess.STDOUT)
    last, since = progress(), time.time()
    try:
        while p.poll() is None:
            time.sleep(poll)
            now = progress()
            if now != last:
                last, since = now, time.time()
            elif time.time() - since > stall:
                p.kill(); p.wait()
                return "stalled", None
        return "exit", p.returncode
    finally:
        if log:
            out.close()


def bridge_dead(path):
    """True for a dump that only records that the office died under an earlier document."""
    try:
        d = json.load(open(path))
    except Exception:
        return False
    return isinstance(d, dict) and (str(d.get("error", "")).startswith("Binary URP bridge") or str(d.get("body_error", "")).startswith("Binary URP bridge"))


def dump_dir(src, dest, profile, port, stall, log, tool=None, poll=2.0):
    """Reloads every package in src into dest/*.json. A document that stalls the office or kills it gets an error
    marker only after `stall` seconds without progress, never because the whole batch took long.
    tool(port, dest, files) -> argv replaces dump7.py under the office (for tests); then no office is started."""
    os.makedirs(dest, exist_ok=True)
    files = sorted(os.path.join(src, f) for f in os.listdir(src) if not f.startswith("."))
    count = lambda: len([f for f in os.listdir(dest) if f.endswith(".json")])
    stalls = 0
    retried = 0
    for attempt in range(4):
        while count() < len(files):
            if tool is None and not listening(port):
                if run([os.path.join(D, "start.sh"), profile, str(port)], log) != 0:
                    return {"error": "office did not start", "stalls": stalls}
            before = count()
            marker = os.path.join(dest, ".current")
            argv = tool(port, dest, files) if tool else [os.path.join(D, "runpy.sh"), os.path.join(D, "dump7.py"), str(port), dest] + files
            how, rc = run_with_stall(argv, lambda: (count(), os.path.getmtime(marker) if os.path.exists(marker) else 0), stall, poll, log=log)
            if how == "stalled" or rc != 0:
                cur = open(marker).read().strip() if os.path.exists(marker) else ""
                if cur and not os.path.exists(os.path.join(dest, os.path.basename(cur) + ".json")):
                    reason = ("HANG: no progress for %ds" % stall) if how == "stalled" else "CRASH: rc=%s" % rc
                    json.dump({"error": reason}, open(os.path.join(dest, os.path.basename(cur) + ".json"), "w"))
                    stalls += 1
                if tool is None:
                    kill_office(profile)
            elif count() == before:
                return {"error": "dump7.py made no progress", "stalls": stalls}
        # dump7.py records "bridge disposed" for every document after an office crash; those are not dumps, so redo them
        gone = [f for f in os.listdir(dest) if f.endswith(".json") and bridge_dead(os.path.join(dest, f))]
        if not gone or attempt == 3:
            break
        if tool is None:
            kill_office(profile)
        for f in gone:
            os.remove(os.path.join(dest, f))
        retried += len(gone)
    if tool is None:
        kill_office(profile)
    res = {"documents": count(), "stalls": stalls}
    if retried:
        res["bridge_retried"] = retried
    return res


def count_done(done):
    ok = fail = 0
    if os.path.exists(done):
        for l in open(done):
            ok += l.rstrip("\n").endswith("\tOK")
            fail += "\tFAIL" in l
    return ok, fail


class Gate:
    def __init__(self, a):
        self.a = a
        self.run = os.path.join(D, "runs", "gate-" + a.tag)
        os.makedirs(self.run, exist_ok=True)
        self.res_path = os.path.join(self.run, "results.json")
        self.res = json.load(open(self.res_path)) if os.path.exists(self.res_path) else {}
        self.modes = a.modes.split(",")
        self.fix_modes = a.fixture_modes.split(",")
        self.prev = os.path.abspath(a.prev) if a.prev else None

    def save(self):
        json.dump(self.res, open(self.res_path, "w"), indent=1)

    def log(self, name):
        return os.path.join(self.run, name + ".log")

    def prev_path(self, *candidates):
        for c in candidates:
            p = os.path.join(self.prev, c) if self.prev else None
            if p and os.path.exists(p):
                return p
        return None

    # ---- stages
    def build(self):
        mods = [m for m in self.a.build.split(",") if m]
        if not mods:
            return {"skipped": "no --build modules"}
        env = os.environ.get("ODFV_BUILD_ENV") or sorted(__import__("glob").glob(os.path.join(D, "..", "..", "main", "*Env.Set.sh")))[-1]
        res = {}
        for m in mods:
            cmd = "cd %s/../../main && source %s && cd %s && perl $SOLARENV/bin/build.pl && perl $SOLARENV/bin/deliver.pl" % (D, env, m)
            res[m] = run(["/bin/zsh", "-c", cmd], self.log("build_" + m))
        return {"ok": all(v == 0 for v in res.values()), "rc": res}

    def refresh(self):
        libs = [l for l in self.a.libs.split(",") if l]
        out = subprocess.run([os.path.join(D, "refresh-app.sh")] + libs, capture_output=True, text=True)
        return {"ok": out.returncode == 0, "output": out.stdout.strip().splitlines()}

    def jobs(self):
        if self.a.jobs:
            return read_jobs(self.a.jobs)
        pj = self.prev_path("jobs.tsv", "ext/jobs.tsv")
        if pj:
            return read_jobs(pj)
        out = subprocess.run([os.path.join(D, "make-jobs.sh"), "OUT"], capture_output=True, text=True, check=True).stdout
        return [tuple(l.split("\t")) for l in out.splitlines()]

    def corpus(self):
        jobs = self.jobs()
        if self.a.limit:
            jobs = jobs[:self.a.limit]
        with open(os.path.join(self.run, "jobs.tsv"), "w") as f:
            f.writelines("%s\t%s\n" % j for j in jobs)
        procs, res = {}, {}
        for i, mode in enumerate(self.modes):
            md = os.path.join(self.run, mode)
            os.makedirs(os.path.join(md, "out"), exist_ok=True)
            with open(os.path.join(md, "jobs.tsv"), "w") as f:
                f.writelines("%s\t%s\n" % j for j in rewrite_jobs(jobs, os.path.join(md, "out")))
            open(os.path.join(md, "done.tsv"), "a").close()
            procs[mode] = subprocess.Popen([os.path.join(D, "drive.sh"), mode, str(self.a.port + i), os.path.join(md, "jobs.tsv"), os.path.join(md, "done.tsv")])
        for mode, p in procs.items():
            p.wait()
            md = os.path.join(self.run, mode)
            ok, fail = count_done(os.path.join(md, "done.tsv"))
            res[mode] = {"rc": p.returncode, "ok": ok, "fail": fail, "jobs": len(jobs), "packages": len(os.listdir(os.path.join(md, "out")))}
            pd = self.prev_path(mode + "/done.tsv")
            if pd and not self.a.limit:
                res[mode]["prev_ok_fail"] = count_done(pd)
        res["ok"] = all(r["rc"] == 0 and r["ok"] + r["fail"] == r["jobs"] and r["ok"] > 0 for r in res.values() if isinstance(r, dict))
        if not self.a.limit:
            res["ok"] = res["ok"] and all(tuple(r["prev_ok_fail"]) == (r["ok"], r["fail"]) for r in res.values() if isinstance(r, dict) and "prev_ok_fail" in r)
        return res

    def prev_validate(self, *keys):
        """The validate-result dict of --prev at keys, or None when it has none."""
        pf = self.prev_path("results.json")
        d = json.load(open(pf)) if pf else {}
        for k in keys:
            d = d.get(k) if isinstance(d, dict) else None
        return d if isinstance(d, dict) else None

    def shall_problems(self, r, prev):
        """Checker results that must fail the gate: a checker that did not run, a Part 1/3 finding, a formula finding that grew."""
        bad = []
        for n in ("ids", "pkg", "doctype", "formulas"):
            if r.get("shall_" + n) is None:
                bad.append("%s checker did not run" % n)
        for n in ("ids", "pkg", "doctype"):
            if r.get("shall_" + n):
                bad.append("%d shall findings in %s" % (r["shall_" + n], n))
        pf = (prev or {}).get("shall_formulas")
        if not self.a.limit and r.get("shall_formulas") is not None and pf is not None and r["shall_formulas"] > pf:
            bad.append("shall_formulas %d > %d in --prev" % (r["shall_formulas"], pf))
        return bad

    def validate_dir(self, md, out, kinds_base, label):
        """validate.py + report.py + the checkers on out/; returns a result dict."""
        r = {}
        log = os.path.join(md, "validate.log")
        run(PY + [os.path.join(D, "validate.py"), out, os.path.join(md, "val.json")], log)
        val = json.load(open(os.path.join(md, "val.json")))
        r["errors"] = {v: len(e) for v, e in val["errors"].items()}
        r["packages"] = len(val["packages"])
        for v in ("12", "14", "12x", "13", "13x"):
            kp = os.path.join(md, "kinds%s.json" % ("" if v == "12" else v))
            run(PY + [os.path.join(D, "report.py"), os.path.join(md, "val.json"), kp, v], os.path.join(md, "report%s.log" % v))
            r["kinds" + v] = len(json.load(open(kp)))
        for name, script, pat in (("ids", "idcheck.py", r"(\d+) errors"), ("pkg", "pkgcheck.py", r"(\d+) shall"),
                                  ("doctype", "doctypecheck.py", r"(\d+) shall"), ("formulas", "formulacheck.py", r"(\d+) shall")):
            o = subprocess.run(PY + [os.path.join(D, script), out, os.path.join(md, name + ".json")], capture_output=True, text=True)
            m = re.search(pat, o.stdout)
            r["shall_" + name] = int(m.group(1)) if m and o.returncode == 0 else None
        base = kinds_base
        if base and os.path.exists(base):
            r["vs_baseline"] = run(PY + [os.path.join(D, "compare.py"), base, os.path.join(md, "kinds.json")], os.path.join(md, "compare_base.log"))
        return r

    def validate(self):
        res = {}
        for mode in self.modes:
            md = os.path.join(self.run, mode)
            r = self.validate_dir(md, os.path.join(md, "out"), os.path.join(D, "baseline", mode + ".kinds.json"), mode)
            pk = self.prev_path(mode + "/kinds.json")
            r["problems"] = self.shall_problems(r, self.prev_validate("validate", mode))
            if not self.a.limit and not pk and "vs_baseline" not in r:
                r["problems"].append("no baseline/%s.kinds.json and no --prev kinds to compare with" % mode)
            if pk and not self.a.limit:
                r["vs_prev"] = run(PY + [os.path.join(D, "compare.py"), pk, os.path.join(md, "kinds.json")], os.path.join(md, "compare_prev.log"))
                r["vs_prev_reverse"] = run(PY + [os.path.join(D, "compare.py"), os.path.join(md, "kinds.json"), pk], os.path.join(md, "compare_prev_rev.log"))
            res[mode] = r
        res["ok"] = all(r.get("vs_baseline", 0) == 0 and r.get("vs_prev", 0) == 0 and r.get("vs_prev_reverse", 0) == 0 and not r["problems"] for r in res.values())
        return res

    def dump(self):
        res, threads = {}, []
        for i, mode in enumerate(self.modes):
            def one(mode=mode, i=i):
                md = os.path.join(self.run, mode)
                res[mode] = dump_dir(os.path.join(md, "out"), os.path.join(md, "dump"), "gate_dump_%s_%s" % (self.a.tag, mode),
                                     self.a.port + 10 + i, self.a.stall, self.log("dump_" + mode))
            t = threading.Thread(target=one); t.start(); threads.append(t)
        for t in threads:
            t.join()
        res["ok"] = all("error" not in r for r in res.values())
        for mode in self.modes:
            md = os.path.join(self.run, mode, "dump")
            res[mode]["bridge_errors"] = sorted(f for f in os.listdir(md) if f.endswith(".json") and bridge_dead(os.path.join(md, f)))
            res["ok"] = res["ok"] and not res[mode]["bridge_errors"]
            res[mode]["hang_markers"] = sorted(f for f in os.listdir(md) if f.endswith(".json") and "error" in json.load(open(os.path.join(md, f))) and
                                               str(json.load(open(os.path.join(md, f)))["error"]).startswith(("HANG", "CRASH")))
        return res

    def diff(self):
        if not self.prev:
            return {"skipped": "no --prev"}
        volatile, res = read_volatile(), {}
        for mode in self.modes:
            md = os.path.join(self.run, mode)
            old = self.prev_path(mode + "/dump", "dump_" + mode)
            oldrun = self.prev_path(mode + "/out")
            r = {}
            if old:
                # compare only the documents this run saved (a --limit run saves fewer)
                sub = os.path.join(md, "prev-dump")
                shutil.rmtree(sub, ignore_errors=True); os.makedirs(sub)
                for f in os.listdir(os.path.join(md, "dump")):
                    if f.endswith(".json") and os.path.exists(os.path.join(old, f)):
                        os.symlink(os.path.join(old, f), os.path.join(sub, f))
                dj = os.path.join(md, "diff_dump.json")
                run(PY + [os.path.join(D, "diff7.py"), sub, os.path.join(md, "dump"), dj], os.path.join(md, "diff_dump.log"))
                same, vol, unexplained = classify(json.load(open(dj)), volatile)
                r["dump"] = {"compared": len(os.listdir(sub)), "identical": same, "volatile": vol, "unexplained": unexplained}
            if oldrun:
                stage = os.path.join(self.run, "cmp-" + mode)
                shutil.rmtree(stage, ignore_errors=True); os.makedirs(os.path.join(stage, "out"))
                for f in os.listdir(os.path.join(md, "out")):
                    if os.path.exists(os.path.join(oldrun, f)):
                        os.symlink(os.path.join(oldrun, f), os.path.join(stage, "out", f))
                # cmp7 reads <run>/out for both sides: the old side is the subset linked above, the new side this run
                cj = os.path.join(md, "cmp7.json")
                cp = subprocess.run(PY + [os.path.join(D, "cmp7.py"), stage, md, mode, cj], capture_output=True, text=True)
                open(os.path.join(md, "cmp7.log"), "w").write(cp.stdout + cp.stderr)
                m = re.search(r"differing after env masks: (\d+); differing after intended-edit normalisation: (\d+)", cp.stdout)
                if m:
                    cmp = json.load(open(cj))
                    differing = sorted(k for k, v in cmp.items() if v.get("norm_diff_streams") or v.get("names_diff") or v.get("missing_in_new"))
                    r["packages"] = {"after_masks": int(m.group(1)), "volatile": [k for k in differing if k in volatile],
                                     "unexplained": [k for k in differing if k not in volatile]}
                else:
                    r["packages"] = {"error": (cp.stderr or cp.stdout)[-200:], "unexplained": ["cmp7.py failed"]}
            res[mode] = r
        res["ok"] = all(("dump" not in r or not r["dump"]["unexplained"]) and ("packages" not in r or not r["packages"]["unexplained"]) for r in res.values())
        return res

    def fixtures(self):
        entries = [l.rstrip("\n").split("\t") for l in open(os.path.join(D, "gate-fixtures.tsv")) if l.strip() and not l.startswith("#")]
        def src_path(s):
            return os.path.join(D, "..", "..", "main", s[4:]) if s.startswith("EXT:") else os.path.join(D, "fixtures", s)
        def out_name(s):
            b = os.path.splitext(os.path.basename(s))[0]
            ext = {"doc": "odt", "docx": "odt", "odt": "odt", "sxw": "odt", "ods": "ods", "sxc": "ods", "odg": "odg", "sxd": "odg", "odp": "odp", "sxi": "odp"}[s.rsplit(".", 1)[1]]
            return ("pf13-" if s.startswith("page-fill-1_3/") else "") + b + "." + ext
        sources = sorted({e[0] for e in entries})
        res, threads = {}, []
        for i, mode in enumerate(self.fix_modes):
            def one(mode=mode, i=i):
                md = os.path.join(self.run, "fixtures", mode)
                out = os.path.join(md, "out")
                os.makedirs(out, exist_ok=True)
                missing = [s for s in sources if not os.path.isfile(src_path(s))]
                with open(os.path.join(md, "jobs.tsv"), "w") as f:
                    f.writelines("%s\t%s\n" % (os.path.abspath(src_path(s)), os.path.join(out, out_name(s))) for s in sources if s not in missing)
                open(os.path.join(md, "done.tsv"), "a").close()
                rc = run([os.path.join(D, "drive.sh"), mode, str(self.a.port + 20 + i), os.path.join(md, "jobs.tsv"), os.path.join(md, "done.tsv")])
                ok, fail = count_done(os.path.join(md, "done.tsv"))
                r = {"drive_rc": rc, "saved": ok, "failed": fail, "missing": missing, "checks": {}}
                prof, port = "gate_rt_%s_%s" % (self.a.tag, mode), self.a.port + 30 + i
                run([os.path.join(D, "start.sh"), prof, str(port)], os.path.join(md, "rt.log"))
                for s, ck in (e for e in entries if e[1] != "-"):
                    doc = os.path.join(out, out_name(s))
                    key = "%s|%s" % (os.path.basename(s), ck)
                    if not os.path.isfile(doc):
                        r["checks"][key] = {"error": "no saved copy"}; continue
                    p = subprocess.run([os.path.join(D, "runpy.sh"), os.path.join(D, "roundtrip.py"), str(port), doc, os.path.join(D, "fixtures", ck)], capture_output=True, text=True, timeout=600)
                    m = re.search(r"roundtrip: (\d+)/(\d+) match", p.stdout)
                    r["checks"][key] = {"mismatches": sorted(re.findall(r"^MISMATCH (\S+?):", p.stdout, re.M)), "match": int(m.group(1)) if m else None, "total": int(m.group(2)) if m else None}
                kill_office(prof)
                r["validate"] = self.validate_dir(md, out, None, mode)
                r["problems"] = self.shall_problems(r["validate"], self.prev_validate("fixtures", mode, "validate"))
                res[mode] = r
            t = threading.Thread(target=one); t.start(); threads.append(t)
        for t in threads:
            t.join()
        pf = self.prev_path("results.json")
        changed = []
        if pf:
            prev = json.load(open(pf)).get("fixtures", {})
            for mode in self.fix_modes:
                for k, c in res.get(mode, {}).get("checks", {}).items():
                    pc = prev.get(mode, {}).get("checks", {}).get(k)
                    if pc is not None and pc != c:
                        changed.append("%s %s" % (mode, k))
        res["changed_vs_prev"] = changed if pf else "no previous fixtures results"
        res["ok"] = all(res[m]["drive_rc"] == 0 and res[m]["failed"] == 0 and not res[m]["missing"] and
                        all("error" not in c and c["total"] for c in res[m]["checks"].values()) and not res[m]["problems"] for m in self.fix_modes) and not changed
        return res


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("tag")
    ap.add_argument("--stages", default="refresh,corpus,validate,dump,diff,fixtures")
    ap.add_argument("--modes", default="ext,strict")
    ap.add_argument("--fixture-modes", default=",".join(FIX_MODES))
    ap.add_argument("--prev")
    ap.add_argument("--jobs")
    ap.add_argument("--limit", type=int, default=0)
    ap.add_argument("--port", type=int, default=2013)
    ap.add_argument("--build", default="")
    ap.add_argument("--libs", default=DEFAULT_LIBS)
    ap.add_argument("--stall", type=int, default=300)
    ap.add_argument("--force", action="store_true")
    a = ap.parse_args()
    g = Gate(a)
    stages = [s for s in STAGES if s in a.stages.split(",") or (s == "build" and a.build)]
    failed = []
    for s in stages:
        if s in g.res and not a.force:
            print("%-9s already done (--force to rerun)" % s)
        else:
            t0 = time.time()
            g.res[s] = getattr(g, s)()
            g.res[s]["seconds"] = int(time.time() - t0)
            g.save()
        ok = g.res[s].get("ok", True)
        print("%-9s %s  %s" % (s, "PASS" if ok else "FAIL", json.dumps({k: v for k, v in g.res[s].items() if k != "ok"})[:300]))
        if not ok:
            failed.append(s)
    print("gate %s: %s" % (a.tag, "PASS" if not failed else "FAIL in " + ", ".join(failed)))
    sys.exit(1 if failed else 0)


if __name__ == "__main__":
    main()