package gudusoft.gsqlparser.pp.score;

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

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;

/**
 * A style profile: the target layout the scorer measures against.
 *
 * <p>"Better" depends on the intended style (river-aligned Celko layout vs the
 * compact sqlfmt look vs the ISF default), so every threshold, weight, target
 * width and alignment expectation lives in a JSON resource under
 * {@code /gudusoft/gsqlparser/pp/score/profiles/} and nothing numeric is
 * hard-coded in the rules. Three profiles ship: {@code isf-default},
 * {@code river}, {@code compact}. A user profile file may set
 * {@code "extends": "isf-default"} to inherit everything it does not override.
 *
 * <p>Scores are only comparable within one profile and one corpus while the
 * profile's {@link #getCalibration() calibration} is {@code heuristic-v0}.
 */
public final class ScoreProfile {

    /** Where the built-in profiles live on the classpath. */
    public static final String RESOURCE_DIR = "/gudusoft/gsqlparser/pp/score/profiles/";

    public static final String ISF_DEFAULT = "isf-default";
    public static final String RIVER = "river";
    public static final String COMPACT = "compact";

    public enum ClauseAlign { LEFT, RIVER }
    public enum JoinOnIndent { SAME, NESTED, RIVER }
    /** Where JOIN clause keywords sit: on the clause spine, or at the block's content column (ISF style). */
    public enum JoinIndent { SPINE, CONTENT }

    private final String name;
    private final String calibration;
    private final String description;
    private final int targetWidth;
    private final int indentUnit;          // 0 = auto-detect
    private final int indentUnitFallback;
    private final int tabSize;
    private final ClauseAlign clauseAlign;
    private final boolean andOrLineStart;
    private final JoinOnIndent joinOnIndent;
    private final JoinIndent joinIndent;
    private final boolean joinOnNewLine;
    private final boolean aliasAlign;
    private final boolean blankBetweenStatements;
    private final boolean errorRegionPreserve;
    private final boolean strictIdentifierCase;
    private final int inlineListMaxItems;
    private final int inlineListMaxLen;
    private final int inlineBlockMaxLen;
    private final Map<String, Double> weights;
    private final Map<String, Double> thresholds;

    private ScoreProfile(Map<String, Object> m) {
        this.name = JsonIn.str(m, "name", "custom");
        this.calibration = JsonIn.str(m, "calibration", "heuristic-v0");
        this.description = JsonIn.str(m, "description", "");
        this.targetWidth = JsonIn.integer(m, "targetWidth", 100);
        this.indentUnit = JsonIn.integer(m, "indentUnit", 0);
        this.indentUnitFallback = JsonIn.integer(m, "indentUnitFallback", 2);
        this.tabSize = JsonIn.integer(m, "tabSize", 4);
        this.clauseAlign = ClauseAlign.valueOf(JsonIn.str(m, "clauseAlign", "left").toUpperCase(Locale.ROOT));
        this.andOrLineStart = JsonIn.bool(m, "andOrLineStart", true);
        this.joinOnIndent = JoinOnIndent.valueOf(JsonIn.str(m, "joinOnIndent", "same").toUpperCase(Locale.ROOT));
        this.joinIndent = JoinIndent.valueOf(JsonIn.str(m, "joinIndent", "content").toUpperCase(Locale.ROOT));
        this.joinOnNewLine = JsonIn.bool(m, "joinOnNewLine", true);
        this.aliasAlign = JsonIn.bool(m, "aliasAlign", false);
        this.blankBetweenStatements = JsonIn.bool(m, "blankBetweenStatements", false);
        this.errorRegionPreserve = JsonIn.bool(m, "errorRegionPreserve", true);
        this.strictIdentifierCase = JsonIn.bool(m, "strictIdentifierCase", false);
        this.inlineListMaxItems = JsonIn.integer(m, "inlineListMaxItems", 3);
        this.inlineListMaxLen = JsonIn.integer(m, "inlineListMaxLen", 60);
        this.inlineBlockMaxLen = JsonIn.integer(m, "inlineBlockMaxLen", 60);
        Map<String, Double> w = new LinkedHashMap<String, Double>();
        for (Map.Entry<String, Object> e : JsonIn.obj(m, "weights").entrySet()) {
            if (e.getValue() instanceof Number) w.put(e.getKey(), ((Number) e.getValue()).doubleValue());
        }
        this.weights = Collections.unmodifiableMap(w);
        Map<String, Double> t = new LinkedHashMap<String, Double>();
        for (Map.Entry<String, Object> e : JsonIn.obj(m, "thresholds").entrySet()) {
            if (e.getValue() instanceof Number) t.put(e.getKey(), ((Number) e.getValue()).doubleValue());
        }
        this.thresholds = Collections.unmodifiableMap(t);
    }

    // ---- loading --------------------------------------------------------

    /** Load a built-in profile by name ({@code isf-default}, {@code river}, {@code compact}). */
    public static ScoreProfile builtin(String name) {
        if (name == null) throw new NullPointerException("name");
        String text = readResource(RESOURCE_DIR + name + ".json");
        if (text == null) {
            throw new IllegalArgumentException("Unknown built-in profile: " + name);
        }
        return fromJson(text);
    }

    /** The default profile ({@code isf-default}). */
    public static ScoreProfile defaults() {
        return builtin(ISF_DEFAULT);
    }

    /**
     * Resolve a profile from a built-in name or a file path. A path is
     * recognised by existing on disk or ending in {@code .json}.
     */
    public static ScoreProfile load(String nameOrPath) throws IOException {
        if (nameOrPath == null || nameOrPath.isEmpty()) return defaults();
        File f = new File(nameOrPath);
        if (f.isFile()) {
            return fromJson(readFile(f));
        }
        if (nameOrPath.endsWith(".json")) {
            throw new IOException("Profile file not found: " + nameOrPath);
        }
        return builtin(nameOrPath);
    }

    /** Parse a profile from JSON text, honouring {@code "extends"}. */
    public static ScoreProfile fromJson(String json) {
        Map<String, Object> m = JsonIn.parseObject(json);
        Object base = m.get("extends");
        if (base != null) {
            String baseText = readResource(RESOURCE_DIR + base + ".json");
            if (baseText == null) {
                throw new IllegalArgumentException("Profile extends unknown base: " + base);
            }
            Map<String, Object> merged = JsonIn.parseObject(baseText);
            deepMerge(merged, m);
            merged.remove("extends");
            m = merged;
        }
        return new ScoreProfile(m);
    }

    @SuppressWarnings("unchecked")
    private static void deepMerge(Map<String, Object> into, Map<String, Object> from) {
        for (Map.Entry<String, Object> e : from.entrySet()) {
            Object existing = into.get(e.getKey());
            if (existing instanceof Map && e.getValue() instanceof Map) {
                deepMerge((Map<String, Object>) existing, (Map<String, Object>) e.getValue());
            } else {
                into.put(e.getKey(), e.getValue());
            }
        }
    }

    private static String readResource(String path) {
        InputStream in = ScoreProfile.class.getResourceAsStream(path);
        if (in == null) return null;
        try {
            return readAll(in);
        } catch (IOException e) {
            return null;
        }
    }

    private static String readFile(File f) throws IOException {
        InputStream in = new FileInputStream(f);
        try {
            return readAll(in);
        } finally {
            in.close();
        }
    }

    private static String readAll(InputStream in) throws IOException {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] buf = new byte[8192];
            int n;
            while ((n = in.read(buf)) > 0) bos.write(buf, 0, n);
            return new String(bos.toByteArray(), Charset.forName("UTF-8"));
        } finally {
            in.close();
        }
    }

    // ---- accessors ------------------------------------------------------

    public String getName() { return name; }
    /** {@code heuristic-v0} until pairwise human votes re-fit the weights ({@code bt-v1}). */
    public String getCalibration() { return calibration; }
    public String getDescription() { return description; }
    /** W: target line width. */
    public int getTargetWidth() { return targetWidth; }
    /** U: indent unit; {@code 0} means auto-detect from the output. */
    public int getIndentUnit() { return indentUnit; }
    public int getIndentUnitFallback() { return indentUnitFallback; }
    public int getTabSize() { return tabSize; }
    public ClauseAlign getClauseAlign() { return clauseAlign; }
    /** True: AND/OR start their line; false: AND/OR end the previous line. */
    public boolean isAndOrLineStart() { return andOrLineStart; }
    public JoinOnIndent getJoinOnIndent() { return joinOnIndent; }
    public JoinIndent getJoinIndent() { return joinIndent; }
    public boolean isJoinOnNewLine() { return joinOnNewLine; }
    public boolean isAliasAlign() { return aliasAlign; }
    public boolean isBlankBetweenStatements() { return blankBetweenStatements; }
    public boolean isErrorRegionPreserve() { return errorRegionPreserve; }
    /**
     * When true, an unquoted identifier whose case changed between original and
     * formatted text fails the {@code IDENTIFIER_CASE} gate check (relevant for
     * case-sensitive object names, e.g. MySQL with lower_case_table_names=0).
     * Off by default because formatters recase identifiers on purpose
     * ({@code GFmtOpt.caseIdentifier}, function names); the count is always reported.
     */
    public boolean isStrictIdentifierCase() { return strictIdentifierCase; }
    public int getInlineListMaxItems() { return inlineListMaxItems; }
    public int getInlineListMaxLen() { return inlineListMaxLen; }
    public int getInlineBlockMaxLen() { return inlineBlockMaxLen; }

    /** Dimension id to weight, as declared (before any automatic adjustment). */
    public Map<String, Double> getWeights() { return weights; }

    public double weight(String dimension) {
        Double w = weights.get(dimension);
        return w == null ? 0.0 : w.doubleValue();
    }

    /** All rule thresholds ({@code RULE.param} keys). */
    public Map<String, Double> getThresholds() { return thresholds; }

    /**
     * A rule threshold. Every number a rule uses comes from here; a missing key
     * is a profile authoring error and fails loudly rather than silently using
     * a hidden default.
     */
    public double thr(String key) {
        Double v = thresholds.get(key);
        if (v == null) {
            throw new IllegalStateException("Profile '" + name + "' has no threshold '" + key + "'");
        }
        return v.doubleValue();
    }

    /** Whether the profile defines a threshold. */
    public boolean hasThr(String key) {
        return thresholds.containsKey(key);
    }

    @Override
    public String toString() {
        return "ScoreProfile[" + name + " W=" + targetWidth + " U=" + (indentUnit == 0 ? "auto" : String.valueOf(indentUnit))
            + " " + clauseAlign + "]";
    }
}