package gudusoft.gsqlparser.dlineage.impl.powerquery;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryConnectorCall;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryIdentifierRef;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryLetExpr;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryNativeQuery;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryNavChain;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryNavSegment;
import gudusoft.gsqlparser.nodes.powerquery.TPowerQueryStep;
import gudusoft.gsqlparser.powerquery.ConnectorCatalog;
import gudusoft.gsqlparser.stmt.powerquery.TPowerQueryDocumentStmt;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Tier 1 + Tier 2 lineage analyzer for Power Query M documents.
 *
 * <p>Given a parsed {@link TPowerQueryDocumentStmt}, walks the step
 * graph and produces upstream lineage references.  Two patterns are
 * handled:
 *
 * <ul>
 *   <li>{@code Value.NativeQuery()} steps — decoded SQL is delegated to
 *       the inner vendor's {@link TGSqlParser} instance and the resulting
 *       lineage is surfaced via
 *       {@link PowerQueryLineageResult#getNativeQueryReferences()}.</li>
 *   <li>Navigation chains {@code source{[Name,Kind]}[Data]} — segments are
 *       resolved against the connector's expected hierarchy
 *       ({@link ConnectorCatalog#expectedHierarchy(EDbVendor)}) and a
 *       synthetic {@code db.schema.table} reference is emitted.</li>
 * </ul>
 *
 * <p>The analyzer is intentionally independent of the full
 * {@code DataFlowAnalyzer} pipeline — it can be run standalone from
 * sidecar code or from inside a higher-level lineage aggregator.
 *
 * <p><b>Emit policy for navigation refs:</b> every navigation-chain step
 * produces a {@link PowerQueryLineageResult.NavigationRef}, even when the
 * chain is only consumed as the context argument to a sibling
 * {@code Value.NativeQuery} (in which case the true upstream tables are
 * inside the decoded SQL, and the context-only nav refs are redundant).
 * The analyzer stays dumb on purpose — callers that care to distinguish
 * "real" upstreams from context-only narrowing should deduplicate using
 * the sibling {@link PowerQueryLineageResult#getNativeQueryReferences()}.
 */
public class TPowerQueryAnalyzer {

    private final TPowerQueryDocumentStmt stmt;
    private EDbVendor innerVendorOverride;
    private EDbVendor explicitInnerVendor;

    public TPowerQueryAnalyzer(TPowerQueryDocumentStmt stmt) {
        this.stmt = stmt;
    }

    /** Fallback vendor used only when no connector call is visible in the
     * document and no {@linkplain #withExplicitInnerVendor(EDbVendor)
     * explicit vendor} was supplied. */
    public TPowerQueryAnalyzer withInnerVendorOverride(EDbVendor vendor) {
        this.innerVendorOverride = vendor;
        return this;
    }

    /**
     * Force the SQL dialect used to parse inner SQL — both the decoded
     * {@code Value.NativeQuery()} text and navigation-chain synthetic
     * SELECTs. When set, this takes precedence over connector-based
     * inference; when {@code null} (default), inference is used.
     */
    public TPowerQueryAnalyzer withExplicitInnerVendor(EDbVendor vendor) {
        this.explicitInnerVendor = vendor;
        return this;
    }

    public PowerQueryLineageResult analyze() {
        PowerQueryLineageResult out = new PowerQueryLineageResult();
        if (stmt == null) return out;
        TPowerQueryLetExpr doc = stmt.getLetExpression();
        if (doc == null) return out;

        for (TPowerQueryStep step : doc.getSteps()) {
            TParseTreeNode expr = step.getExpression();
            if (expr instanceof TPowerQueryNativeQuery) {
                handleNativeQuery(doc, step, (TPowerQueryNativeQuery) expr, out);
            } else if (expr instanceof TPowerQueryNavChain) {
                handleNavigationChain(doc, step, (TPowerQueryNavChain) expr, out);
            }
        }

        // Propagate warnings emitted during parsing
        for (String w : stmt.getWarnings()) {
            out.addWarning(w);
        }

        return out;
    }

    // ---------- NativeQuery → inner SQL parser delegation ----------

    private void handleNativeQuery(TPowerQueryLetExpr doc,
                                   TPowerQueryStep step,
                                   TPowerQueryNativeQuery nq,
                                   PowerQueryLineageResult out) {
        EDbVendor vendor;
        if (explicitInnerVendor != null) {
            vendor = explicitInnerVendor;
        } else {
            vendor = nq.getInferredInnerVendor();
            if (vendor == null) {
                vendor = resolveVendorForStep(doc, nq.getSourceStepName());
            }
            if (vendor == null) {
                vendor = innerVendorOverride;
            }
        }

        PowerQueryLineageResult.NativeQueryRef ref =
                new PowerQueryLineageResult.NativeQueryRef();
        ref.stepName = step.getName();
        ref.decodedSql = nq.getDecodedSql();
        ref.resolvedVendor = vendor;

        if (vendor == null) {
            out.addWarning("Could not infer vendor for NativeQuery step '"
                    + step.getName() + "'; SQL left unparsed.");
            out.addNativeQuery(ref);
            return;
        }

        try {
            TGSqlParser inner = new TGSqlParser(vendor);
            inner.sqltext = nq.getDecodedSql();
            int rc = inner.parse();
            ref.innerParseReturnCode = rc;
            ref.innerParser = inner;
        } catch (RuntimeException re) {
            out.addWarning("Inner SQL parse for step '" + step.getName()
                    + "' threw: " + re.getMessage());
        }
        out.addNativeQuery(ref);
    }

    // ---------- Navigation chain → synthetic table reference ----------

    private void handleNavigationChain(TPowerQueryLetExpr doc,
                                       TPowerQueryStep step,
                                       TPowerQueryNavChain chain,
                                       PowerQueryLineageResult out) {
        EDbVendor vendor;
        if (explicitInnerVendor != null) {
            vendor = explicitInnerVendor;
        } else {
            vendor = resolveVendorForStep(doc, chain.getSourceStepName());
            if (vendor == null) vendor = innerVendorOverride;
        }

        PowerQueryLineageResult.NavigationRef ref =
                new PowerQueryLineageResult.NavigationRef();
        ref.stepName = step.getName();
        ref.resolvedVendor = vendor;

        collectChainSegmentsInOrder(doc, chain, ref);

        if (vendor == null) {
            out.addWarning("Could not infer vendor for navigation step '"
                    + step.getName() + "'; table reference is raw "
                    + ref.segments.toString());
        } else {
            ref.syntheticSelect = buildSyntheticSelect(vendor, ref);
        }
        out.addNavigation(ref);
    }

    /**
     * Walks back through prior nav-chain steps and appends their segments
     * to {@code ref} in connector-hierarchy order (oldest first). Without
     * this, each nav step only knows its own one segment, so the leaf's
     * synthetic SELECT would only reference the final name (e.g. just the
     * view) instead of the full {@code db.schema.view} path implied by
     * the source chain.
     */
    private void collectChainSegmentsInOrder(TPowerQueryLetExpr doc,
                                             TPowerQueryNavChain leaf,
                                             PowerQueryLineageResult.NavigationRef ref) {
        Deque<TPowerQueryNavChain> chainStack = new ArrayDeque<>();
        Set<String> guard = new HashSet<>();
        TPowerQueryNavChain current = leaf;
        while (current != null) {
            chainStack.push(current);
            String sourceName = current.getSourceStepName();
            if (sourceName == null || !guard.add(sourceName) || doc == null) break;
            TPowerQueryStep sourceStep = doc.findStep(sourceName);
            if (sourceStep == null) break;
            TParseTreeNode expr = sourceStep.getExpression();
            if (expr instanceof TPowerQueryNavChain) {
                current = (TPowerQueryNavChain) expr;
            } else {
                break;
            }
        }
        while (!chainStack.isEmpty()) {
            TPowerQueryNavChain c = chainStack.pop();
            for (TPowerQueryNavSegment seg : c.getSegments()) {
                if (seg == null) continue;
                ref.addSegment(seg.getKind(), seg.getName());
            }
        }
    }

    private String buildSyntheticSelect(EDbVendor vendor,
                                        PowerQueryLineageResult.NavigationRef ref) {
        List<String> hierarchy = ConnectorCatalog.expectedHierarchy(vendor);
        if (hierarchy.isEmpty() || ref.segments.isEmpty()) return null;

        List<String> parts = new ArrayList<>();
        for (PowerQueryLineageResult.NamedPart p : ref.segments) {
            if (p == null || p.name == null) continue;
            parts.add(p.name);
        }
        if (parts.isEmpty()) return null;

        String quoted = quoteIdentifiers(vendor, parts);
        return "SELECT * FROM " + quoted;
    }

    private String quoteIdentifiers(EDbVendor vendor, List<String> parts) {
        switch (vendor) {
            case dbvmssql: {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < parts.size(); i++) {
                    if (i > 0) sb.append('.');
                    sb.append('[').append(parts.get(i)).append(']');
                }
                return sb.toString();
            }
            case dbvmysql: {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < parts.size(); i++) {
                    if (i > 0) sb.append('.');
                    sb.append('`').append(parts.get(i)).append('`');
                }
                return sb.toString();
            }
            case dbvbigquery: {
                StringBuilder sb = new StringBuilder();
                sb.append('`');
                for (int i = 0; i < parts.size(); i++) {
                    if (i > 0) sb.append('.');
                    sb.append(parts.get(i));
                }
                sb.append('`');
                return sb.toString();
            }
            default: {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < parts.size(); i++) {
                    if (i > 0) sb.append('.');
                    sb.append('"').append(parts.get(i)).append('"');
                }
                return sb.toString();
            }
        }
    }

    // ---------- vendor inference ----------

    private EDbVendor resolveVendorForStep(TPowerQueryLetExpr doc, String stepName) {
        if (stepName == null || doc == null) return null;
        String current = stepName;
        java.util.Set<String> guard = new java.util.HashSet<>();
        while (current != null && guard.add(current)) {
            TPowerQueryStep step = doc.findStep(current);
            if (step == null) return null;
            TParseTreeNode expr = step.getExpression();
            if (expr instanceof TPowerQueryConnectorCall) {
                return ((TPowerQueryConnectorCall) expr).getResolvedVendor();
            }
            if (expr instanceof TPowerQueryIdentifierRef) {
                current = ((TPowerQueryIdentifierRef) expr).getName();
                continue;
            }
            if (expr instanceof TPowerQueryNavChain) {
                current = ((TPowerQueryNavChain) expr).getSourceStepName();
                continue;
            }
            // Opaque expression — try connector detection on raw text fallback.
            return null;
        }
        return null;
    }
}