package gudusoft.gsqlparser.demos.prettyscore;

import gudusoft.gsqlparser.pp.score.PrettyScore;
import gudusoft.gsqlparser.pp.score.json.JsonIn;

import java.io.File;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;

/**
 * Operations over saved run records: finding-level diff between two runs,
 * baseline regression check, corpus backlog (Markdown) and blind A/B
 * acceptance samples. All keyed on {@code file|engine|source} and the
 * position-independent finding fingerprint so a reformat does not break the
 * alignment.
 */
public final class RunTools {

    private RunTools() {
    }

    @SuppressWarnings("unchecked")
    public static Map<String, Object> loadRun(File f) throws IOException {
        return JsonIn.parseObject(new String(Files.readAllBytes(f.toPath()), Charset.forName("UTF-8")));
    }

    @SuppressWarnings("unchecked")
    static List<Map<String, Object>> entries(Map<String, Object> run) {
        List<Map<String, Object>> out = new ArrayList<Map<String, Object>>();
        for (Object o : JsonIn.arr(run, "entries")) out.add((Map<String, Object>) o);
        return out;
    }

    static String key(Map<String, Object> e) {
        return e.get("file") + "|" + e.get("engine") + "|" + e.get("source");
    }

    /** Fixable, counted findings of an entry as {@code fingerprint -> finding}. */
    @SuppressWarnings("unchecked")
    static Map<String, Map<String, Object>> fingerprints(Map<String, Object> e) {
        Map<String, Map<String, Object>> out = new LinkedHashMap<String, Map<String, Object>>();
        for (Object o : JsonIn.arr(e, "findings")) {
            Map<String, Object> f = (Map<String, Object>) o;
            if (!Boolean.TRUE.equals(f.get("fixable"))) continue;
            String fp = String.valueOf(f.get("fingerprint"));
            // several findings can share a fingerprint (e.g. two overflow lines in one predicate); suffix them
            String k = fp;
            int n = 2;
            while (out.containsKey(k)) k = fp + "#" + (n++);
            out.put(k, f);
        }
        return out;
    }

    /** Result of {@link #diffRuns}. */
    public static final class Diff {
        public final List<String> fixed = new ArrayList<String>();
        public final List<String> added = new ArrayList<String>();
        public final List<String> persisting = new ArrayList<String>();
        /** Entries present in A but errored or absent in B: their findings are neither fixed nor persisting. */
        public final List<String> unavailable = new ArrayList<String>();
        public int newMajor;
        public final StringBuilder text = new StringBuilder();
    }

    public static Diff diffRuns(Map<String, Object> a, Map<String, Object> b) {
        Diff d = new Diff();
        Map<String, Map<String, Object>> ea = new LinkedHashMap<String, Map<String, Object>>();
        for (Map<String, Object> e : entries(a)) ea.put(key(e), e);
        Map<String, Map<String, Object>> eb = new LinkedHashMap<String, Map<String, Object>>();
        for (Map<String, Object> e : entries(b)) eb.put(key(e), e);
        Set<String> keys = new LinkedHashSet<String>(ea.keySet());
        keys.addAll(eb.keySet());
        for (String k : keys) {
            Map<String, Object> ebk = eb.get(k);
            if (ebk == null || ebk.containsKey("error")) {
                d.unavailable.add(k + (ebk == null ? " (missing in B)" : " (B error: " + ebk.get("error") + ")"));
                continue;
            }
            Map<String, Map<String, Object>> fa = ea.containsKey(k) ? fingerprints(ea.get(k)) : new LinkedHashMap<String, Map<String, Object>>();
            Map<String, Map<String, Object>> fb = fingerprints(ebk);
            for (String fp : fa.keySet()) {
                if (fb.containsKey(fp)) d.persisting.add(k + " " + fp);
                else d.fixed.add(k + " " + fp);
            }
            for (Map.Entry<String, Map<String, Object>> e : fb.entrySet()) {
                if (fa.containsKey(e.getKey())) continue;
                String sev = String.valueOf(e.getValue().get("severity"));
                d.added.add(k + " " + e.getKey() + " [" + sev + "] " + e.getValue().get("evidence"));
                if ("major".equals(sev) || "bug".equals(sev)) d.newMajor++;
            }
        }
        d.text.append(String.format(Locale.ROOT, "fixed %d, new %d (%d major/bug), persisting %d, unavailable %d%n",
            d.fixed.size(), d.added.size(), d.newMajor, d.persisting.size(), d.unavailable.size()));
        summaryLine(d.text, "A", a);
        summaryLine(d.text, "B", b);
        if (!d.fixed.isEmpty()) { d.text.append("FIXED:\n"); for (String s : d.fixed) d.text.append("  ").append(s).append('\n'); }
        if (!d.added.isEmpty()) { d.text.append("NEW:\n"); for (String s : d.added) d.text.append("  ").append(s).append('\n'); }
        if (!d.unavailable.isEmpty()) { d.text.append("UNAVAILABLE:\n"); for (String s : d.unavailable) d.text.append("  ").append(s).append('\n'); }
        if (!d.persisting.isEmpty()) { d.text.append("PERSISTING:\n"); for (String s : d.persisting) d.text.append("  ").append(s).append('\n'); }
        return d;
    }

    @SuppressWarnings("unchecked")
    static void summaryLine(StringBuilder sb, String label, Map<String, Object> run) {
        Map<String, Object> summary = JsonIn.obj(run, "summary");
        sb.append(label).append(": ");
        for (Map.Entry<String, Object> e : summary.entrySet()) {
            Map<String, Object> s = (Map<String, Object>) e.getValue();
            if (s.containsKey("mean_ratio")) {
                sb.append(String.format(Locale.ROOT, "%s mean_ratio=%.3f min=%.3f gate_fail=%s; ", e.getKey(),
                    JsonIn.dbl(s, "mean_ratio", 0), JsonIn.dbl(s, "min_ratio", 0), s.get("gate_failures")));
            } else if (s.containsKey("pp2_recovery_ratio")) {
                sb.append(String.format(Locale.ROOT, "degraded pp2_recovery_ratio=%.3f; ", JsonIn.dbl(s, "pp2_recovery_ratio", 0)));
            }
        }
        sb.append('\n');
    }

    /** Baseline check: mean ratio must not drop by more than {@code maxDrop}; no new gate failures. Returns problems (empty = ok). */
    @SuppressWarnings("unchecked")
    public static List<String> checkBaseline(Map<String, Object> baseline, Map<String, Object> current, double maxDrop) {
        List<String> problems = new ArrayList<String>();
        for (String k : new String[]{"version", "vendor", "profile", "calibration", "seed", "degraded_samples", "engines", "ast"}) {
            Object b = baseline.get(k), c = current.get(k);
            if (b == null || c == null || !String.valueOf(b).equals(String.valueOf(c))) {
                problems.add("run identity differs on " + k + ": baseline " + b + ", current " + c);
            }
        }
        if (!problems.isEmpty()) return problems; // incomparable runs: do not read scores into it
        Map<String, Object> sb = JsonIn.obj(baseline, "summary");
        Map<String, Object> sc = JsonIn.obj(current, "summary");
        for (Map.Entry<String, Object> e : sb.entrySet()) {
            Map<String, Object> b = (Map<String, Object>) e.getValue();
            Map<String, Object> c = (Map<String, Object>) sc.get(e.getKey());
            if (c == null) { problems.add("engine " + e.getKey() + " missing from current run"); continue; }
            String ratioKey = b.containsKey("mean_ratio") ? "mean_ratio" : "pp2_recovery_ratio";
            double rb = JsonIn.dbl(b, ratioKey, 0), rc = JsonIn.dbl(c, ratioKey, 0);
            if (rb - rc > maxDrop) {
                problems.add(String.format(Locale.ROOT, "%s %s dropped %.3f -> %.3f (max drop %.3f)", e.getKey(), ratioKey, rb, rc, maxDrop));
            }
        }
        Map<String, Map<String, Object>> eb = new LinkedHashMap<String, Map<String, Object>>();
        for (Map<String, Object> e : entries(baseline)) eb.put(key(e), e);
        Set<String> currentKeys = new LinkedHashSet<String>();
        for (Map<String, Object> e : entries(current)) currentKeys.add(key(e));
        for (String k : eb.keySet()) {
            if (!currentKeys.contains(k)) problems.add("entry missing from current run: " + k);
        }
        for (Map<String, Object> e : entries(current)) {
            Map<String, Object> b = eb.get(key(e));
            if (b == null) {
                if (e.containsKey("error")) problems.add("new error: " + key(e) + " " + e.get("error"));
                else problems.add("entry not in baseline: " + key(e));
                continue;
            }
            if (Boolean.TRUE.equals(b.get("gate_passed")) && e.containsKey("gate_passed") && !Boolean.TRUE.equals(e.get("gate_passed"))) {
                problems.add("new gate failure: " + key(e));
            }
            if (!b.containsKey("error") && e.containsKey("error")) {
                problems.add("new error: " + key(e) + " " + e.get("error"));
            }
        }
        return problems;
    }

    /** Corpus-level improvement backlog as Markdown, aggregated by rule over fixable findings. */
    @SuppressWarnings("unchecked")
    public static String backlog(Map<String, Object> run, String engineFilter) {
        Map<String, List<Object[]>> byRule = new TreeMap<String, List<Object[]>>(); // rule -> [{gain, file, line, evidence}]
        Map<String, Set<String>> filesHit = new TreeMap<String, Set<String>>();
        int files = 0;
        for (Map<String, Object> e : entries(run)) {
            if (!"clean".equals(e.get("source")) || e.containsKey("error")) continue;
            if (engineFilter != null && !engineFilter.equals(e.get("engine"))) continue;
            files++;
            double attainable = JsonIn.dbl(e, "attainable", 100.0);
            if (attainable <= 0) attainable = 100.0;
            for (Object o : JsonIn.arr(e, "findings")) {
                Map<String, Object> f = (Map<String, Object>) o;
                if (!Boolean.TRUE.equals(f.get("fixable"))) continue;
                String rule = String.valueOf(f.get("rule"));
                List<Object[]> l = byRule.get(rule);
                if (l == null) { l = new ArrayList<Object[]>(); byRule.put(rule, l); filesHit.put(rule, new LinkedHashSet<String>()); }
                // gain in ratio points (score points / the entry's attainable), the quantity the loop tracks
                l.add(new Object[]{JsonIn.dbl(f, "gain", 0) / attainable, e.get("file"), f.get("line"), f.get("evidence")});
                filesHit.get(rule).add(key(e));
            }
        }
        List<Map.Entry<String, List<Object[]>>> rows = new ArrayList<Map.Entry<String, List<Object[]>>>(byRule.entrySet());
        final Map<String, Double> totals = new LinkedHashMap<String, Double>();
        for (Map.Entry<String, List<Object[]>> r : rows) {
            double t = 0;
            for (Object[] x : r.getValue()) t += (Double) x[0];
            totals.put(r.getKey(), t);
        }
        Collections.sort(rows, new Comparator<Map.Entry<String, List<Object[]>>>() {
            @Override
            public int compare(Map.Entry<String, List<Object[]>> a, Map.Entry<String, List<Object[]>> b) {
                return Double.compare(totals.get(b.getKey()), totals.get(a.getKey()));
            }
        });
        StringBuilder sb = new StringBuilder();
        sb.append("# PrettyScore backlog — ").append(run.get("vendor")).append(" / ").append(run.get("profile"))
            .append(engineFilter == null ? "" : " / " + engineFilter).append(" (").append(run.get("calibration")).append(")\n\n");
        sb.append("Entries (file x engine): ").append(files).append(". Rows sorted by estimated corpus gain; unfixable findings excluded.\n\n");
        sb.append("| rank | rule | files_hit / total | total_ratio_gain | est_gain (mean ratio/entry) | target | examples |\n");
        sb.append("|---|---|---|---|---|---|---|\n");
        int rank = 1;
        for (Map.Entry<String, List<Object[]>> r : rows) {
            List<Object[]> l = r.getValue();
            Collections.sort(l, new Comparator<Object[]>() {
                @Override public int compare(Object[] a, Object[] b) { return Double.compare((Double) b[0], (Double) a[0]); }
            });
            double total = totals.get(r.getKey());
            String ex = example(l.get(0)) + "<br>" + example(l.get(l.size() / 2)) + "<br>" + example(l.get(l.size() - 1));
            sb.append(String.format(Locale.ROOT, "| %d | %s | %d / %d | %.3f | %.4f | %s | %s |%n", rank++, r.getKey(),
                filesHit.get(r.getKey()).size(), files, total, files == 0 ? 0 : total / files,
                PrettyScore.targetFor(r.getKey()).replace("|", "/"), ex.replace("|", "/")));
        }
        return sb.toString();
    }

    private static String example(Object[] x) {
        String ev = String.valueOf(x[3]);
        if (ev.length() > 80) ev = ev.substring(0, 77) + "...";
        return "`" + x[1] + ":" + x[2] + "` " + ev.replace("`", "'");
    }

    /**
     * Write {@code n} anonymised A/B pairs from two runs that kept their
     * formatted text: {@code NN-left.sql} / {@code NN-right.sql} with random
     * side assignment, plus {@code key.csv} (which side is run B) for the
     * person tallying the votes.
     */
    public static int acceptanceSample(Map<String, Object> a, Map<String, Object> b, int n, long seed, File outDir) throws IOException {
        Map<String, Map<String, Object>> eb = new LinkedHashMap<String, Map<String, Object>>();
        for (Map<String, Object> e : entries(b)) eb.put(key(e), e);
        List<String[]> candidates = new ArrayList<String[]>();
        for (Map<String, Object> e : entries(a)) {
            Map<String, Object> other = eb.get(key(e));
            if (other == null) continue;
            String ta = JsonIn.str(e, "formatted", null);
            String tb = JsonIn.str(other, "formatted", null);
            if (ta == null || tb == null || ta.equals(tb)) continue;
            candidates.add(new String[]{key(e), ta, tb});
        }
        if (candidates.isEmpty()) return 0;
        Random rnd = new Random(seed);
        Collections.shuffle(candidates, rnd);
        if (!outDir.isDirectory() && !outDir.mkdirs()) throw new IOException("cannot create " + outDir);
        StringBuilder keyCsv = new StringBuilder("pair,source,after_side\n");
        int written = 0;
        for (int i = 0; i < candidates.size() && i < n; i++) {
            String[] c = candidates.get(i);
            boolean afterLeft = rnd.nextBoolean();
            String id = String.format(Locale.ROOT, "%02d", i + 1);
            Files.write(new File(outDir, id + "-left.sql").toPath(), (afterLeft ? c[2] : c[1]).getBytes(Charset.forName("UTF-8")));
            Files.write(new File(outDir, id + "-right.sql").toPath(), (afterLeft ? c[1] : c[2]).getBytes(Charset.forName("UTF-8")));
            keyCsv.append(id).append(',').append(c[0].replace(',', ';')).append(',').append(afterLeft ? "left" : "right").append('\n');
            written++;
        }
        Files.write(new File(outDir, "key.csv").toPath(), keyCsv.toString().getBytes(Charset.forName("UTF-8")));
        return written;
    }
}