package gudusoft.gsqlparser.lineage.v2.fold;

import gudusoft.gsqlparser.lineage.v2.Finding;
import gudusoft.gsqlparser.lineage.v2.validation.DocumentIndex;
import gudusoft.gsqlparser.lineage.v2.validation.SemanticStage;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

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

/**
 * The {@code PROJECTOR} checks of {@code algorithms/fold-v1.md}, Section 11: folds each statement with
 * {@link FoldKernel} and compares the result with the Fact layer of the same document, at stage
 * {@code SEMANTIC}.
 *
 * <p>The comparison is a port of the reference runner's ({@code conformance/run.py}, class {@code Projector}),
 * so a document gets the same diagnostic codes from both, with one declared difference: the reference leaves out
 * the derived-unit rules of Section 7.3, and this check applies them, so a statement of a derived unit whose text
 * is only {@code OBSERVED} folds to {@code ASSUMED} Occurrences and writes bounded by {@code PARTIAL}.</p>
 *
 * @since 4.2.17
 */
public final class Projector implements SemanticStage.FoldCheck {

    /**
     * The check to give {@link gudusoft.gsqlparser.lineage.v2.validation.LineageValidator#standard}, with the
     * kernel's default limits.
     */
    public static final SemanticStage.FoldCheck CHECK = new Projector(FoldKernel.DEFAULT_MAX_STATES,
            FoldKernel.DEFAULT_MAX_WORLDS);

    private final int maxStates;
    private final int maxWorlds;

    private Projector(int maxStates, int maxWorlds) {
        this.maxStates = maxStates;
        this.maxWorlds = maxWorlds;
    }

    /** The check with other limits on the work of folding one statement (see {@link FoldKernel}). */
    public static SemanticStage.FoldCheck withLimits(int maxStates, int maxWorlds) {
        return new Projector(maxStates, maxWorlds);
    }

    @Override
    public void check(DocumentIndex index, List<Finding> findings, List<String> notes) {
        new Run(new FoldKernel(index, maxStates, maxWorlds), findings).run();
    }

    /** One comparison: the document, the kernel and the findings. */
    private static final class Run {
        private final FoldKernel kernel;
        private final DocumentIndex index;
        private final List<Finding> findings;
        private final Map<List<Object>, List<Long>> factsByProposition = new HashMap<List<Object>, List<Long>>();

        Run(FoldKernel kernel, List<Finding> findings) {
            this.kernel = kernel;
            this.index = kernel.getIndex();
            this.findings = findings;
            for (Map<?, ?> fact : index.all("fact")) {
                List<Object> key = Arrays.<Object>asList(FoldKernel.norm(fact.get("sourceRef")),
                        FoldKernel.norm(fact.get("targetRef")), labelOfFact(fact));
                List<Long> refs = factsByProposition.get(key);
                if (refs == null) {
                    refs = new ArrayList<Long>();
                    factsByProposition.put(key, refs);
                }
                refs.add(intRef(fact.get("ref")));
            }
        }

        void run() {
            findings.addAll(kernel.malformedEdges());
            for (Long statement : kernel.getStatements()) {
                compare(statement, kernel.fold(statement));
            }
        }

        private static FoldLabel labelOfFact(Map<?, ?> obj) {
            return FoldLabel.of(obj.get("kind"), obj.get("role"));
        }

        /** (source, target, label, path, ordinal): the key of a Fact Occurrence. */
        private static List<Object> factKey(Object source, Object target, FoldLabel label, Object path, Object ordinal) {
            return Arrays.<Object>asList(FoldKernel.norm(source), FoldKernel.norm(target), label,
                    new FoldKernel.PathKey(path), FoldKernel.norm(ordinal));
        }

        private void compare(long statement, StatementFold folded) {
            boolean complete = "COMPLETE".equals(kernel.completeness(statement));
            List<Map<?, ?>> occurrences = new ArrayList<Map<?, ?>>();
            for (Map<?, ?> occurrence : index.all("occurrence")) {
                if (FoldKernel.same(occurrence.get("statementRef"), statement)) {
                    occurrences.add(occurrence);
                }
            }
            String where = "statement ref " + statement;

            LinkedHashMap<List<Object>, StatementFold.FactOccurrence> expectedFacts =
                    new LinkedHashMap<List<Object>, StatementFold.FactOccurrence>();
            for (StatementFold.FactOccurrence fact : folded.getFacts()) {
                expectedFacts.put(factKey(fact.getSourceRef(), fact.getTargetRef(), fact.getLabel(), fact.getPath(),
                        (long) fact.getOrdinal()), fact);
            }
            Set<List<Object>> matchedFactKeys = new LinkedHashSet<List<Object>>();
            for (Map<?, ?> occurrence : occurrences) {
                if (!occurrence.containsKey("factRef")) {
                    continue;
                }
                Map<?, ?> fact = index.get("fact", occurrence.get("factRef"));
                if (fact == null) {
                    continue;
                }
                List<Object> key = factKey(fact.get("sourceRef"), fact.get("targetRef"), labelOfFact(fact),
                        occurrence.get("path"), occurrence.get("ordinal"));
                StatementFold.FactOccurrence expected = expectedFacts.get(key);
                if (expected != null) {
                    matchedFactKeys.add(key);
                    checkOccurrence(occurrence, expected.getProofStatus(), expected.getSupport(), complete, expected, null);
                    continue;
                }
                if (candidateHolds(folded, labelOfFact(fact), fact.get("sourceRef"), fact.get("targetRef"))) {
                    findings.add(new Finding("SEMANTIC_FOLD_CANDIDATE_AS_FACT", "occurrences ref " + occurrence.get("ref"),
                            "the fold yields only a FactCandidate for this proposition"));
                } else if (complete) {
                    findings.add(new Finding("SEMANTIC_FOLD_UNSUPPORTED", "occurrences ref " + occurrence.get("ref"),
                            "no fold walk yields this Fact Occurrence"));
                }
            }
            for (Map.Entry<List<Object>, StatementFold.FactOccurrence> entry : expectedFacts.entrySet()) {
                if (!matchedFactKeys.contains(entry.getKey())) {
                    findings.add(new Finding("SEMANTIC_FOLD_MISSING_FACT", where,
                            "no Occurrence for fold result " + entry.getValue()));
                }
            }

            // Candidate results: exact matches first, then the near misses on the same path and kind.
            List<Object[]> declared = new ArrayList<Object[]>();
            for (Map<?, ?> occurrence : occurrences) {
                Map<?, ?> candidate = index.get("factCandidate", occurrence.get("factCandidateRef"));
                if (candidate != null) {
                    declared.add(new Object[] {occurrence, candidate});
                }
            }
            LinkedHashMap<Object, StatementFold.Candidate> candidateMatches =
                    new LinkedHashMap<Object, StatementFold.Candidate>();
            List<StatementFold.Candidate> unmatched = new ArrayList<StatementFold.Candidate>();
            for (StatementFold.Candidate result : folded.getCandidates()) {
                Map<?, ?> hit = null;
                for (Object[] pair : declared) {
                    Map<?, ?> occurrence = (Map<?, ?>) pair[0];
                    if (!candidateMatches.containsKey(FoldKernel.norm(occurrence.get("ref")))
                            && sameCandidate(occurrence, (Map<?, ?>) pair[1], result)) {
                        hit = occurrence;
                        break;
                    }
                }
                if (hit == null) {
                    unmatched.add(result);
                } else {
                    candidateMatches.put(FoldKernel.norm(hit.get("ref")), result);
                    checkOccurrence(hit, result.getProofStatus(), result.getSupport(), complete, null, result);
                }
            }
            List<Object[]> leftover = new ArrayList<Object[]>();
            for (Object[] pair : declared) {
                if (!candidateMatches.containsKey(FoldKernel.norm(((Map<?, ?>) pair[0]).get("ref")))) {
                    leftover.add(pair);
                }
            }
            for (StatementFold.Candidate result : unmatched) {
                Object[] near = null;
                for (Object[] pair : leftover) {
                    Map<?, ?> occurrence = (Map<?, ?>) pair[0];
                    if (FoldKernel.same(occurrence.get("path"), result.getPath())
                            && labelOfFact((Map<?, ?>) pair[1]).equals(result.getLabel())) {
                        near = pair;
                        break;
                    }
                }
                if (near != null) {
                    leftover.remove(near);
                    findings.add(new Finding("SEMANTIC_FOLD_CANDIDATE_MISMATCH",
                            "occurrences ref " + ((Map<?, ?>) near[0]).get("ref"), "the fold yields " + result));
                } else {
                    findings.add(new Finding("SEMANTIC_FOLD_MISSING_FACT", where, "no FactCandidate for fold result "
                            + result));
                }
            }
            if (complete) {
                for (Object[] pair : leftover) {
                    findings.add(new Finding("SEMANTIC_FOLD_UNSUPPORTED", "occurrences ref " + ((Map<?, ?>) pair[0]).get("ref"),
                            "no fold walk yields this FactCandidate"));
                }
            }
            checkWrites(statement, matchedFactKeys, candidateMatches);
        }

        private static boolean candidateHolds(StatementFold folded, FoldLabel label, Object source, Object target) {
            StatementFold.Pair pair = new StatementFold.Pair(source, target);
            for (StatementFold.Candidate candidate : folded.getCandidates()) {
                if (candidate.getLabel().equals(label)) {
                    for (Set<StatementFold.Pair> outcome : candidate.getEffectiveOutcomes()) {
                        if (outcome.contains(pair)) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        /**
         * The decision of a published FactCandidate end (fold-v1 Section 7.1, item 5): the deciding set it names, a set of
         * the document's candidateSets, compared by its members and membership; null without decidedBy.
         */
        private StatementFold.Decision declaredDecision(Map<?, ?> cset) {
            if (!(cset.get("decidedBy") instanceof Map<?, ?>)) {
                return null;
            }
            Map<?, ?> decided = (Map<?, ?>) cset.get("decidedBy");
            Map<?, ?> deciding = null;
            for (Map<?, ?> root : items(index.document().get("candidateSets"))) {
                if (FoldKernel.same(FoldKernel.norm(root.get("ref")), FoldKernel.norm(decided.get("candidateSetRef")))) {
                    deciding = root;
                }
            }
            List<Object> alternatives = new ArrayList<Object>();
            if (deciding != null && deciding.get("candidateRefs") instanceof List<?>) {
                for (Object member : (List<?>) deciding.get("candidateRefs")) {
                    alternatives.add(FoldKernel.norm(member));
                }
            }
            List<StatementFold.Pair> alignment = new ArrayList<StatementFold.Pair>();
            for (Map<?, ?> pair : items(decided.get("alignment"))) {
                alignment.add(new StatementFold.Pair(FoldKernel.norm(pair.get("alternativeRef")),
                        FoldKernel.norm(pair.get("candidateRef"))));
            }
            return new StatementFold.Decision(decided.get("candidateSetRef"), alternatives,
                    deciding == null ? null : deciding.get("membership"), alignment);
        }

        /** (source end, target end, explicit outcomes or null, effective outcomes) of a FactCandidate record. */
        private Object[] declaredCandidate(Map<?, ?> candidate) {
            StatementFold.End[] ends = new StatementFold.End[2];
            String[] sides = {"source", "target"};
            for (int i = 0; i < 2; i++) {
                Map<?, ?> end = candidate.get(sides[i]) instanceof Map<?, ?> ? (Map<?, ?>) candidate.get(sides[i])
                        : Collections.emptyMap();
                if (end.containsKey("endpointRef")) {
                    ends[i] = StatementFold.End.fixed(FoldKernel.norm(end.get("endpointRef")));
                } else {
                    Map<?, ?> cset = end.get("candidateSet") instanceof Map<?, ?> ? (Map<?, ?>) end.get("candidateSet")
                            : Collections.emptyMap();
                    List<Object> list = new ArrayList<Object>();
                    if (cset.get("candidateRefs") instanceof List<?>) {
                        for (Object member : (List<?>) cset.get("candidateRefs")) {
                            if (intRef(member) != null) {
                                list.add(intRef(member));
                            }
                        }
                    }
                    // sorted with duplicates kept, as a sorted tuple keeps them
                    Collections.sort(list, FoldKernel.REF_ORDER);
                    ends[i] = StatementFold.End.set(list, cset.get("membership"), declaredDecision(cset));
                }
            }
            Set<Set<StatementFold.Pair>> explicit = null;
            if (candidate.get("outcomes") instanceof List<?>) {
                explicit = new LinkedHashSet<Set<StatementFold.Pair>>();
                for (Map<?, ?> outcome : items(candidate.get("outcomes"))) {
                    Set<StatementFold.Pair> pairs = new LinkedHashSet<StatementFold.Pair>();
                    for (Map<?, ?> pair : items(outcome.get("pairs"))) {
                        pairs.add(new StatementFold.Pair(FoldKernel.norm(pair.get("sourceRef")),
                                FoldKernel.norm(pair.get("targetRef"))));
                    }
                    explicit.add(pairs);
                }
            }
            return new Object[] {ends[0], ends[1], explicit,
                    explicit != null ? explicit : FoldKernel.impliedOutcomes(ends[0], ends[1])};
        }

        /**
         * The reference matches a FactCandidate Occurrence by kind, path, ends and outcomes; this check also matches
         * the ordinal (identity-v1, Section 5.4), so that of two FactCandidates with one subject on one path each
         * Occurrence is compared with its own result (a declared difference from the reference).
         */
        private boolean sameCandidate(Map<?, ?> occurrence, Map<?, ?> candidate, StatementFold.Candidate result) {
            if (!labelOfFact(candidate).equals(result.getLabel()) || !FoldKernel.same(occurrence.get("path"), result.getPath())
                    || !FoldKernel.same(occurrence.get("ordinal"), (long) result.getOrdinal())) {
                return false;
            }
            Object[] ends = declaredCandidate(candidate);
            return ends[0].equals(result.getSource()) && ends[1].equals(result.getTarget())
                    && (ends[2] == null) == (result.getOutcomes() == null) && ends[3].equals(result.getEffectiveOutcomes());
        }

        private void checkOccurrence(Map<?, ?> occurrence, String folded, Set<Long> support, boolean complete,
                                     StatementFold.FactOccurrence fact, StatementFold.Candidate candidate) {
            String where = "occurrences ref " + occurrence.get("ref");
            Object declared = occurrence.get("proofStatus");
            if ("ASSUMED".equals(declared) && "PROVEN".equals(folded)) {
                findings.add(new Finding("SEMANTIC_FOLD_PROOF_MISMATCH", where, "ASSUMED, the fold proves it"));
            }
            if ("PROVEN".equals(declared) && "ASSUMED".equals(folded) && complete) {
                findings.add(new Finding("SEMANTIC_FOLD_PROOF_MISMATCH", where, "PROVEN, the fold yields ASSUMED"));
            }
            Set<Object> listed = new HashSet<Object>();
            Object pathRefs = occurrence.get("supportPathRefs");
            if (pathRefs instanceof List<?>) {
                for (Object pathRef : (List<?>) pathRefs) {
                    Map<?, ?> path = index.get("supportPath", pathRef);
                    Object refs = path == null ? null : path.get("microEdgeRefs");
                    List<?> list = refs instanceof List<?> ? (List<?>) refs : Collections.emptyList();
                    if (!yields(list, occurrence, fact, candidate)) {
                        findings.add(new Finding("SEMANTIC_FOLD_BAD_SUPPORT_PATH", where,
                                "support path " + pathRef + " is not a fold walk yielding this record"));
                    }
                    for (Object r : list) {
                        listed.add(FoldKernel.norm(r));
                    }
                }
            }
            if (complete) {
                Set<Long> missing = new TreeSet<Long>();
                for (Long edge : support) {
                    if (!listed.contains(edge)) {
                        missing.add(edge);
                    }
                }
                if (!missing.isEmpty()) {
                    findings.add(new Finding("SEMANTIC_FOLD_SUPPORT_NOT_COVERED", where,
                            "micro-edges " + missing + " are not covered"));
                }
            }
        }

        /**
         * True when the listed micro-edges form a fold walk yielding the record of the Occurrence. Beyond the
         * reference's test, the walk must start at the Occurrence's own reference (its position, for a Fact) or take
         * only the references of the FactCandidate's group (fold-v1, Section 8.2, item 3; a declared difference).
         */
        private boolean yields(List<?> refs, Map<?, ?> occurrence, StatementFold.FactOccurrence expectedFact,
                               StatementFold.Candidate expectedCandidate) {
            List<Map<?, ?>> edges = new ArrayList<Map<?, ?>>();
            for (Object r : refs) {
                Map<?, ?> edge = index.get("microEdge", r);
                if (edge == null) {
                    return false;
                }
                edges.add(edge);
            }
            if (edges.isEmpty()) {
                return false;
            }
            Object statement = occurrence.get("statementRef");
            for (Map<?, ?> edge : edges) {
                if (!FoldKernel.same(edge.get("statementRef"), statement)) {
                    return false;
                }
            }
            Map<?, ?> first = edges.get(0);
            Map<?, ?> last = edges.get(edges.size() - 1);
            if (!(kernel.kept(first.get("sourceRef")) || kernel.graphCset(first.get("sourceRef")))) {
                return false;
            }
            if (!kernel.kept(last.get("targetRef"))) {
                return false;
            }
            FoldLabel label = FoldKernel.edgeLabel(first);
            FoldKernel.Sigma sigma = FoldKernel.Sigma.EMPTY;
            for (int i = 0; i < edges.size(); i++) {
                Map<?, ?> edge = edges.get(i);
                if (i > 0 && !FoldKernel.same(edge.get("sourceRef"), edges.get(i - 1).get("targetRef"))) {
                    return false;
                }
                if (i < edges.size() - 1 && !kernel.folded(edge.get("targetRef"))) {
                    return false;
                }
                if (i > 0) {
                    label = label.compose(FoldKernel.edgeLabel(edge));
                }
                sigma = sigma.extend(kernel.choices(edge));
                if (sigma == null) {
                    return false;
                }
            }
            Map<?, ?> fact = index.get("fact", occurrence.get("factRef"));
            if (fact != null) {
                return label.equals(labelOfFact(fact)) && FoldKernel.same(first.get("sourceRef"), fact.get("sourceRef"))
                        && FoldKernel.same(last.get("targetRef"), fact.get("targetRef"))
                        && FoldKernel.same(first.get("referencePath"), occurrence.get("path"))
                        && (expectedFact == null
                        || FoldKernel.same(FoldKernel.offsetOf(first.get("referenceStart")), expectedFact.getOffset()));
            }
            if (expectedCandidate != null) {
                for (Object ref : sigma.refs) {
                    if (!FoldKernel.containsRef(expectedCandidate.getReferences(), ref)) {
                        return false;
                    }
                }
            }
            Map<?, ?> candidate = index.get("factCandidate", occurrence.get("factCandidateRef"));
            if (candidate == null || sigma.isEmpty() || !label.equals(labelOfFact(candidate))) {
                return false;
            }
            Object[] ends = declaredCandidate(candidate);
            StatementFold.End targetEnd = (StatementFold.End) ends[1];
            if (kernel.graphCset(first.get("sourceRef"))) {
                List<Object> targets = targetEnd.isFixed() ? Collections.singletonList(targetEnd.getEndpointRef())
                        : targetEnd.getMembers();
                return FoldKernel.containsRef(targets, last.get("targetRef"));
            }
            StatementFold.Pair pair = new StatementFold.Pair(first.get("sourceRef"), last.get("targetRef"));
            @SuppressWarnings("unchecked")
            Set<Set<StatementFold.Pair>> effective = (Set<Set<StatementFold.Pair>>) ends[3];
            for (Set<StatementFold.Pair> outcome : effective) {
                if (outcome.contains(pair)) {
                    return true;
                }
            }
            return false;
        }

        private static final class Need {
            final Set<Object> facts = new LinkedHashSet<Object>();
            final Set<Object> candidates = new LinkedHashSet<Object>();
            final Set<StatementFold.TerminalInput> terminals = new LinkedHashSet<StatementFold.TerminalInput>();
            String bound = "COMPLETE";
            final Set<Long> diagnostics = new TreeSet<Long>();
        }

        /** Sections 7.4 and 7.5, as the reference checks them against the write records of the statement. */
        private void checkWrites(long statement, Set<List<Object>> matchedFactKeys,
                                 Map<Object, StatementFold.Candidate> candidateMatches) {
            Map<Object, List<Map<?, ?>>> out = kernel.outOf(statement);
            TreeMap<Object, Need> required = new TreeMap<Object, Need>(FoldKernel.REF_ORDER);
            for (Map<?, ?> edge : kernel.edgesOf(statement)) {
                if (kernel.isField(edge.get("targetRef"))) {
                    need(required, edge.get("targetRef"));
                }
            }
            List<Map<?, ?>> writes = new ArrayList<Map<?, ?>>();
            for (Map<?, ?> write : index.all("tfo")) {
                if (FoldKernel.same(write.get("statementRef"), statement)) {
                    writes.add(write);
                    if (kernel.isField(write.get("targetRef"))) {
                        need(required, write.get("targetRef"));
                    }
                }
            }
            for (List<Object> key : matchedFactKeys) {
                List<Long> facts = factsByProposition.get(key.subList(0, 3));
                if (kernel.isField(key.get(1))) {
                    Need need = need(required, key.get(1));
                    if (facts != null) {
                        need.facts.addAll(facts);
                    }
                }
            }
            for (Map.Entry<Object, StatementFold.Candidate> entry : candidateMatches.entrySet()) {
                Map<?, ?> occurrence = index.get("occurrence", entry.getKey());
                StatementFold.End target = entry.getValue().getTarget();
                List<Object> targets = target.isFixed() ? Collections.singletonList(target.getEndpointRef())
                        : target.getMembers();
                for (Object t : targets) {
                    if (kernel.isField(t)) {
                        Need need = need(required, t);
                        need.candidates.add(FoldKernel.norm(occurrence.get("factCandidateRef")));
                        need.bound = "PARTIAL";
                    }
                }
            }
            for (Map.Entry<Object, Set<StatementFold.TerminalInput>> entry : kernel.terminalInputs(statement, out).entrySet()) {
                need(required, entry.getKey()).terminals.addAll(entry.getValue());
            }
            // the reference also lowers through micro-edges that take two alternatives of one reference; fold-v1
            // counts walks only (a declared difference)
            Map<Object, Object[]> lowered = kernel.lowering(statement, out);
            boolean observed = kernel.observed(statement);
            for (Map.Entry<Object, Need> entry : required.entrySet()) {
                Need need = entry.getValue();
                if (observed) {
                    need.bound = FoldKernel.lower(need.bound, "PARTIAL");
                }
                if (kernel.enteredByChoice(statement, entry.getKey())) {
                    need.bound = FoldKernel.lower(need.bound, "PARTIAL"); // written only in some worlds (Section 7.4)
                }
                Object[] lowering = lowered.get(entry.getKey());
                if (lowering != null) {
                    need.bound = FoldKernel.lower(need.bound, lowering[0]);
                    @SuppressWarnings("unchecked")
                    Set<Long> diagnostics = (Set<Long>) lowering[1];
                    need.diagnostics.addAll(diagnostics);
                }
            }
            for (Map.Entry<Object, Need> entry : required.entrySet()) {
                Need need = entry.getValue();
                List<Map<?, ?>> mine = new ArrayList<Map<?, ?>>();
                for (Map<?, ?> write : writes) {
                    if (FoldKernel.same(write.get("targetRef"), entry.getKey())) {
                        mine.add(write);
                    }
                }
                if (mine.isEmpty()) {
                    findings.add(new Finding("SEMANTIC_FOLD_INPUT_MISSING", "statement ref " + statement,
                            "field ref " + entry.getKey() + " is written but has no TargetFieldOccurrence"));
                    continue;
                }
                for (Map<?, ?> write : mine) {
                    String where = "targetFieldOccurrences ref " + write.get("ref");
                    Set<Object> haveFacts = new HashSet<Object>();
                    Set<Object> haveCandidates = new HashSet<Object>();
                    Set<StatementFold.TerminalInput> haveTerminals = new HashSet<StatementFold.TerminalInput>();
                    for (Map<?, ?> input : items(write.get("inputs"))) {
                        if (input.containsKey("factRef")) {
                            haveFacts.add(FoldKernel.norm(input.get("factRef")));
                        }
                        if (input.containsKey("factCandidateRef")) {
                            haveCandidates.add(FoldKernel.norm(input.get("factCandidateRef")));
                        }
                        if (!"FIELD_REF".equals(input.get("kind"))) {
                            haveTerminals.add(FoldKernel.terminalInput(input.get("kind"), input));
                        }
                    }
                    List<Object> missing = new ArrayList<Object>();
                    for (Object fact : need.facts) {
                        if (!haveFacts.contains(fact)) {
                            missing.add(fact);
                        }
                    }
                    for (Object candidate : need.candidates) {
                        if (!haveCandidates.contains(candidate)) {
                            missing.add(candidate);
                        }
                    }
                    for (StatementFold.TerminalInput terminal : need.terminals) {
                        if (!haveTerminals.contains(terminal)) {
                            missing.add(terminal);
                        }
                    }
                    if (!missing.isEmpty()) {
                        findings.add(new Finding("SEMANTIC_FOLD_INPUT_MISSING", where, "missing inputs " + missing));
                    }
                    Set<Long> linked = new HashSet<Long>();
                    FoldKernel.addRefs(linked, write.get("diagnosticRefs"));
                    Set<Long> lowering = new TreeSet<Long>(need.diagnostics);
                    lowering.removeAll(linked);
                    if (FoldKernel.rank(write.get("upstreamCompleteness")) > FoldKernel.rank(need.bound)
                            || !lowering.isEmpty()) {
                        findings.add(new Finding("SEMANTIC_FOLD_COMPLETENESS_EXCEEDS_BOUND", where, "declared "
                                + write.get("upstreamCompleteness") + ", bound " + need.bound + ", unlinked diagnostics "
                                + lowering));
                    }
                }
            }
        }

        private static Need need(Map<Object, Need> required, Object target) {
            Object key = FoldKernel.norm(target);
            Need need = required.get(key);
            if (need == null) {
                need = new Need();
                required.put(key, need);
            }
            return need;
        }
    }
}