package gudusoft.gsqlparser.pp.score;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.pp2.token.TokenEquivalence;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/**
 * PrettyScore: scores the readability of an <b>already formatted</b> SQL text
 * against a style {@link ScoreProfile} and explains every deduction.
 *
 * <pre>
 *   ScoreReport r = new PrettyScore().score(formattedSql, EDbVendor.dbvmssql, ScoreProfile.defaults(), originalSql, null);
 *   r.getScore();       // 0-100
 *   r.getAttainable();  // what the formatter could reach on this input
 *   r.getRatio();       // score / attainable — the closed-loop target
 *   r.toJson();         // published contract, version "prettyscore/0.1"
 * </pre>
 *
 * <p><b>Read this before quoting a number.</b> While the profile's
 * calibration is {@code heuristic-v0} the weights are engineering guesses:
 * the score is reliable only as a relative measure within one profile on one
 * corpus (before/after a formatter change). It is not an absolute readability
 * verdict and must not be presented as one. A script that never wraps (one
 * over-wide line holding most tokens) is charged on width, density and indent
 * even when local agreement would otherwise look perfect.
 *
 * <p>Syntax errors are fine: the lexical facts come from the pp2 pipeline,
 * which never needs a successful parse; only the AST depth is lost, in which
 * case the indent dimension's weight is halved and a note is attached.
 *
 * <p>Thread-safety: the only configuration is {@link #setAstEnabled}, read
 * once at the start of every {@code score} call; instances may be shared.
 */
public final class PrettyScore {

    private volatile boolean astEnabled = true;

    /**
     * Whether a second GSP parse is run to stamp AST depth (default true).
     * Disabling it makes scoring O(tokens) with no parser cost, at the price
     * of the indent dimension's weight being halved as if the text had not
     * parsed. Useful for very large scripts or pure lexical regression runs.
     */
    public PrettyScore setAstEnabled(boolean enabled) {
        this.astEnabled = enabled;
        return this;
    }

    public boolean isAstEnabled() {
        return astEnabled;
    }

    /** Score {@code sql} with the default profile and no fidelity gate. */
    public ScoreReport score(String sql, EDbVendor vendor) {
        return score(sql, vendor, ScoreProfile.defaults(), null, null);
    }

    /**
     * @param sql      the formatted SQL; must not be null
     * @param vendor   dialect; must not be null
     * @param profile  style profile; null selects {@code isf-default}
     * @param original the un-formatted input; when given the fidelity gate
     *                 (token / comment / AST preservation) and the comments
     *                 dimension are evaluated
     * @param options  the formatter options the caller claims produced
     *                 {@code sql} ({@code GFmtOpt} field names); when given,
     *                 contradictions surface as {@code OPTION_NOT_HONORED}
     */
    public ScoreReport score(String sql, EDbVendor vendor, ScoreProfile profile, String original,
                             Map<String, Object> options) {
        if (sql == null) throw new NullPointerException("sql");
        if (vendor == null) throw new NullPointerException("vendor");
        if (profile == null) profile = ScoreProfile.defaults();
        final boolean ast = astEnabled; // snapshot: a concurrent setter cannot split one scoring run

        FactsBuilder builder = new FactsBuilder(profile);
        Facts facts = builder.build(sql, vendor, ast);
        Facts origFacts = original == null ? null : builder.build(original, vendor, false);
        Geometry geo = new Geometry(facts, profile);
        RuleContext ctx = new RuleContext(facts, profile, geo, origFacts, options);

        List<Rule> rules = Arrays.<Rule>asList(new SpineRule(), new IndentRule(), new WidthRule(), new DensityRule(),
            new AlignmentRule(), new ConsistencyRule(), new GroupingRule(), new CommentRule(), new OptionRule());
        for (Rule r : rules) {
            r.apply(ctx);
        }
        Explainer.depthMetrics(facts, ctx.metrics);

        // ---- gate
        List<ScoreReport.GateCheck> checks = new ArrayList<ScoreReport.GateCheck>();
        boolean gateEvaluated = original != null;
        boolean gatePassed = true;
        if (gateEvaluated) {
            boolean tokens = TokenEquivalence.equalsModuloFormatting(original, sql, null, vendor, true);
            checks.add(new ScoreReport.GateCheck("TOKEN_PRESERVED", tokens,
                tokens ? "" : "solid token sequence differs from the original", null));
            Map<String, Object> extra = new LinkedHashMap<String, Object>();
            extra.put("input", origFacts.getCommentCount());
            extra.put("output", facts.getCommentCount());
            boolean comments = origFacts.getCommentCount() == facts.getCommentCount();
            checks.add(new ScoreReport.GateCheck("COMMENTS_PRESERVED", comments,
                comments ? "" : "comment count changed", extra));
            if (tokens) {
                int recased = recasedIdentifiers(origFacts, facts);
                Map<String, Object> idExtra = new LinkedHashMap<String, Object>();
                idExtra.put("changed", recased);
                boolean idOk = recased == 0 || !profile.isStrictIdentifierCase();
                checks.add(new ScoreReport.GateCheck("IDENTIFIER_CASE", idOk,
                    recased == 0 ? "" : recased + " unquoted identifier(s) recased" + (idOk ? " (informational; profile.strictIdentifierCase=false)" : ""), idExtra));
            }
            if (ast) {
                String astDetail = astEquivalent(original, sql, vendor);
                if (astDetail != null) {
                    checks.add(new ScoreReport.GateCheck("AST_EQUIVALENT", astDetail.isEmpty(), astDetail, null));
                }
            } else {
                checks.add(new ScoreReport.GateCheck("AST_EQUIVALENT", true, "not evaluated (ast disabled)", null));
            }
            for (ScoreReport.GateCheck c : checks) if (!c.isOk()) gatePassed = false;
        }
        Map<String, Object> parseExtra = new LinkedHashMap<String, Object>();
        parseExtra.put("parse_ok", facts.isParseOk());
        parseExtra.put("error_regions", facts.getErrorRegions());
        parseExtra.put("unclosed_blocks", facts.getUnclosedBlocks());
        checks.add(new ScoreReport.GateCheck("PARSE_STATUS", true,
            facts.isParseOk() ? "parsed" : "not parsed; pp2-tolerant facts only", parseExtra));

        Explainer.Result agg = Explainer.aggregate(ctx.findings, profile, facts, gatePassed, ctx.metrics);

        ctx.metrics.put("statements", facts.getStatementCount());
        ctx.metrics.put("comments", facts.getCommentCount());
        if (!ast) ctx.notes.add("ast disabled by caller: parse status not evaluated, indent weight halved");
        ScoreReport.ParseInfo parse = new ScoreReport.ParseInfo(ast, facts.isParseOk(),
            !ast ? "pp2-lexical (ast disabled)" : facts.isParseOk() ? "gsp-parse+pp2" : "pp2-tolerant",
            facts.getErrorRegions(), facts.isParseOk() ? facts.getParserStatementCount() : facts.getStatementCount(),
            facts.isAstAvailable());
        return new ScoreReport(profile.getName(), profile.getCalibration(), vendor.name(), parse,
            gateEvaluated, gatePassed, checks, agg.score, agg.attainable, agg.unfixableImpact,
            agg.dimensions, agg.findings, agg.improvements, ctx.metrics, ctx.notes);
    }

    /** The formatter option / renderer component a rule id maps to (see the improvement list). */
    public static String targetFor(String rule) {
        return OptionAdvisor.target(rule);
    }

    /**
     * Number of unquoted identifier tokens whose text differs only by case
     * between the two token sequences (which the TOKEN_PRESERVED check has
     * already found equal modulo case).
     */
    static int recasedIdentifiers(Facts a, Facts b) {
        int n = 0;
        int i = 0, j = 0;
        while (i < a.tokenCount() && j < b.tokenCount()) {
            TokenFacts x = a.token(i);
            TokenFacts y = b.token(j);
            if (x.isComment()) { i++; continue; }
            if (y.isComment()) { j++; continue; }
            boolean identifierLike = x.getType() == gudusoft.gsqlparser.ETokenType.ttidentifier
                || x.getType() == gudusoft.gsqlparser.ETokenType.ttnonreservedkeyword
                || (x.getType() == gudusoft.gsqlparser.ETokenType.ttkeyword && !RuleSupport.isStructuralKeyword(a, x));
            if (identifierLike && !x.getText().equals(y.getText()) && x.getUpper().equals(y.getUpper())) {
                n++;
            }
            i++;
            j++;
        }
        return n;
    }

    /**
     * Compare the two parses structurally: statement count and statement types.
     * Returns null when either side does not parse (check not applicable),
     * "" when equivalent, otherwise a description of the difference.
     */
    static String astEquivalent(String original, String formatted, EDbVendor vendor) {
        TGSqlParser a = new TGSqlParser(vendor);
        a.sqltext = original;
        TGSqlParser b = new TGSqlParser(vendor);
        b.sqltext = formatted;
        int ra, rb;
        try {
            ra = a.parse();
            rb = b.parse();
        } catch (Throwable t) {
            return null;
        }
        if (ra != 0 && rb != 0) return null;
        if (ra != 0 || rb != 0) {
            return String.format(Locale.ROOT, "original %s, formatted %s", ra == 0 ? "parses" : "fails to parse", rb == 0 ? "parses" : "fails to parse");
        }
        int na = a.sqlstatements.size(), nb = b.sqlstatements.size();
        if (na != nb) return "statement count " + na + " vs " + nb;
        for (int i = 0; i < na; i++) {
            TCustomSqlStatement sa = a.sqlstatements.get(i);
            TCustomSqlStatement sb = b.sqlstatements.get(i);
            if (sa.sqlstatementtype != sb.sqlstatementtype) {
                return "statement " + (i + 1) + " type " + sa.sqlstatementtype + " vs " + sb.sqlstatementtype;
            }
            int ta = sa.tables == null ? 0 : sa.tables.size();
            int tb = sb.tables == null ? 0 : sb.tables.size();
            if (ta != tb) return "statement " + (i + 1) + " table count " + ta + " vs " + tb;
        }
        return "";
    }
}