package gudusoft.gsqlparser.lineage.v2.fold;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;

/**
 * What FOLD-V1 yields for one statement ({@code algorithms/fold-v1.md}, Section 2, item 1): the Fact
 * Occurrences, the FactCandidates, and the requirements on every write of a field. References are the
 * document-local {@code ref}s of the document the statement was folded from.
 *
 * @since 4.2.17
 */
public final class StatementFold {

    private final long statementRef;
    private final List<FactOccurrence> facts;
    private final List<Candidate> candidates;
    private final List<WriteRequirement> writes;

    StatementFold(long statementRef, List<FactOccurrence> facts, List<Candidate> candidates,
                  List<WriteRequirement> writes) {
        this.statementRef = statementRef;
        this.facts = Collections.unmodifiableList(new ArrayList<FactOccurrence>(facts));
        this.candidates = Collections.unmodifiableList(new ArrayList<Candidate>(candidates));
        this.writes = Collections.unmodifiableList(new ArrayList<WriteRequirement>(writes));
    }

    public long getStatementRef() {
        return statementRef;
    }

    /** One entry per Fact Occurrence (Section 8.1), ordered by source, target, label, path and ordinal. */
    public List<FactOccurrence> getFacts() {
        return facts;
    }

    /** One entry per FactCandidate (Section 7.1, items 4 to 6). */
    public List<Candidate> getCandidates() {
        return candidates;
    }

    /** One entry per field the statement writes (Sections 7.4 and 7.5), ordered by target. */
    public List<WriteRequirement> getWrites() {
        return writes;
    }

    static <T> List<T> frozen(List<T> list) {
        return Collections.unmodifiableList(new ArrayList<T>(list));
    }

    static List<List<Long>> frozenWalks(List<List<Long>> walks) {
        List<List<Long>> out = new ArrayList<List<Long>>();
        for (List<Long> walk : walks) {
            out.add(Collections.unmodifiableList(new ArrayList<Long>(walk)));
        }
        return Collections.unmodifiableList(out);
    }

    /** A detached, frozen copy of a binding, so that no result aliases the document it was folded from. */
    static Map<?, ?> freeze(Map<?, ?> binding) {
        return binding == null ? null : (Map<?, ?>) gudusoft.gsqlparser.lineage.v2.json.CanonicalJson.immutableCopy(binding);
    }

    static SortedSet<Long> frozen(Set<Long> set) {
        return Collections.unmodifiableSortedSet(new TreeSet<Long>(set));
    }

    /** One (source, target) pair of an outcome (Section 7.1, item 5). */
    public static final class Pair {
        private final Object source;
        private final Object target;

        public Pair(Object source, Object target) {
            this.source = source;
            this.target = target;
        }

        /** The source ref; for the candidate set of an {@code UNRESOLVED} reference, that set's ref. */
        public Object getSource() {
            return source;
        }

        public Object getTarget() {
            return target;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof Pair)) {
                return false;
            }
            Pair pair = (Pair) other;
            return FoldKernel.same(source, pair.source) && FoldKernel.same(target, pair.target);
        }

        @Override
        public int hashCode() {
            return FoldKernel.hash(source) * 31 + FoldKernel.hash(target);
        }

        @Override
        public String toString() {
            return "(" + source + ", " + target + ")";
        }
    }

    /**
     * One end of a FactCandidate: a fixed endpoint, or a candidate set with its membership, and, when another reference
     * decides it (fold-v1 Section 7.1, item 5), the decision.
     */
    public static final class End {
        private final Object endpointRef;
        private final List<Object> members;
        private final Object membership;
        private final Decision decision;

        private End(Object endpointRef, List<Object> members, Object membership, Decision decision) {
            this.endpointRef = endpointRef;
            this.members = members;
            this.membership = membership;
            this.decision = decision;
        }

        static End fixed(Object endpointRef) {
            return new End(endpointRef, null, null, null);
        }

        static End set(List<Object> members, Object membership) {
            return set(members, membership, null);
        }

        static End set(List<Object> members, Object membership, Decision decision) {
            return new End(null, Collections.unmodifiableList(new ArrayList<Object>(members)), membership, decision);
        }

        /** How another reference decides this candidate-set end; null when none does (or for a fixed end). */
        public Decision getDecision() {
            return decision;
        }

        public boolean isFixed() {
            return members == null;
        }

        /** The endpoint of a fixed end; null for a candidate set. */
        public Object getEndpointRef() {
            return endpointRef;
        }

        /** The members of a candidate-set end, sorted; null for a fixed end. */
        public List<Object> getMembers() {
            return members;
        }

        /** {@code COMPLETE} or {@code INCOMPLETE} for a candidate-set end; null for a fixed end. */
        public Object getMembership() {
            return membership;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof End)) {
                return false;
            }
            End end = (End) other;
            if (isFixed() != end.isFixed()) {
                return false;
            }
            if (isFixed()) {
                return FoldKernel.same(endpointRef, end.endpointRef);
            }
            if (members.size() != end.members.size() || !FoldKernel.same(membership, end.membership)
                    || (decision == null ? end.decision != null : !decision.equals(end.decision))) {
                return false;
            }
            for (int i = 0; i < members.size(); i++) {
                if (!FoldKernel.same(members.get(i), end.members.get(i))) {
                    return false;
                }
            }
            return true;
        }

        @Override
        public int hashCode() {
            if (isFixed()) {
                return FoldKernel.hash(endpointRef);
            }
            int h = FoldKernel.hash(membership);
            for (Object member : members) {
                h = h * 31 + FoldKernel.hash(member);
            }
            return h;
        }

        @Override
        public String toString() {
            return isFixed() ? String.valueOf(endpointRef) : "SET " + membership + " " + members
                    + (decision == null ? "" : " " + decision);
        }
    }

    /**
     * How a reference decides a FactCandidate's candidate-set end (fold-v1 Section 7.1, item 5): the deciding
     * reference's candidate set (in the ExplainGraph; at a published end, the document's set with the same members),
     * and the pairs {alternative, member}, sorted. Two decisions are equal when the deciding sets have the same members
     * and membership and the pairs are equal.
     */
    public static final class Decision {
        private final Object decidingRef;
        private final List<Object> alternatives;
        private final Object membership;
        private final List<Pair> alignment;

        Decision(Object decidingRef, List<Object> alternatives, Object membership, List<Pair> alignment) {
            this.decidingRef = decidingRef;
            List<Object> sorted = new ArrayList<Object>(alternatives);
            Collections.sort(sorted, FoldKernel.REF_ORDER);
            this.alternatives = Collections.unmodifiableList(sorted);
            this.membership = membership;
            List<Pair> pairs = new ArrayList<Pair>(alignment);
            Collections.sort(pairs, new java.util.Comparator<Pair>() {
                @Override
                public int compare(Pair a, Pair b) {
                    int c = FoldKernel.REF_ORDER.compare(a.getSource(), b.getSource());
                    return c != 0 ? c : FoldKernel.REF_ORDER.compare(a.getTarget(), b.getTarget());
                }
            });
            this.alignment = Collections.unmodifiableList(pairs);
        }

        /** The deciding reference's candidate set. */
        public Object getDecidingRef() {
            return decidingRef;
        }

        /** The members of the deciding set, sorted. */
        public List<Object> getAlternatives() {
            return alternatives;
        }

        public Object getMembership() {
            return membership;
        }

        /** The pairs: source is the alternative, target the member of the end. */
        public List<Pair> getAlignment() {
            return alignment;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof Decision)) {
                return false;
            }
            Decision d = (Decision) other;
            return alternatives.equals(d.alternatives) && FoldKernel.same(membership, d.membership)
                    && alignment.equals(d.alignment);
        }

        @Override
        public int hashCode() {
            return alternatives.hashCode() * 31 + alignment.hashCode();
        }

        @Override
        public String toString() {
            return "DECIDED " + alternatives + " " + membership + " " + alignment;
        }
    }

    /** A Fact Occurrence (Section 8.1): the proposition, its path and ordinal, proof, bindings and support. */
    public static final class FactOccurrence {
        private final Object sourceRef;
        private final Object targetRef;
        private final FoldLabel label;
        private final Object path;
        private final Long offset;
        private final int ordinal;
        private final String proofStatus;
        private final SortedSet<Long> support;
        private final Map<?, ?> sourceBinding;
        private final Map<?, ?> targetBinding;

        private final List<List<Long>> supportWalks;

        FactOccurrence(Object sourceRef, Object targetRef, FoldLabel label, Object path, Long offset, int ordinal,
                       String proofStatus, Set<Long> support, Map<?, ?> sourceBinding, Map<?, ?> targetBinding,
                       List<List<Long>> supportWalks) {
            this.supportWalks = frozenWalks(supportWalks);
            this.sourceRef = sourceRef;
            this.targetRef = targetRef;
            this.label = label;
            this.path = path;
            this.offset = offset;
            this.ordinal = ordinal;
            this.proofStatus = proofStatus;
            this.support = frozen(support);
            this.sourceBinding = freeze(sourceBinding);
            this.targetBinding = freeze(targetBinding);
        }

        public Object getSourceRef() {
            return sourceRef;
        }

        public Object getTargetRef() {
            return targetRef;
        }

        public FoldLabel getLabel() {
            return label;
        }

        /** The semantic path of the reference read by the first edge ({@code referencePath}), or null. */
        public Object getPath() {
            return path;
        }

        /** The UTF-8 offset of that reference ({@code referenceStart}), or null. */
        public Long getOffset() {
            return offset;
        }

        /** The rank among the Occurrences of the same Fact and path, by the position of the reference. */
        public int getOrdinal() {
            return ordinal;
        }

        /** {@code PROVEN} or {@code ASSUMED} (Section 7.2, item 2). */
        public String getProofStatus() {
            return proofStatus;
        }

        /** The micro-edges of the support subgraph (Section 8.2, item 1). */
        public SortedSet<Long> getSupport() {
            return support;
        }

        /**
         * Fold walks (micro-edge refs in walk order) that each yield this Occurrence and together cover its support
         * subgraph: the {@code supportPaths} to publish (Section 8.2, items 3 and 4).
         */
        public List<List<Long>> getSupportWalks() {
            return supportWalks;
        }

        /**
         * The source-side binding of the first edge (Section 8.1, item 2), or null when it has none. When several
         * walks support the Occurrence, the binding comes from a walk that decides its proof (an unconditional
         * {@code PROVEN} walk for a {@code PROVEN} Occurrence), and among those from the first edge earliest in
         * the text.
         */
        public Map<?, ?> getSourceBinding() {
            return sourceBinding;
        }

        /** The target-side binding of the last edge, chosen like {@link #getSourceBinding()}. */
        public Map<?, ?> getTargetBinding() {
            return targetBinding;
        }

        @Override
        public String toString() {
            return sourceRef + " -" + label + "-> " + targetRef + " @" + path + "#" + ordinal + " " + proofStatus;
        }
    }

    /**
     * The binding of one side of a FactCandidate Occurrence (Section 7.1, item 6). When
     * {@link #namesOwnCandidateSet()} is true, the binding's {@code candidateSetRef} stands for the candidate set
     * of that side of the FactCandidate itself, whose ref the producer assigns.
     */
    public static final class CandidateBinding {
        private final Map<?, ?> binding;
        private final boolean ownCandidateSet;

        CandidateBinding(Map<?, ?> binding, boolean ownCandidateSet) {
            this.binding = freeze(binding);
            this.ownCandidateSet = ownCandidateSet;
        }

        /** The binding as found on the micro-edge, or null when the edge has none. */
        public Map<?, ?> getBinding() {
            return binding;
        }

        public boolean namesOwnCandidateSet() {
            return ownCandidateSet;
        }

        @Override
        public String toString() {
            return binding + (ownCandidateSet ? " (own candidate set)" : "");
        }
    }

    /** A FactCandidate (Section 7.1, items 4 to 6) with its Occurrence. */
    public static final class Candidate {
        private final FoldLabel label;
        private final List<Object> references;
        private final End source;
        private final End target;
        private final Set<Set<Pair>> outcomes;
        private final Set<Set<Pair>> effectiveOutcomes;
        private final String proofStatus;
        private final SortedSet<Long> support;
        private final Object path;
        private final Long offset;
        int ordinal;
        CandidateBinding sourceBinding;
        CandidateBinding targetBinding;

        private final List<List<Long>> supportWalks;

        Candidate(FoldLabel label, List<Object> references, End source, End target, Set<Set<Pair>> outcomes,
                  Set<Set<Pair>> effectiveOutcomes, String proofStatus, Set<Long> support, Object path, Long offset,
                  List<List<Long>> supportWalks) {
            this.supportWalks = frozenWalks(supportWalks);
            this.label = label;
            this.references = frozen(references);
            this.source = source;
            this.target = target;
            this.outcomes = outcomes == null ? null : FoldKernel.frozenOutcomes(outcomes);
            this.effectiveOutcomes = FoldKernel.frozenOutcomes(effectiveOutcomes);
            this.proofStatus = proofStatus;
            this.support = frozen(support);
            this.path = path;
            this.offset = offset;
        }

        public FoldLabel getLabel() {
            return label;
        }

        /** The ambiguous references of the group, named by their candidate sets, sorted. */
        public List<Object> getReferences() {
            return references;
        }

        public End getSource() {
            return source;
        }

        public End getTarget() {
            return target;
        }

        /** The outcomes to list in {@code outcomes}; null when they are the implied ones. */
        public Set<Set<Pair>> getOutcomes() {
            return outcomes;
        }

        /** The outcomes that hold: the listed ones, or the implied ones when none are listed. */
        public Set<Set<Pair>> getEffectiveOutcomes() {
            return effectiveOutcomes;
        }

        public String getProofStatus() {
            return proofStatus;
        }

        public SortedSet<Long> getSupport() {
            return support;
        }

        /** Fold walks that each yield this FactCandidate and together cover its support subgraph. */
        public List<List<Long>> getSupportWalks() {
            return supportWalks;
        }

        /** The semantic path of the deciding reference, or null. */
        public Object getPath() {
            return path;
        }

        /** The UTF-8 offset of the deciding reference, or null. */
        public Long getOffset() {
            return offset;
        }

        /** The rank among the FactCandidates of the statement with the same subject and path (identity-v1 5.4). */
        public int getOrdinal() {
            return ordinal;
        }

        public CandidateBinding getSourceBinding() {
            return sourceBinding;
        }

        public CandidateBinding getTargetBinding() {
            return targetBinding;
        }

        @Override
        public String toString() {
            return source + " -" + label + "-> " + target + " @" + path + "#" + ordinal + " " + proofStatus
                    + (outcomes == null ? "" : " outcomes " + outcomes);
        }
    }

    /**
     * A terminal input of a write (Section 7.5): its kind, disclosure, the literal or hash token, and a parameter's
     * marker as written with, for an anonymous marker, its position (two parameters of one write are two inputs).
     */
    public static final class TerminalInput {
        private final Object kind;
        private final Object disclosure;
        private final Object value;
        private final Object parameterText;
        private final Object parameterOrdinal;

        TerminalInput(Object kind, Object disclosure, Object value, Object parameterText, Object parameterOrdinal) {
            this.kind = kind;
            this.disclosure = disclosure;
            this.value = value;
            this.parameterText = parameterText;
            this.parameterOrdinal = parameterOrdinal;
        }

        /** A PARAMETER's marker or name as written, else null. */
        public Object getParameterText() {
            return parameterText;
        }

        /** An anonymous PARAMETER marker's position among the statement's anonymous markers, else null. */
        public Object getParameterOrdinal() {
            return parameterOrdinal;
        }

        public Object getKind() {
            return kind;
        }

        public Object getDisclosure() {
            return disclosure;
        }

        /** The literal of a {@code PRESENT} literal, the canonical JSON of a {@code HASHED} token, else null. */
        public Object getValue() {
            return value;
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof TerminalInput)) {
                return false;
            }
            TerminalInput input = (TerminalInput) other;
            return FoldKernel.same(kind, input.kind) && FoldKernel.same(disclosure, input.disclosure)
                    && FoldKernel.same(value, input.value) && FoldKernel.same(parameterText, input.parameterText)
                    && FoldKernel.same(parameterOrdinal, input.parameterOrdinal);
        }

        @Override
        public int hashCode() {
            return (((FoldKernel.hash(kind) * 31 + FoldKernel.hash(disclosure)) * 31 + FoldKernel.hash(value)) * 31
                    + FoldKernel.hash(parameterText)) * 31 + FoldKernel.hash(parameterOrdinal);
        }

        @Override
        public String toString() {
            return kind + " " + disclosure + " " + value + (parameterText == null ? "" : " " + parameterText)
                    + (parameterOrdinal == null ? "" : " #" + parameterOrdinal);
        }
    }

    /** What a write of one field must carry (Sections 7.4 and 7.5). */
    public static final class WriteRequirement {
        private final Object targetRef;
        private final String bound;
        private final List<FactOccurrence> facts;
        private final List<Candidate> candidates;
        private final Set<TerminalInput> terminals;
        private final SortedSet<Long> diagnosticRefs;

        WriteRequirement(Object targetRef, String bound, List<FactOccurrence> facts, List<Candidate> candidates,
                         Set<TerminalInput> terminals, Set<Long> diagnosticRefs) {
            this.targetRef = targetRef;
            this.bound = bound;
            this.facts = frozen(facts);
            this.candidates = frozen(candidates);
            this.terminals = Collections.unmodifiableSet(new java.util.LinkedHashSet<TerminalInput>(terminals));
            this.diagnosticRefs = frozen(diagnosticRefs);
        }

        public Object getTargetRef() {
            return targetRef;
        }

        /** The highest {@code upstreamCompleteness} the write may declare: COMPLETE, PARTIAL or UNKNOWN. */
        public String getBound() {
            return bound;
        }

        /** One Occurrence of each Fact into the field; each Fact is a {@code FIELD_REF} input. */
        public List<FactOccurrence> getFacts() {
            return facts;
        }

        /** The FactCandidates whose target end is the field or contains it; each is a {@code FIELD_REF} input. */
        public List<Candidate> getCandidates() {
            return candidates;
        }

        /** The terminals that reach the field through {@code VALUE} micro-edges only. */
        public Set<TerminalInput> getTerminals() {
            return terminals;
        }

        /** The diagnostics of the nodes and holes that lowered the bound; the write must link them. */
        public SortedSet<Long> getDiagnosticRefs() {
            return diagnosticRefs;
        }

        @Override
        public String toString() {
            return targetRef + " " + bound + " facts " + facts.size() + " candidates " + candidates.size()
                    + " terminals " + terminals + " diagnostics " + diagnosticRefs;
        }
    }
}