package gudusoft.gsqlparser.lineage2.api;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EResolverType;
import gudusoft.gsqlparser.ESqlStatementType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.ir.semantic.DiagnosticCode;
import gudusoft.gsqlparser.ir.semantic.catalog.Catalog;
import gudusoft.gsqlparser.lineage2.contract.ContractDiagnostic;
import gudusoft.gsqlparser.lineage2.contract.ContractEdge;
import gudusoft.gsqlparser.lineage2.contract.ContractStatement;
import gudusoft.gsqlparser.lineage2.contract.ContractVersions;
import gudusoft.gsqlparser.lineage2.contract.DiagnosticSeverity;
import gudusoft.gsqlparser.lineage2.contract.FingerprintV1;
import gudusoft.gsqlparser.lineage2.contract.LineageDocument;
import gudusoft.gsqlparser.lineage2.contract.SourceLocation;
import gudusoft.gsqlparser.lineage2.contract.TransformGraph;
import gudusoft.gsqlparser.lineage2.engine.StatementLineageExtractor;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * lineage2 engine entry point (lineage2-execution-plan.md §3): analyzes one
 * <b>unit</b> (a SQL file or script) and produces the uniform contract
 * document (lineage2-contract.md).
 *
 * <p>The document carries the statement inventory — 1-based
 * {@code statementIndex} in source order, contract {@code kind},
 * FINGERPRINT-V1 {@code queryFingerprint}, absolute {@code sourceLocation}
 * (1-based, half-open, trailing statement separator excluded) — plus
 * statement-level degrade [D-09]: a statement that fails to parse yields a
 * {@code PARSE_FAILED} diagnostic on its own entry and the remaining
 * statements are unaffected; the engine never throws for malformed SQL.
 * Edge extraction is per statement kind: {@code SELECT} statements flow
 * through {@link StatementLineageExtractor} (US-021); the remaining kinds
 * land with their stories (US-022+), so {@code transformGraphs} is still
 * empty.
 *
 * <p>The {@code artifactLocator} is bound here, at the API boundary where
 * the unit is known: from {@link LineageConfig#getArtifactLocator()} for
 * text input, or the file's base name for the {@link File} overload (the
 * config value wins when non-empty).
 *
 * <p>The {@link Catalog} parameter feeds the semantic gate and the
 * endpoint {@code resolutionStatus} computation; the full BindingGate
 * (AMBIGUOUS / PARSER_UNSUPPORTED facts) arrives with US-025.
 *
 * <p>This class is stateless and its static methods are safe to call from
 * multiple threads.
 *
 * <p>Internal API: not part of the public gsqlparser surface.
 */
public final class LineageAnalyzer {

    /** Gold-fixture-pinned degrade message (GF-034a). */
    private static final String PARSE_FAILED_MESSAGE =
            "statement could not be parsed; no lineage extracted";

    private LineageAnalyzer() {
        // utility — no instances
    }

    /**
     * Analyze a unit supplied as text.
     *
     * @param unitText non-null SQL text of the whole unit
     * @param vendor   non-null vendor enum
     * @param catalog  optional catalog snapshot; may be {@code null}
     * @param config   optional configuration; {@code null} means
     *                 {@link LineageConfig#defaults()}
     * @return the contract document wrapped in a {@link LineageResult};
     *         never throws for malformed SQL (runtime exceptions signal
     *         engine bugs, per contract §2)
     */
    public static LineageResult analyze(String unitText, EDbVendor vendor,
                                        Catalog catalog, LineageConfig config) {
        if (unitText == null) {
            throw new IllegalArgumentException("unitText must not be null");
        }
        if (vendor == null) {
            throw new IllegalArgumentException("vendor must not be null");
        }
        LineageConfig effective = (config == null)
                ? LineageConfig.defaults() : config;
        return analyzeUnit(unitText, vendor, catalog, effective,
                effective.getArtifactLocator());
    }

    /**
     * Analyze a unit supplied as a file (read as UTF-8). The
     * {@code artifactLocator} defaults to the file's base name; a non-empty
     * {@link LineageConfig#getArtifactLocator()} overrides it.
     *
     * @throws IOException when the file cannot be read — I/O failures are
     *                     the caller's concern, unlike SQL-level failures
     *                     which degrade into diagnostics
     */
    public static LineageResult analyze(File unitFile, EDbVendor vendor,
                                        Catalog catalog, LineageConfig config)
            throws IOException {
        if (unitFile == null) {
            throw new IllegalArgumentException("unitFile must not be null");
        }
        if (vendor == null) {
            throw new IllegalArgumentException("vendor must not be null");
        }
        String unitText = new String(
                Files.readAllBytes(unitFile.toPath()), StandardCharsets.UTF_8);
        LineageConfig effective = (config == null)
                ? LineageConfig.defaults() : config;
        String locator = effective.getArtifactLocator().isEmpty()
                ? unitFile.getName() : effective.getArtifactLocator();
        return analyzeUnit(unitText, vendor, catalog, effective, locator);
    }

    private static LineageResult analyzeUnit(String unitText, EDbVendor vendor,
                                             Catalog catalog,
                                             LineageConfig config,
                                             String artifactLocator) {
        TGSqlParser parser = new TGSqlParser(vendor);
        parser.setResolverType(EResolverType.RESOLVER2);
        parser.sqltext = unitText;
        int rc = parser.parse();

        List<ContractStatement> statements = new ArrayList<>();
        List<ContractEdge> edges = new ArrayList<>();
        List<ContractDiagnostic> unitDiagnostics = new ArrayList<>();

        TStatementList stmts = parser.sqlstatements;
        if (stmts == null || stmts.size() == 0) {
            if (rc != 0) {
                // Whole-unit parse catastrophe: nothing was split into
                // statements, so degrade at document level.
                String errorMessage = parser.getErrormessage();
                if (errorMessage == null || errorMessage.isEmpty()) {
                    errorMessage = "parser returned non-zero rc=" + rc;
                }
                unitDiagnostics.add(new ContractDiagnostic(
                        DiagnosticCode.PARSE_FAILED.name(),
                        DiagnosticSeverity.ERROR,
                        "SQL parse failed: " + errorMessage, null, null));
            }
            // rc == 0 with no statements (e.g. comment-only unit): an empty
            // statement inventory with no diagnostics.
        } else {
            LineIndex lines = new LineIndex(unitText);
            for (int i = 0; i < stmts.size(); i++) {
                TCustomSqlStatement raw = stmts.get(i);
                ContractStatement statement = buildStatement(raw, i + 1,
                        unitText, lines, artifactLocator);
                statements.add(statement);
                if (statement.getDiagnostics().isEmpty()
                        && "SELECT".equals(statement.getKind())
                        && raw instanceof TSelectSqlStatement) {
                    int[] span = statementSpan(raw, unitText);
                    String statementText = (span != null)
                            ? unitText.substring(span[0], span[1])
                            : String.valueOf(raw);
                    edges.addAll(StatementLineageExtractor.extract(
                            (TSelectSqlStatement) raw, statementText, i + 1,
                            statement.getQueryFingerprint(), vendor, catalog,
                            config, artifactLocator, unitText));
                }
            }
        }

        LineageDocument document = new LineageDocument(
                ContractVersions.CONTRACT_VERSION,
                ContractVersions.engineVersion(),
                vendorName(vendor),
                artifactLocator,
                statements,
                edges,
                Collections.<TransformGraph>emptyList(),
                unitDiagnostics);
        return new LineageResult(document);
    }

    /**
     * One contract statement entry: source-ordered index, kind,
     * FINGERPRINT-V1 of the statement's verbatim text (trailing statement
     * separator excluded — the same slice convention as
     * {@code SqlSemanticAnalyzer.statementText}), absolute half-open span
     * of that text, and the degrade diagnostic when the statement failed
     * to parse.
     */
    private static ContractStatement buildStatement(TCustomSqlStatement stmt,
                                                    int statementIndex,
                                                    String unitText,
                                                    LineIndex lines,
                                                    String artifactLocator) {
        int[] span = statementSpan(stmt, unitText);
        String text;
        SourceLocation location = null;
        if (span != null) {
            text = unitText.substring(span[0], span[1]);
            location = new SourceLocation(artifactLocator, statementIndex,
                    lines.lineOf(span[0]), lines.colOf(span[0]),
                    lines.lineOf(span[1]), lines.colOf(span[1]));
        } else {
            // Defensive fallback — boundary tokens unusable. No fabricated
            // position (contract §6); fingerprint over the parser's text.
            text = String.valueOf(stmt);
        }

        boolean parseFailed = stmt.sqlstatementtype == ESqlStatementType.sstinvalid
                || stmt.getErrorCount() > 0;
        List<ContractDiagnostic> diagnostics;
        if (parseFailed) {
            diagnostics = Collections.singletonList(new ContractDiagnostic(
                    DiagnosticCode.PARSE_FAILED.name(),
                    DiagnosticSeverity.ERROR, PARSE_FAILED_MESSAGE,
                    statementIndex, location));
        } else {
            diagnostics = Collections.emptyList();
        }

        String kind = (stmt.sqlstatementtype == ESqlStatementType.sstinvalid)
                ? "UNKNOWN" : statementKind(stmt);
        return new ContractStatement(statementIndex, kind,
                FingerprintV1.fingerprint(text), location, diagnostics);
    }

    /**
     * Half-open {@code [start, end)} character span of the statement's
     * verbatim text within the unit: boundary-token offsets, minus trailing
     * whitespace and one trailing {@code ';'}. Returns {@code null} when
     * the boundary tokens are unusable.
     */
    private static int[] statementSpan(TCustomSqlStatement stmt, String unitText) {
        TSourceToken startToken = stmt.getStartToken();
        TSourceToken endToken = stmt.getEndToken();
        if (startToken == null || endToken == null) {
            return null;
        }
        int start = (int) startToken.offset;
        String endText = endToken.astext;
        int end = (int) endToken.offset + (endText == null ? 0 : endText.length());
        if (start < 0 || end < start || end > unitText.length()) {
            return null;
        }
        // Defensive: skip leading whitespace (the start token is normally a
        // solid token, so this is a no-op).
        while (start < end && Character.isWhitespace(unitText.charAt(start))) {
            start++;
        }
        while (end > start && Character.isWhitespace(unitText.charAt(end - 1))) {
            end--;
        }
        if (end > start && unitText.charAt(end - 1) == ';') {
            end--;
            while (end > start && Character.isWhitespace(unitText.charAt(end - 1))) {
                end--;
            }
        }
        if (end == start) {
            return null;
        }
        return new int[]{start, end};
    }

    /**
     * Contract statement-kind string (contract §2.1). Kinds outside the
     * documented M2 set fall back to {@code "UNKNOWN"} until their
     * extraction stories define them (the kind list is open-ended and the
     * semantic layer is draft until the M2 freeze).
     */
    private static String statementKind(TCustomSqlStatement stmt) {
        ESqlStatementType type = stmt.sqlstatementtype;
        switch (type) {
            case sstselect:
                boolean selectInto = stmt instanceof TSelectSqlStatement
                        && ((TSelectSqlStatement) stmt).getIntoClause() != null;
                return selectInto ? "SELECT_INTO" : "SELECT";
            case sstinsert:
                return "INSERT";
            case sstupdate:
                return "UPDATE";
            case sstdelete:
                return "DELETE";
            case sstmerge:
                return "MERGE";
            case sstcreatetable:
                return "CREATE_TABLE";
            case sstcreateview:
                return "CREATE_VIEW";
            case sstcreatesynonym:
                return "CREATE_SYNONYM";
            default:
                return "UNKNOWN";
        }
    }

    /** Contract vendor string: the {@link EDbVendor} name minus its
     * {@code dbv} prefix (e.g. {@code dbvmssql} → {@code "mssql"}). */
    private static String vendorName(EDbVendor vendor) {
        String name = vendor.name();
        return name.startsWith("dbv") ? name.substring(3) : name;
    }

    /** Offset → 1-based line/column conversion over the unit text. */
    private static final class LineIndex {
        private final int[] lineStarts;

        LineIndex(String text) {
            int lineCount = 1;
            for (int i = 0; i < text.length(); i++) {
                if (text.charAt(i) == '\n') {
                    lineCount++;
                }
            }
            lineStarts = new int[lineCount];
            int line = 1;
            for (int i = 0; i < text.length(); i++) {
                if (text.charAt(i) == '\n') {
                    lineStarts[line++] = i + 1;
                }
            }
        }

        int lineOf(int offset) {
            int lo = 0, hi = lineStarts.length - 1;
            while (lo < hi) {
                int mid = (lo + hi + 1) >>> 1;
                if (lineStarts[mid] <= offset) {
                    lo = mid;
                } else {
                    hi = mid - 1;
                }
            }
            return lo + 1;
        }

        int colOf(int offset) {
            return offset - lineStarts[lineOf(offset) - 1] + 1;
        }
    }
}