package gudusoft.gsqlparser.demos.prettyscore;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;

import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
import java.util.Random;

/**
 * Derives syntax-broken samples from a clean SQL text with a fixed seed so a
 * corpus of "real-looking" parse failures can be regenerated in CI without
 * checking the derived files in. Three degradations, applied in rotation:
 *
 * <ul>
 *   <li>{@link Kind#TRUNCATE} — drop the trailing 10-40% of the tokens at a token boundary.</li>
 *   <li>{@link Kind#DROP_PAREN} — remove one random {@code (} or {@code )}.</li>
 *   <li>{@link Kind#INSERT_KEYWORD} — insert {@code FOOBAR} before a random clause keyword.</li>
 * </ul>
 *
 * <p>These samples are meant for the pp2 (tolerant) engine; pp is expected
 * to reject them.
 */
public final class SyntaxDegrader {

    public enum Kind { TRUNCATE, DROP_PAREN, INSERT_KEYWORD }

    /** A derived sample. */
    public static final class Sample {
        public final Kind kind;
        public final String sql;
        public final String description;
        /** True when the degraded text still parses (a FOOBAR alias, a cut before an optional clause); excluded from recovery corpora. */
        public final boolean stillParses;
        Sample(Kind kind, String sql, String description) { this(kind, sql, description, false); }
        Sample(Kind kind, String sql, String description, boolean stillParses) { this.kind = kind; this.sql = sql; this.description = description; this.stillParses = stillParses; }
    }

    private SyntaxDegrader() {
    }

    /**
     * Degrade {@code sql} with the {@code index}-th kind (rotating) and a seed derived from {@code seed} and
     * {@code index}, verifying that the result no longer parses; up to five re-seeded attempts rotate through
     * the kinds, and a sample that still parses after that is returned flagged {@link Sample#stillParses}.
     */
    public static Sample degrade(String sql, EDbVendor vendor, long seed, int index) {
        Sample last = null;
        for (int attempt = 0; attempt < 5; attempt++) {
            Kind kind = Kind.values()[Math.abs(index + attempt) % Kind.values().length];
            Sample s = degrade(sql, vendor, seed * 31 + index + 1000L * attempt, kind);
            if (!parses(s.sql, vendor)) return s;
            last = s;
        }
        return new Sample(last.kind, last.sql, last.description + " (still parses)", true);
    }

    static boolean parses(String sql, EDbVendor vendor) {
        try {
            gudusoft.gsqlparser.TGSqlParser p = new gudusoft.gsqlparser.TGSqlParser(vendor);
            p.sqltext = sql;
            return p.parse() == 0;
        } catch (Throwable t) {
            return false;
        }
    }

    public static Sample degrade(String sql, EDbVendor vendor, long seed, Kind kind) {
        Random rnd = new Random(seed);
        List<TSourceToken> toks = LayoutDegrader.solidAndCommentTokens(sql, vendor);
        if (toks.size() < 4) return new Sample(kind, sql, "too short to degrade");
        switch (kind) {
            case TRUNCATE: {
                int keep = (int) Math.max(2, toks.size() * (0.6 + 0.3 * rnd.nextDouble()));
                TSourceToken last = toks.get(keep - 1);
                int cut = (int) (last.offset + last.toString().length());
                return new Sample(kind, sql.substring(0, Math.min(cut, sql.length())), "truncated after token " + keep + " of " + toks.size());
            }
            case DROP_PAREN: {
                List<TSourceToken> parens = new ArrayList<TSourceToken>();
                for (TSourceToken t : toks) {
                    if (t.tokentype == ETokenType.ttleftparenthesis || t.tokentype == ETokenType.ttrightparenthesis) parens.add(t);
                }
                if (parens.isEmpty()) return degrade(sql, vendor, seed, Kind.TRUNCATE);
                TSourceToken victim = parens.get(rnd.nextInt(parens.size()));
                int at = (int) victim.offset;
                return new Sample(kind, sql.substring(0, at) + sql.substring(at + 1), "dropped '" + victim + "' at offset " + at);
            }
            case INSERT_KEYWORD:
            default: {
                List<TSourceToken> heads = new ArrayList<TSourceToken>();
                for (TSourceToken t : toks) {
                    if (t.tokentype != ETokenType.ttkeyword) continue;
                    String u = t.toString().toUpperCase(Locale.ROOT);
                    if (u.equals("FROM") || u.equals("WHERE") || u.equals("GROUP") || u.equals("ORDER") || u.equals("JOIN")
                        || u.equals("HAVING") || u.equals("SET") || u.equals("VALUES")) heads.add(t);
                }
                if (heads.isEmpty()) return degrade(sql, vendor, seed, Kind.TRUNCATE);
                TSourceToken at = heads.get(rnd.nextInt(heads.size()));
                int off = (int) at.offset;
                return new Sample(kind, sql.substring(0, off) + "FOOBAR " + sql.substring(off), "inserted FOOBAR before " + at + " at offset " + off);
            }
        }
    }
}