package gudusoft.gsqlparser.dlineage.dynamicsql;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.Endpoint;
import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;

/**
 * B3 (design {@code routine-summary-scc-design.md} §2.6): the canonical
 * LEAF-edge comparator between a LEGACY analysis and the SHADOW side model.
 * Comparison is over boundary→boundary leaf edges — the same reachability
 * projection the B2 differential proof uses — never XML equality.
 *
 * <p>Edge keys are STRUCTURED ({@link LeafEdgeKey}): every identifier segment
 * is a {@link CanonKey} built with an EXPLICIT vendor, so equality carries the
 * vendor's real identifier relation (SQL Server collation included) and never
 * consults ambient global state; display strings are rendering only
 * (codex-B3-r1 finding 8).
 *
 * <p>Classification:
 * <ul>
 * <li>{@code EQUAL} — leaf edge present in both runs;</li>
 * <li>{@code INTENDED_ADDITION} — SHADOW-only edge (the promotion gate
 *     requires every one of these to match a hand-authored golden,
 *     bidirectionally — arch-F2 / codex-r2 N4);</li>
 * <li>{@code MISSING_LEGACY_EDGE} — LEGACY edge absent from SHADOW. Current
 *     publication is observation-only and cannot remove legacy edges; the
 *     class remains useful for evaluating a future application mode;</li>
 * <li>{@code REGRESSION} — a missing legacy edge whose exact endpoints
 *     survive in SHADOW with a FLIPPED relation flavor (fdd↔fdr): the flow
 *     survived but its semantics changed. Checked BEFORE CHANGED_TARGET —
 *     the more specific pairing wins (codex-B3-r1 finding 9);</li>
 * <li>{@code CHANGED_TARGET} — a missing legacy edge paired with a
 *     shadow-only edge sharing (vendor, relation type, source): the flow
 *     moved rather than vanished. Only meaningful under replacement (B6).</li>
 * </ul>
 */
public final class ShadowLeafEdgeComparator {

    public enum Classification {
        EQUAL, INTENDED_ADDITION, MISSING_LEGACY_EDGE, CHANGED_TARGET, REGRESSION
    }

    /** One canonical leaf-edge key: vendor + relation type + two endpoints,
     *  each endpoint a kind plus CanonKey'd name segments. */
    public static final class LeafEdgeKey {
        private final EDbVendor vendor;
        private final String relationType;
        private final String sourceKind;
        private final List<CanonKey> sourceSegments;
        private final String targetKind;
        private final List<CanonKey> targetSegments;
        private final String display;

        private LeafEdgeKey(EDbVendor vendor, String relationType,
                String sourceKind, List<CanonKey> sourceSegments, String sourceText,
                String targetKind, List<CanonKey> targetSegments, String targetText) {
            this.vendor = vendor;
            this.relationType = relationType;
            this.sourceKind = sourceKind;
            this.sourceSegments = Collections.unmodifiableList(sourceSegments);
            this.targetKind = targetKind;
            this.targetSegments = Collections.unmodifiableList(targetSegments);
            this.display = relationType + "|" + sourceKind + ":" + sourceText
                    + "|" + targetKind + ":" + targetText;
        }

        static LeafEdgeKey of(EDbVendor vendor, Endpoint source, Endpoint target,
                String relationType) {
            return new LeafEdgeKey(vendor, relationType,
                    source.getKind().name(), segmentsOf(vendor, source),
                    source.getParent() + "." + source.getColumn(),
                    target.getKind().name(), segmentsOf(vendor, target),
                    target.getParent() + "." + target.getColumn());
        }

        /**
         * Parse one hand-golden line: {@code type|KIND:parent.column|KIND:parent.column}.
         * Segments go through the SAME canonKey construction as model-derived
         * keys, so the golden's spelling case is irrelevant wherever the
         * vendor's identifier rules say it is.
         */
        public static LeafEdgeKey parse(EDbVendor vendor, String line) {
            String[] parts = line.split("\\|");
            if (parts.length != 3) {
                throw new IllegalArgumentException("expected type|src|tgt: " + line);
            }
            String[] src = splitEndpoint(parts[1], line);
            String[] tgt = splitEndpoint(parts[2], line);
            return new LeafEdgeKey(vendor, parts[0].trim(),
                    src[0], segmentsOf(vendor, src[1]), src[1],
                    tgt[0], segmentsOf(vendor, tgt[1]), tgt[1]);
        }

        private static String[] splitEndpoint(String text, String line) {
            int colon = text.indexOf(':');
            if (colon <= 0) {
                throw new IllegalArgumentException("expected KIND:name in " + line);
            }
            return new String[] { text.substring(0, colon).trim(),
                    text.substring(colon + 1).trim() };
        }

        private static List<CanonKey> segmentsOf(EDbVendor vendor, Endpoint e) {
            return segmentsOf(vendor, e.getParent() + "." + e.getColumn());
        }

        private static List<CanonKey> segmentsOf(EDbVendor vendor, String qualified) {
            List<String> parts = SQLUtil.parseNames(qualified);
            List<CanonKey> keys = new ArrayList<CanonKey>();
            for (int i = 0; i < parts.size(); i++) {
                // last segment is the column; the rest are container names
                ESQLDataObjectType type = i == parts.size() - 1
                        ? ESQLDataObjectType.dotColumn : ESQLDataObjectType.dotTable;
                keys.add(SQLUtil.canonKey(vendor, type, parts.get(i)));
            }
            return keys;
        }

        public String getRelationType() { return relationType; }

        boolean sameSourceAndType(LeafEdgeKey o) {
            // non-identifier-compare: relation type + kind tokens; segments use CanonKey equality
            return vendor == o.vendor && relationType.equals(o.relationType)
                    && sourceKind.equals(o.sourceKind)
                    && sourceSegments.equals(o.sourceSegments);
        }

        boolean sameEndpointsFlippedType(LeafEdgeKey o) {
            // non-identifier-compare: relation type + kind tokens; segments use CanonKey equality
            return vendor == o.vendor && !relationType.equals(o.relationType)
                    && sourceKind.equals(o.sourceKind)
                    && sourceSegments.equals(o.sourceSegments)
                    && targetKind.equals(o.targetKind)
                    && targetSegments.equals(o.targetSegments);
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (!(obj instanceof LeafEdgeKey)) {
                return false;
            }
            LeafEdgeKey o = (LeafEdgeKey) obj;
            // non-identifier-compare: relation type + kind tokens; segments use CanonKey equality
            return vendor == o.vendor && relationType.equals(o.relationType)
                    && sourceKind.equals(o.sourceKind)
                    && sourceSegments.equals(o.sourceSegments)
                    && targetKind.equals(o.targetKind)
                    && targetSegments.equals(o.targetSegments);
        }

        @Override
        public int hashCode() {
            int h = vendor.hashCode();
            h = h * 31 + relationType.hashCode();
            h = h * 31 + sourceKind.hashCode();
            h = h * 31 + sourceSegments.hashCode();
            h = h * 31 + targetKind.hashCode();
            h = h * 31 + targetSegments.hashCode();
            return h;
        }

        /** Rendering only — never compare display strings. */
        @Override
        public String toString() {
            return display;
        }
    }

    /** One classified canonical leaf edge. */
    public static final class ClassifiedEdge {
        private final LeafEdgeKey key;
        private final Classification classification;

        ClassifiedEdge(LeafEdgeKey key, Classification classification) {
            this.key = key;
            this.classification = classification;
        }

        public LeafEdgeKey getKey() { return key; }
        public Classification getClassification() { return classification; }

        @Override
        public String toString() {
            return classification + " " + key;
        }
    }

    /** Comparator output: classified edges + promotion-gate view. */
    public static final class Report {
        private final List<ClassifiedEdge> entries;

        Report(List<ClassifiedEdge> entries) {
            this.entries = Collections.unmodifiableList(entries);
        }

        public List<ClassifiedEdge> getEntries() { return entries; }

        public List<ClassifiedEdge> byClassification(Classification c) {
            List<ClassifiedEdge> result = new ArrayList<ClassifiedEdge>();
            for (ClassifiedEdge e : entries) {
                if (e.getClassification() == c) {
                    result.add(e);
                }
            }
            return result;
        }

        /** §2.6 gate: the report contains ONLY EQUAL + INTENDED_ADDITION. */
        public boolean onlyEqualAndIntendedAdditions() {
            for (ClassifiedEdge e : entries) {
                if (e.getClassification() != Classification.EQUAL
                        && e.getClassification() != Classification.INTENDED_ADDITION) {
                    return false;
                }
            }
            return true;
        }
    }

    private ShadowLeafEdgeComparator() {
    }

    /**
     * Canonical leaf-edge keys of an analyzed dataflow: its relation graph's
     * boundary→boundary reachability projection (identical machinery to the
     * summary extraction closure, applied to the WHOLE unit's model).
     */
    public static Set<LeafEdgeKey> leafKeysOf(EDbVendor vendor, dataflow df) {
        Set<LeafEdgeKey> keys = new LinkedHashSet<LeafEdgeKey>();
        if (df == null) {
            return keys;
        }
        RoutineSummaryExtractor.RelationGraph graph =
                RoutineSummaryExtractor.RelationGraph.of(df);
        for (RoutineSummaryEdge edge : RoutineSummaryExtractor.close(graph)) {
            keys.add(LeafEdgeKey.of(vendor, edge.getSource(), edge.getTarget(),
                    edge.getRelationType()));
        }
        return keys;
    }

    /**
     * Leaf key → number of DISTINCT composition occurrences producing it
     * (caller × callee × call-site ordinal — the additions set already
     * carries occurrence identity). This is the provenance-bearing layer of
     * the two-layer key ruling (codex-B3-r2 findings 8/10): the golden gate
     * checks OCCURRENCE counts, so losing one of several same-topology
     * composition paths fails even though the leaf projection is unchanged.
     */
    public static java.util.Map<LeafEdgeKey, Integer> occurrenceCountsOf(
            EDbVendor vendor, Set<ShadowSummaryApplier.ComposedEdge> additions) {
        java.util.Map<LeafEdgeKey, Integer> counts =
                new java.util.LinkedHashMap<LeafEdgeKey, Integer>();
        for (ShadowSummaryApplier.ComposedEdge edge : additions) {
            LeafEdgeKey key = LeafEdgeKey.of(vendor, edge.getSource(),
                    edge.getTarget(), edge.getRelationType());
            Integer prior = counts.get(key);
            counts.put(key, prior == null ? 1 : prior + 1);
        }
        return counts;
    }

    /** Canonical keys of SHADOW additions (same construction as legacy keys). */
    public static Set<LeafEdgeKey> additionKeysOf(EDbVendor vendor,
            Set<ShadowSummaryApplier.ComposedEdge> additions) {
        Set<LeafEdgeKey> keys = new LinkedHashSet<LeafEdgeKey>();
        for (ShadowSummaryApplier.ComposedEdge edge : additions) {
            keys.add(LeafEdgeKey.of(vendor, edge.getSource(), edge.getTarget(),
                    edge.getRelationType()));
        }
        return keys;
    }

    /**
     * Classify a LEGACY leaf-edge set against the SHADOW side model
     * (B3 shape: SHADOW = LEGACY ∪ additions, so only EQUAL and
     * INTENDED_ADDITION can appear; the remaining classes guard the
     * comparator's reuse under B6 replacement).
     */
    public static Report compare(Set<LeafEdgeKey> legacyKeys,
            Set<LeafEdgeKey> shadowKeys) {
        List<ClassifiedEdge> entries = new ArrayList<ClassifiedEdge>();
        List<LeafEdgeKey> missing = new ArrayList<LeafEdgeKey>();
        List<LeafEdgeKey> shadowOnly = new ArrayList<LeafEdgeKey>();
        for (LeafEdgeKey key : legacyKeys) {
            if (shadowKeys.contains(key)) {
                entries.add(new ClassifiedEdge(key, Classification.EQUAL));
            } else {
                missing.add(key);
            }
        }
        for (LeafEdgeKey key : shadowKeys) {
            if (!legacyKeys.contains(key)) {
                shadowOnly.add(key);
            }
        }
        for (LeafEdgeKey miss : missing) {
            Classification cls = Classification.MISSING_LEGACY_EDGE;
            for (LeafEdgeKey candidate : shadowOnly) {
                if (miss.sameEndpointsFlippedType(candidate)) {
                    cls = Classification.REGRESSION;
                    break;
                }
            }
            if (cls == Classification.MISSING_LEGACY_EDGE) {
                for (LeafEdgeKey candidate : shadowOnly) {
                    if (miss.sameSourceAndType(candidate)) {
                        cls = Classification.CHANGED_TARGET;
                        break;
                    }
                }
            }
            entries.add(new ClassifiedEdge(miss, cls));
        }
        for (LeafEdgeKey key : shadowOnly) {
            entries.add(new ClassifiedEdge(key, Classification.INTENDED_ADDITION));
        }
        return new Report(entries);
    }
}