package gudusoft.gsqlparser.demos.sqlguard;

import gudusoft.gsqlparser.util.json.JSON;

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

/** Response POJO and nested contract types for SQL Guard. */
public class SqlGuardResponse {
    public boolean ok = true;
    public String requestId;
    public String decision = "ALLOW";
    public int riskScore = 0;
    public String summary = "SQL allowed.";
    public Facts facts = new Facts();
    public List<StatementResult> statements = new ArrayList<StatementResult>();
    public List<Violation> violations = new ArrayList<Violation>();
    public List<String> suggestions = new ArrayList<String>();
    public Map<String, Object> audit = new LinkedHashMap<String, Object>();
    public ErrorInfo error;

    public String toJson() { return JSON.toJSONString(toMap()); }

    public Map<String, Object> toMap() {
        LinkedHashMap<String, Object> m = new LinkedHashMap<String, Object>();
        m.put("ok", ok);
        if (requestId != null) m.put("requestId", requestId);
        if (ok) {
            m.put("decision", decision); m.put("riskScore", riskScore); m.put("summary", summary);
            m.put("facts", facts.toMap()); m.put("statements", toStatementMaps());
            m.put("violations", toViolationMaps()); m.put("suggestions", suggestions);
        } else if (error != null) m.put("error", error.toMap());
        m.put("audit", audit);
        return m;
    }

    private List<Map<String,Object>> toStatementMaps(){ List<Map<String,Object>> l=new ArrayList<Map<String,Object>>(); for(StatementResult s:statements)l.add(s.toMap()); return l; }
    private List<Map<String,Object>> toViolationMaps(){ List<Map<String,Object>> l=new ArrayList<Map<String,Object>>(); for(Violation v:violations)l.add(v.toMap()); return l; }

    public static SqlGuardResponse error(String requestId, String code, String message) {
        SqlGuardResponse r = new SqlGuardResponse(); r.ok = false; r.requestId = requestId; r.error = new ErrorInfo();
        r.error.code = code; r.error.message = message; r.audit.put("engine", "gsp-java"); return r;
    }

    public static class Facts {
        public String dialect;
        public List<TableFact> tables = new ArrayList<TableFact>();
        public List<ColumnFact> columns = new ArrayList<ColumnFact>();
        public List<JoinFact> joins = new ArrayList<JoinFact>();
        public List<Object> filters = new ArrayList<Object>();
        public List<AggregationFact> aggregations = new ArrayList<AggregationFact>();
        public List<LineageEdge> lineage = new ArrayList<LineageEdge>();
        public List<SetOperationFact> setOperations = new ArrayList<SetOperationFact>();
        public List<String> ctes = new ArrayList<String>();
        public List<OrderByFact> orderBy = new ArrayList<OrderByFact>();
        public List<String> diagnostics = new ArrayList<String>();
        Map<String,Object> toMap(){
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("dialect", dialect);
            m.put("tables", maps(tables));
            m.put("columns", maps(columns));
            m.put("joins", maps(joins));
            m.put("filters", filters);
            m.put("aggregations", maps(aggregations));
            m.put("lineage", maps(lineage));
            m.put("setOperations", maps(setOperations));
            m.put("ctes", ctes);
            m.put("orderBy", maps(orderBy));
            m.put("diagnostics", diagnostics);
            return m;
        }
    }
    interface Mappable { Map<String,Object> toMap(); }
    static List<Map<String,Object>> maps(List<? extends Mappable> in){ List<Map<String,Object>> out=new ArrayList<Map<String,Object>>(); for(Mappable x:in)out.add(x.toMap()); return out; }
    public static class TableFact implements Mappable { public String name; public String schema; public boolean catalogMatched; public Map<String,Object> toMap(){ LinkedHashMap<String,Object>m=new LinkedHashMap<String,Object>(); m.put("name",name); m.put("schema",schema); m.put("catalogMatched",catalogMatched); return m; }}
    public static class ColumnFact implements Mappable { public String table; public String name; public List<String> policyTags=new ArrayList<String>(); public String exposure; public Map<String,Object> toMap(){ LinkedHashMap<String,Object>m=new LinkedHashMap<String,Object>(); m.put("table",table); m.put("name",name); m.put("policyTags",policyTags); m.put("exposure",exposure); return m; }}

    /**
     * One ON-predicate pair emitted by the {@code WRONG_JOIN_PATH} rule
     * (blueprint §S24). Populated only when both sides bind to catalog
     * columns.
     *
     * <ul>
     *   <li>{@code joinPath} — the equality the SQL wrote, in canonical
     *       form: {@code "left.table.col = right.table.col"} (lowercased,
     *       fully-qualified to disambiguate identical-name tables).</li>
     *   <li>{@code joinPathMatchesForeignKey} — {@code true} when the
     *       predicate's columns line up with a catalog FK between the
     *       two tables (in either direction). {@code false} otherwise.</li>
     *   <li>{@code expectedForeignKeyPath} — non-null only when an FK
     *       exists between the joined tables but the predicate doesn't
     *       match it. Carries the canonical "correct" predicate so the
     *       BFF can surface a Did-you-mean.</li>
     * </ul>
     *
     * <p><b>Wire-format change in S24.</b> Pre-S24, {@code facts.joins}
     * was always serialized as {@code []}. S24 introduces typed
     * {@code JoinFact} entries; downstream consumers can no longer
     * assume the array is empty. {@code joinPath} and
     * {@code joinPathMatchesForeignKey} are always present on each
     * entry; {@code expectedForeignKeyPath} is OMITTED from the JSON
     * when null (i.e. for FK-matching joins and joins between tables
     * with no FK relationship at all). Joins whose sides don't catalog-
     * bind are NOT emitted (CTEs, subquery aliases, etc.).</p>
     *
     * <p><b>Single-column FK only (V1).</b> The matching logic uses
     * {@link gudusoft.gsqlparser.catalog.input.model.ConstraintModel}
     * entries whose {@code columns().size() == 1 &&
     * referencedColumns().size() == 1}. Composite-FK queries currently
     * report {@code joinPathMatchesForeignKey:false} and do NOT fire
     * WRONG_JOIN_PATH (because no single-column FK exists between the
     * tables — the rule stays silent rather than misfire). Multi-
     * column FK correlation is deferred to blueprint B8 (TODO #15).</p>
     */
    public static class JoinFact implements Mappable {
        public String joinPath;
        public boolean joinPathMatchesForeignKey;
        public String expectedForeignKeyPath;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("joinPath", joinPath);
            m.put("joinPathMatchesForeignKey", joinPathMatchesForeignKey);
            if (expectedForeignKeyPath != null) {
                m.put("expectedForeignKeyPath", expectedForeignKeyPath);
            }
            return m;
        }
    }

    /**
     * One UNION / INTERSECT / EXCEPT / MINUS operator in the statement,
     * populated by walking {@code TSelectSqlStatement.isCombinedQuery()} +
     * {@code getLeftStmt()}/{@code getRightStmt()}. Blueprint §S14/§S15.
     *
     * <p>The {@code op} carries the canonical SQL token form
     * ({@code "UNION"}, {@code "UNION ALL"}, {@code "INTERSECT"},
     * {@code "EXCEPT"}, {@code "EXCEPT ALL"}, {@code "MINUS"}). Multiple
     * set-ops in one statement emit one entry per operator in left-to-right
     * tree order. {@code statementIndex} pins each entry to the source
     * statement so multi-statement requests stay disambiguated.</p>
     */
    public static class SetOperationFact implements Mappable {
        public int statementIndex;
        public String op;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("statementIndex", statementIndex);
            m.put("op", op);
            return m;
        }
    }

    /**
     * One aggregation-level fact per SELECT, populated when the statement
     * carries a HAVING clause. Blueprint §S16. The {@code having} text is
     * round-tripped from {@code THavingClause.toString()} — dialect-faithful
     * verbatim text (lowercased to match the existing convention) so a
     * downstream BFF can echo "this query filters groups by …" without
     * re-parsing.
     *
     * <p>Wire-format contract: empty list when the statement has no
     * HAVING; one entry per statement that does. Currently single-field;
     * future S16 work may add {@code groupBy} / {@code having.atoms[]} —
     * the typed shape leaves room without breaking consumers.</p>
     */
    public static class AggregationFact implements Mappable {
        public int statementIndex;
        public String having;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("statementIndex", statementIndex);
            if (having != null) m.put("having", having);
            return m;
        }
    }
    public static class LineageEdge implements Mappable {
        public int statementIndex;
        public String targetColumn;
        public List<String> sourceColumns = new ArrayList<String>();
        public String lineageType;
        /**
         * Aggregate function calls detected inside this edge's source
         * expression, in left-to-right textual order, deduplicated. Each
         * entry is the bare uppercase function name (e.g. {@code "COUNT"},
         * {@code "SUM"}, {@code "AVG"}) or {@code "FUNC(DISTINCT)"} when
         * the call uses the DISTINCT modifier (e.g. {@code COUNT(DISTINCT)}).
         *
         * <p>Multi-aggregate expressions emit every call faithfully so
         * downstream intent-mismatch checks (blueprint §S23) can reason
         * about the actual aggregation grain: {@code COUNT(DISTINCT a) /
         * COUNT(*)} → {@code ["COUNT(DISTINCT)", "COUNT"]}, not a
         * collapsed scalar. A naive scalar field would record only the
         * first match and silently lie about the rest of the expression.
         *
         * <p>Scope: scalar aggregate calls only. Window aggregates
         * ({@code AVG(x) OVER (...)}) live on the separate
         * {@link #windowFunctions} field; FILTER aggregates
         * ({@code COUNT(x) FILTER (WHERE ...)}) are still deferred
         * (MantisBT #4468). A statement that mixes scalar and window
         * aggregates produces edges in both fields.
         *
         * <p>Wire-format contract: {@code null} for non-aggregate edges
         * and OMITTED from the JSON map so unaffected edges round-trip
         * byte-identical to the pre-S2 shape.
         */
        public List<String> aggregateFunctions;
        /**
         * Window function calls detected inside this edge's source
         * expression. Populated when any {@link gudusoft.gsqlparser.nodes.TFunctionCall}
         * in the projection carries a non-null
         * {@code getWindowSpecification()} / {@code getWindowDef()}.
         *
         * <p>Companion to {@link #aggregateFunctions} (scalar form) and
         * activated by blueprint §1.5.B B1 / B2. When this list is
         * non-empty, {@link #lineageType} is {@code "window"} and the
         * {@link #sourceColumns} list is augmented with the columns
         * referenced inside the window spec's {@code PARTITION BY} and
         * {@code ORDER BY} — dlineage surfaces those as {@code fdr} edges
         * with {@code clauseType="selectList"} / {@code "orderby"} on
         * the function resultset; sqlguard promotes them into
         * {@code sourceColumns} because they determine which rows the
         * window aggregate reads.
         *
         * <p><b>Wire-format contract:</b> {@code null} for non-window
         * edges and OMITTED from the JSON map; window edges add the
         * {@code windowFunctions} key. {@link #lineageType} simultaneously
         * shifts from {@code "expression"} (pre-B1) to {@code "window"}
         * for any projection containing an {@code OVER (...)} call, which
         * IS a wire-format change for downstream consumers that were
         * previously seeing window aggregates classified as
         * {@code "expression"}.
         *
         * <p><b>L3 escalation status (MantisBT #4467).</b> Populated
         * AST-side via {@link gudusoft.gsqlparser.nodes.TFunctionCall#getWindowDef()}
         * because dlineage does not surface window-spec metadata as
         * typed fields. When #4467 lands, the visitor migrates to
         * dlineage's {@code relationship.getWindowSpec()} and this
         * wire field stays unchanged.
         */
        public List<WindowFn> windowFunctions;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("statementIndex", statementIndex);
            m.put("targetColumn", targetColumn);
            m.put("sourceColumns", sourceColumns);
            m.put("lineageType", lineageType);
            if (aggregateFunctions != null) {
                m.put("aggregateFunctions", aggregateFunctions);
            }
            if (windowFunctions != null) {
                List<Map<String,Object>> wfs = new ArrayList<Map<String,Object>>();
                for (WindowFn wf : windowFunctions) {
                    wfs.add(wf.toMap());
                }
                m.put("windowFunctions", wfs);
            }
            return m;
        }
    }

    /**
     * One window-function call found inside a {@link LineageEdge}'s
     * source expression. Activated by blueprint §1.5.B B1 / B2.
     *
     * <ul>
     *   <li>{@code functionName} — uppercase function name
     *       (e.g. {@code "COUNT"}, {@code "LAG"}, {@code "ROW_NUMBER"}),
     *       or {@code "FUNC(DISTINCT)"} when the call uses the DISTINCT
     *       modifier. Matches the
     *       {@link LineageEdge#aggregateFunctions} convention.</li>
     *   <li>{@code partitionBy} — column names from {@code PARTITION BY}
     *       in textual order. Captured from the {@code TFunctionCall}'s
     *       {@code getWindowDef().getPartitionClause()}. Identifiers are
     *       lowercased per the project's vendor-aware folding so the
     *       wire shape matches the rest of {@code sourceColumns}; values
     *       are simple identifiers (no schema/table qualifier) because
     *       the partition syntax accepts bare expressions, not necessarily
     *       fully-qualified column refs.</li>
     *   <li>{@code orderBy} — entries from the window's {@code ORDER BY}
     *       clause as {@code {column, direction}} pairs, in textual
     *       order. {@code direction} is {@code "ASC"} / {@code "DESC"} /
     *       {@code "NONE"} when omitted in the SQL.</li>
     *   <li>{@code frame} — raw text of the frame specification when
     *       present (e.g. {@code "ROWS BETWEEN 1 PRECEDING AND CURRENT
     *       ROW"}), or {@code null} when no frame clause is given. We
     *       expose the source text rather than typed boundary nodes
     *       because frame syntax varies sharply across dialects;
     *       downstream consumers that need typed access should walk the
     *       AST. Omitted from JSON when {@code null}.</li>
     * </ul>
     *
     * <p>Wire-format contract: {@code functionName}, {@code partitionBy},
     * {@code orderBy} are always present (possibly empty list); {@code
     * frame} is OMITTED from the JSON map when {@code null}.
     */
    public static class WindowFn implements Mappable {
        public String functionName;
        public List<String> partitionBy = new ArrayList<String>();
        public List<OrderByItem> orderBy = new ArrayList<OrderByItem>();
        public String frame;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("functionName", functionName);
            m.put("partitionBy", partitionBy);
            List<Map<String,Object>> obs = new ArrayList<Map<String,Object>>();
            for (OrderByItem ob : orderBy) {
                obs.add(ob.toMap());
            }
            m.put("orderBy", obs);
            if (frame != null) {
                m.put("frame", frame);
            }
            return m;
        }
    }

    /** One ORDER BY entry inside a {@link WindowFn}. */
    public static class OrderByItem implements Mappable {
        public String column;
        public String direction;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("column", column);
            m.put("direction", direction);
            return m;
        }
    }

    /**
     * One top-level ORDER BY entry in a SELECT (blueprint §S12). Carries
     * {@code statementIndex} so multi-statement requests stay disambiguated;
     * this is the structural difference from {@link OrderByItem}, which is
     * the per-window form embedded inside {@link WindowFn} where the
     * statement context lives on the parent {@link LineageEdge}.
     */
    public static class OrderByFact implements Mappable {
        public int statementIndex;
        public String column;
        public String direction;
        public Map<String,Object> toMap() {
            LinkedHashMap<String,Object> m = new LinkedHashMap<String,Object>();
            m.put("statementIndex", statementIndex);
            m.put("column", column);
            m.put("direction", direction);
            return m;
        }
    }
    public static class StatementResult { public int index; public String sqlType; public String decision="ALLOW"; public int riskScore; public String summary="SQL allowed."; public int lineageCount; public Map<String,Object> toMap(){ LinkedHashMap<String,Object>m=new LinkedHashMap<String,Object>(); m.put("index",index); m.put("sqlType",sqlType); m.put("decision",decision); m.put("riskScore",riskScore); m.put("summary",summary); m.put("lineageCount",lineageCount); return m; }}
    public static class Violation { public int statementIndex; public String code; public String severity; public String message; public String evidence; public Map<String,Object> toMap(){ LinkedHashMap<String,Object>m=new LinkedHashMap<String,Object>(); m.put("statementIndex",statementIndex); m.put("code",code); m.put("severity",severity); m.put("message",message); m.put("evidence",evidence); return m; }}
    public static class ErrorInfo { public String code; public String message; public Map<String,Object> toMap(){ LinkedHashMap<String,Object>m=new LinkedHashMap<String,Object>(); m.put("code",code); m.put("message",message); return m; }}
}