package gudusoft.gsqlparser.lineage.v2.merge;

import gudusoft.gsqlparser.lineage.v2.json.CanonicalJson;
import gudusoft.gsqlparser.lineage.v2.model.Document;
import gudusoft.gsqlparser.lineage.v2.validation.DocumentIndex;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import static gudusoft.gsqlparser.lineage.v2.validation.DocumentIndex.items;

/**
 * The {@code SEMANTIC} comparison of two documents (specification Sections 9.7 to 9.9; contract: section 7 of
 * {@code docs/designs/data-lineage/05-sqllr-m1-core-library-plan-zh.md}). Objects are matched by identity, never by
 * document-local reference: analysis contexts by content, endpoints by portable id, Facts by {@code FactIdV1},
 * Occurrences by logical key (all records of one key together, so a status change is reported as one change even
 * when the analysis context changed too), statements by unit id and ordinal, writes by statement, target and
 * assignment ordinal, ExplainGraph nodes by logical key. Compared values replace each reference by the identity of
 * what it names, so a change of a referenced object (an evidence item, a candidate's outcomes) shows; objects
 * without an identity are compared only through what refers to them, and a note counts those left unmatched.
 *
 * <p>The diff document of the specification is not defined yet (Section 20, item 6), so the comparison is an
 * in-memory {@link Comparison}.</p>
 *
 * @since 4.2.17
 */
public final class LineageComparator {

    /** The kinds of change, in the order they are reported. */
    public enum Kind {
        /** An analysis context only the second document has (reported first, Section 9.9). */
        CONTEXT_ADDED,
        CONTEXT_REMOVED,
        ENDPOINT_ADDED,
        ENDPOINT_REMOVED,
        /** An endpoint of one portable identity whose other attributes (kind, name, display) changed. */
        ENDPOINT_CHANGED,
        FACT_ADDED,
        FACT_REMOVED,
        /** A Fact of one identity whose other attributes changed. */
        FACT_CHANGED,
        OCCURRENCE_ADDED,
        OCCURRENCE_REMOVED,
        /** The proof status, a binding or the evidence of one logical Occurrence changed (Section 9.7). */
        STATUS_CHANGED,
        /** The completeness of the document, a unit, a statement, a write, a feature, serving or the ExplainGraph. */
        COMPLETENESS_CHANGED,
        /** A statement or an ExplainGraph node moved and nothing else about it changed. */
        LOCATION_CHANGED
    }

    /** One difference. */
    public static final class Change {
        private final Kind kind;
        private final String key;
        private final Object before;
        private final Object after;

        Change(Kind kind, String key, Object before, Object after) {
            this.kind = kind;
            this.key = key;
            this.before = before == null ? null : CanonicalJson.immutableCopy(before);
            this.after = after == null ? null : CanonicalJson.immutableCopy(after);
        }

        public Kind getKind() {
            return kind;
        }

        /** The identity of what changed: an id, a logical key, or a composite key. */
        public String getKey() {
            return key;
        }

        /** The compared value in the first document (frozen JSON, references as identities), or null. */
        public Object getBefore() {
            return before;
        }

        /** The compared value in the second document, or null. */
        public Object getAfter() {
            return after;
        }

        @Override
        public String toString() {
            return kind + " " + key + (before == null && after == null ? ""
                    : ": " + CanonicalJson.jcsText(before) + " -> " + CanonicalJson.jcsText(after));
        }
    }

    /** The differences of two documents, in the order of {@link Kind}. */
    public static final class Comparison {
        private final List<Change> changes;
        private final List<String> notes;

        Comparison(List<Change> changes, List<String> notes) {
            this.changes = Collections.unmodifiableList(changes);
            this.notes = Collections.unmodifiableList(notes);
        }

        public List<Change> getChanges() {
            return changes;
        }

        public boolean isEmpty() {
            return changes.isEmpty();
        }

        public List<String> getNotes() {
            return notes;
        }

        @Override
        public String toString() {
            return changes.toString();
        }
    }

    private LineageComparator() {
    }

    public static Comparison compare(Document before, Document after) {
        View a = new View(before.toBytes());
        View b = new View(after.toBytes());
        List<Change> changes = new ArrayList<Change>();
        List<String> notes = new ArrayList<String>();
        diffSets(changes, Kind.CONTEXT_ADDED, Kind.CONTEXT_REMOVED, null, a.contexts, b.contexts);
        diffSets(changes, Kind.ENDPOINT_ADDED, Kind.ENDPOINT_REMOVED, Kind.ENDPOINT_CHANGED, a.endpoints, b.endpoints);
        diffSets(changes, Kind.FACT_ADDED, Kind.FACT_REMOVED, Kind.FACT_CHANGED, a.facts, b.facts);
        diffSets(changes, Kind.OCCURRENCE_ADDED, Kind.OCCURRENCE_REMOVED, Kind.STATUS_CHANGED, a.occurrences,
                b.occurrences);
        diffUnion(changes, Kind.COMPLETENESS_CHANGED, a.completeness, b.completeness);
        diffValues(changes, Kind.LOCATION_CHANGED, a.locations, b.locations);
        for (View view : new View[] {a, b}) {
            if (view.unidentified > 0) {
                notes.add((view == a ? "first" : "second") + " document: " + view.unidentified
                        + " Occurrences or writes have no identity; they are compared only through what refers to them");
            }
        }
        return new Comparison(changes, notes);
    }

    private static void diffSets(List<Change> changes, Kind added, Kind removed, Kind changed, Map<String, Object> a,
                                 Map<String, Object> b) {
        for (Map.Entry<String, Object> entry : b.entrySet()) {
            if (!a.containsKey(entry.getKey())) {
                changes.add(new Change(added, entry.getKey(), null, entry.getValue()));
            }
        }
        for (Map.Entry<String, Object> entry : a.entrySet()) {
            if (!b.containsKey(entry.getKey())) {
                changes.add(new Change(removed, entry.getKey(), entry.getValue(), null));
            }
        }
        if (changed != null) {
            diffValues(changes, changed, a, b);
        }
    }

    /** Changed values, and values present on one side only (an ExplainGraph added or removed, for instance). */
    private static void diffUnion(List<Change> changes, Kind kind, Map<String, Object> a, Map<String, Object> b) {
        java.util.TreeSet<String> keys = new java.util.TreeSet<String>(a.keySet());
        keys.addAll(b.keySet());
        for (String key : keys) {
            Object x = a.get(key);
            Object y = b.get(key);
            if (x == null || y == null || !CanonicalJson.jcsText(x).equals(CanonicalJson.jcsText(y))) {
                changes.add(new Change(kind, key, x, y));
            }
        }
    }

    private static void diffValues(List<Change> changes, Kind kind, Map<String, Object> a, Map<String, Object> b) {
        for (Map.Entry<String, Object> entry : a.entrySet()) {
            Object other = b.get(entry.getKey());
            if (other != null && !CanonicalJson.jcsText(entry.getValue()).equals(CanonicalJson.jcsText(other))) {
                changes.add(new Change(kind, entry.getKey(), entry.getValue(), other));
            }
        }
    }

    /** What a document says, keyed by identity. */
    private static final class View {
        final Map<String, Object> contexts = new TreeMap<String, Object>();
        final Map<String, Object> endpoints = new TreeMap<String, Object>();
        final Map<String, Object> facts = new TreeMap<String, Object>();
        final Map<String, Object> occurrences = new TreeMap<String, Object>();
        final Map<String, Object> completeness = new TreeMap<String, Object>();
        final Map<String, Object> locations = new TreeMap<String, Object>();
        int unidentified;
        private final Semantics semantics;

        View(byte[] document) {
            semantics = new Semantics(document);
            DocumentIndex index = semantics.index();
            Map<?, ?> doc = index.document();
            for (Map<?, ?> context : items(doc.get("analysisContexts"))) {
                contexts.put(semantics.keyedIdentity(context.get("ref")), semantics.formOf(context.get("ref")));
            }
            for (Map<?, ?> endpoint : index.all("endpoint")) {
                String identity = semantics.keyedIdentity(endpoint.get("ref"));
                if (identity != null) {
                    add(endpoints, identity, semantics.formOf(endpoint.get("ref")));
                }
            }
            for (Map<?, ?> fact : index.all("fact")) {
                String identity = semantics.keyedIdentity(fact.get("ref"));
                if (identity != null) {
                    add(facts, identity, semantics.formOf(fact.get("ref")));
                }
            }
            for (Map<?, ?> occurrence : index.all("occurrence")) {
                String identity = semantics.keyedIdentity(occurrence.get("ref"));
                if (identity == null) {
                    unidentified++;
                    continue;
                }
                Map<String, Object> record = new TreeMap<String, Object>();
                for (Map.Entry<?, ?> member : ((Map<?, ?>) semantics.formOf(occurrence.get("ref"))).entrySet()) {
                    String name = String.valueOf(member.getKey());
                    // the analysis context of the record is compared with the contexts, not with each record
                    if (!"recordId".equals(name) && !"statementRef".equals(name)) {
                        record.put(name, member.getValue());
                    }
                }
                add(occurrences, identity, record);
            }
            completeness.put("document", Collections.singletonList(doc.get("analysisCompleteness")));
            completeness.put("serving", semantics.form(doc.get("servingCompleteness"), "servingCompleteness"));
            completeness.put("features", doc.get("featureCompleteness") == null ? Collections.emptyList()
                    : semantics.form(doc.get("featureCompleteness"), "featureCompleteness"));
            Map<?, ?> graph = index.graph();
            if (index.hasGraph()) {
                List<Object> graphCompleteness = new ArrayList<Object>();
                graphCompleteness.add(graph.get("completeness"));
                graphCompleteness.add(graph.get("statementCompleteness") == null ? Collections.emptyList()
                        : semantics.form(graph.get("statementCompleteness"), "explainGraph.statementCompleteness"));
                completeness.put("explainGraph", graphCompleteness);
            }
            for (Map<?, ?> unit : index.all("sourceUnit")) {
                String identity = semantics.keyedIdentity(unit.get("ref"));
                if (identity != null) {
                    add(completeness, identity, scopeCompleteness(unit, "sourceUnits[].featureCompleteness"));
                }
            }
            for (Map<?, ?> statement : index.all("statement")) {
                String identity = semantics.keyedIdentity(statement.get("ref"));
                if (identity != null) {
                    add(completeness, identity, scopeCompleteness(statement, "statements[].featureCompleteness"));
                    Map<String, Object> where = new TreeMap<String, Object>();
                    where.put("start", statement.get("start"));
                    where.put("end", statement.get("end"));
                    add(locations, identity, where);
                }
            }
            for (Map<?, ?> write : index.all("tfo")) {
                String statement = semantics.keyedIdentity(write.get("statementRef"));
                String target = semantics.keyedIdentity(write.get("targetRef"));
                if (statement == null || target == null) {
                    unidentified++;
                    continue;
                }
                Map<String, Object> value = new TreeMap<String, Object>();
                for (String member : new String[] {"upstreamCompleteness", "upstreamDisposition",
                        "upstreamDispositionReason"}) {
                    if (write.containsKey(member)) {
                        value.put(member, write.get(member));
                    }
                }
                add(completeness, "write " + statement + " " + target + " " + write.get("assignmentOrdinal"), value);
            }
            for (Map<?, ?> node : index.all("node")) {
                String identity = semantics.keyedIdentity(node.get("ref"));
                if (identity != null && node.get("span") != null) {
                    add(locations, identity, semantics.form(node.get("span"), "explainGraph.nodes[].span"));
                }
            }
        }

        private Object scopeCompleteness(Map<?, ?> scope, String path) {
            Map<String, Object> value = new TreeMap<String, Object>();
            value.put("analysisCompleteness", scope.get("analysisCompleteness"));
            if (scope.get("featureCompleteness") != null) {
                value.put("featureCompleteness", semantics.form(scope.get("featureCompleteness"), path));
            }
            return value;
        }

        /** Several objects of one identity (one per analysis context, for instance) are compared as a multiset. */
        @SuppressWarnings("unchecked")
        private static void add(Map<String, Object> into, String identity, Object value) {
            List<Object> values = (List<Object>) into.get(identity);
            if (values == null) {
                values = new ArrayList<Object>();
                into.put(identity, values);
            }
            values.add(value);
            List<String> texts = new ArrayList<String>();
            for (Object item : values) {
                texts.add(CanonicalJson.jcsText(item));
            }
            Collections.sort(texts);
            values.clear();
            for (String text : texts) {
                values.add(CanonicalJson.parse(text.getBytes(java.nio.charset.StandardCharsets.UTF_8)));
            }
        }
    }
}