import { appendUnique, arrayEquals, domainDescriptions, flatMorph, groupBy, hasKey, isArray, jsTypeOfDescriptions, printable, range, throwParseError, unset } from "@ark/util";
import { compileLiteralPropAccess, compileSerializedValue } from "../shared/compile.js";
import { Disjoint } from "../shared/disjoint.js";
import { implementNode } from "../shared/implement.js";
import { intersectNodesRoot, intersectOrPipeNodes } from "../shared/intersections.js";
import { $ark, registeredReference } from "../shared/registry.js";
import { Traversal } from "../shared/traversal.js";
import { hasArkKind } from "../shared/utils.js";
import { BaseRoot } from "./root.js";
import { defineRightwardIntersections } from "./utils.js";
const implementation = implementNode({
    kind: "union",
    hasAssociatedError: true,
    collapsibleKey: "branches",
    keys: {
        ordered: {},
        branches: {
            child: true,
            parse: (schema, ctx) => {
                const branches = [];
                for (const branchSchema of schema) {
                    const branchNodes = hasArkKind(branchSchema, "root") ?
                        branchSchema.branches
                        : ctx.$.parseSchema(branchSchema).branches;
                    for (const node of branchNodes) {
                        if (node.hasKind("morph")) {
                            const matchingMorphIndex = branches.findIndex(matching => matching.hasKind("morph") && matching.hasEqualMorphs(node));
                            if (matchingMorphIndex === -1)
                                branches.push(node);
                            else {
                                const matchingMorph = branches[matchingMorphIndex];
                                branches[matchingMorphIndex] = ctx.$.node("morph", {
                                    ...matchingMorph.inner,
                                    in: matchingMorph.rawIn.rawOr(node.rawIn)
                                });
                            }
                        }
                        else
                            branches.push(node);
                    }
                }
                if (!ctx.def.ordered)
                    branches.sort((l, r) => (l.hash < r.hash ? -1 : 1));
                return branches;
            }
        }
    },
    normalize: schema => (isArray(schema) ? { branches: schema } : schema),
    reduce: (inner, $) => {
        const reducedBranches = reduceBranches(inner);
        if (reducedBranches.length === 1)
            return reducedBranches[0];
        if (reducedBranches.length === inner.branches.length)
            return;
        return $.node("union", {
            ...inner,
            branches: reducedBranches
        }, { prereduced: true });
    },
    defaults: {
        description: node => node.distribute(branch => branch.description, describeBranches),
        expected: ctx => {
            const byPath = groupBy(ctx.errors, "propString");
            const pathDescriptions = Object.entries(byPath).map(([path, errors]) => {
                const branchesAtPath = [];
                for (const errorAtPath of errors)
                    appendUnique(branchesAtPath, errorAtPath.expected);
                const expected = describeBranches(branchesAtPath);
                // if there are multiple actual descriptions that differ,
                // just fall back to printable, which is the most specific
                const actual = errors.every(e => e.actual === errors[0].actual) ?
                    errors[0].actual
                    : printable(errors[0].data);
                return `${path && `${path} `}must be ${expected}${actual && ` (was ${actual})`}`;
            });
            return describeBranches(pathDescriptions);
        },
        problem: ctx => ctx.expected,
        message: ctx => {
            if (ctx.problem[0] === "[") {
                // clarify paths like [1], [0][1], and ["key!"] that could be confusing
                return `value at ${ctx.problem}`;
            }
            return ctx.problem;
        }
    },
    intersections: {
        union: (l, r, ctx) => {
            if (l.isNever !== r.isNever) {
                // if exactly one operand is never, we can use it to discriminate based on presence
                return Disjoint.init("presence", l, r);
            }
            let resultBranches;
            if (l.ordered) {
                if (r.ordered) {
                    throwParseError(writeOrderedIntersectionMessage(l.expression, r.expression));
                }
                resultBranches = intersectBranches(r.branches, l.branches, ctx);
                if (resultBranches instanceof Disjoint)
                    resultBranches.invert();
            }
            else
                resultBranches = intersectBranches(l.branches, r.branches, ctx);
            if (resultBranches instanceof Disjoint)
                return resultBranches;
            return ctx.$.parseSchema(l.ordered || r.ordered ?
                {
                    branches: resultBranches,
                    ordered: true
                }
                : { branches: resultBranches });
        },
        ...defineRightwardIntersections("union", (l, r, ctx) => {
            const branches = intersectBranches(l.branches, [r], ctx);
            if (branches instanceof Disjoint)
                return branches;
            if (branches.length === 1)
                return branches[0];
            return ctx.$.parseSchema(l.ordered ? { branches, ordered: true } : { branches });
        })
    }
});
export class UnionNode extends BaseRoot {
    isBoolean = this.branches.length === 2 &&
        this.branches[0].hasUnit(false) &&
        this.branches[1].hasUnit(true);
    get branchGroups() {
        const branchGroups = [];
        let firstBooleanIndex = -1;
        for (const branch of this.branches) {
            if (branch.hasKind("unit") && branch.domain === "boolean") {
                if (firstBooleanIndex === -1) {
                    firstBooleanIndex = branchGroups.length;
                    branchGroups.push(branch);
                }
                else
                    branchGroups[firstBooleanIndex] = $ark.intrinsic.boolean;
                continue;
            }
            branchGroups.push(branch);
        }
        return branchGroups;
    }
    unitBranches = this.branches.filter((n) => n.rawIn.hasKind("unit"));
    discriminant = this.discriminate();
    discriminantJson = this.discriminant ? discriminantToJson(this.discriminant) : null;
    expression = this.distribute(n => n.nestableExpression, expressBranches);
    createBranchedOptimisticRootApply() {
        return (data, onFail) => {
            const optimisticResult = this.traverseOptimistic(data);
            if (optimisticResult !== unset)
                return optimisticResult;
            const ctx = new Traversal(data, this.$.resolvedConfig);
            this.traverseApply(data, ctx);
            return ctx.finalize(onFail);
        };
    }
    get shallowMorphs() {
        return this.branches.reduce((morphs, branch) => appendUnique(morphs, branch.shallowMorphs), []);
    }
    get defaultShortDescription() {
        return this.distribute(branch => branch.defaultShortDescription, describeBranches);
    }
    innerToJsonSchema(ctx) {
        // special case to simplify { const: true } | { const: false }
        // to the canonical JSON Schema representation { type: "boolean" }
        if (this.branchGroups.length === 1 &&
            this.branchGroups[0].equals($ark.intrinsic.boolean))
            return { type: "boolean" };
        const jsonSchemaBranches = this.branchGroups.map(group => group.toJsonSchemaRecurse(ctx));
        if (jsonSchemaBranches.every((branch) => 
        // iff all branches are pure unit values with no metadata,
        // we can simplify the representation to an enum
        Object.keys(branch).length === 1 && hasKey(branch, "const"))) {
            return {
                enum: jsonSchemaBranches.map(branch => branch.const)
            };
        }
        return {
            anyOf: jsonSchemaBranches
        };
    }
    traverseAllows = (data, ctx) => this.branches.some(b => b.traverseAllows(data, ctx));
    traverseApply = (data, ctx) => {
        const errors = [];
        for (let i = 0; i < this.branches.length; i++) {
            ctx.pushBranch();
            this.branches[i].traverseApply(data, ctx);
            if (!ctx.hasError()) {
                if (this.branches[i].includesTransform)
                    return ctx.queuedMorphs.push(...ctx.popBranch().queuedMorphs);
                return ctx.popBranch();
            }
            errors.push(ctx.popBranch().error);
        }
        ctx.errorFromNodeContext({ code: "union", errors, meta: this.meta });
    };
    traverseOptimistic = (data) => {
        for (let i = 0; i < this.branches.length; i++) {
            const branch = this.branches[i];
            if (branch.traverseAllows(data)) {
                if (branch.contextFreeMorph)
                    return branch.contextFreeMorph(data);
                // if we're calling this function and the matching branch didn't have
                // a context-free morph, it shouldn't have morphs at all
                return data;
            }
        }
        return unset;
    };
    compile(js) {
        if (!this.discriminant ||
            // if we have a union of two units like `boolean`, the
            // undiscriminated compilation will be just as fast
            (this.unitBranches.length === this.branches.length &&
                this.branches.length === 2))
            return this.compileIndiscriminable(js);
        // we need to access the path as optional so we don't throw if it isn't present
        let condition = this.discriminant.optionallyChainedPropString;
        if (this.discriminant.kind === "domain")
            condition = `typeof ${condition} === "object" ? ${condition} === null ? "null" : "object" : typeof ${condition} === "function" ? "object" : typeof ${condition}`;
        const cases = this.discriminant.cases;
        const caseKeys = Object.keys(cases);
        const { optimistic } = js;
        // only the first layer can be optimistic
        js.optimistic = false;
        js.block(`switch(${condition})`, () => {
            for (const k in cases) {
                const v = cases[k];
                const caseCondition = k === "default" ? k : `case ${k}`;
                let caseResult;
                if (v === true)
                    caseResult = optimistic ? "data" : "true";
                else if (optimistic) {
                    if (v.rootApplyStrategy === "branchedOptimistic")
                        caseResult = js.invoke(v, { kind: "Optimistic" });
                    else if (v.contextFreeMorph)
                        caseResult = `${js.invoke(v)} ? ${registeredReference(v.contextFreeMorph)}(data) : "${unset}"`;
                    else
                        caseResult = `${js.invoke(v)} ? data : "${unset}"`;
                }
                else
                    caseResult = js.invoke(v);
                js.line(`${caseCondition}: return ${caseResult}`);
            }
            return js;
        });
        if (js.traversalKind === "Allows") {
            js.return(optimistic ? `"${unset}"` : false);
            return;
        }
        const expected = describeBranches(this.discriminant.kind === "domain" ?
            caseKeys.map(k => {
                const jsTypeOf = k.slice(1, -1);
                return jsTypeOf === "function" ?
                    domainDescriptions.object
                    : domainDescriptions[jsTypeOf];
            })
            : caseKeys);
        const serializedPathSegments = this.discriminant.path.map(k => typeof k === "symbol" ? registeredReference(k) : JSON.stringify(k));
        const serializedExpected = JSON.stringify(expected);
        const serializedActual = this.discriminant.kind === "domain" ?
            `${serializedTypeOfDescriptions}[${condition}]`
            : `${serializedPrintable}(${condition})`;
        js.line(`ctx.errorFromNodeContext({
	code: "predicate",
	expected: ${serializedExpected},
	actual: ${serializedActual},
	relativePath: [${serializedPathSegments}],
	meta: ${this.compiledMeta}
})`);
    }
    compileIndiscriminable(js) {
        if (js.traversalKind === "Apply") {
            js.const("errors", "[]");
            for (const branch of this.branches) {
                js.line("ctx.pushBranch()")
                    .line(js.invoke(branch))
                    .if("!ctx.hasError()", () => js.return(branch.includesTransform ?
                    "ctx.queuedMorphs.push(...ctx.popBranch().queuedMorphs)"
                    : "ctx.popBranch()"))
                    .line("errors.push(ctx.popBranch().error)");
            }
            js.line(`ctx.errorFromNodeContext({ code: "union", errors, meta: ${this.compiledMeta} })`);
        }
        else {
            const { optimistic } = js;
            // only the first layer can be optimistic
            js.optimistic = false;
            for (const branch of this.branches) {
                js.if(`${js.invoke(branch)}`, () => js.return(optimistic ?
                    branch.contextFreeMorph ?
                        `${registeredReference(branch.contextFreeMorph)}(data)`
                        : "data"
                    : true));
            }
            js.return(optimistic ? `"${unset}"` : false);
        }
    }
    get nestableExpression() {
        // avoid adding unnecessary parentheses around boolean since it's
        // already collapsed to a single keyword
        return this.isBoolean ? "boolean" : `(${this.expression})`;
    }
    discriminate() {
        if (this.branches.length < 2 || this.isCyclic)
            return null;
        if (this.unitBranches.length === this.branches.length) {
            const cases = flatMorph(this.unitBranches, (i, n) => [
                `${n.rawIn.serializedValue}`,
                n.hasKind("morph") ? n : true
            ]);
            return {
                kind: "unit",
                path: [],
                optionallyChainedPropString: "data",
                cases
            };
        }
        const candidates = [];
        for (let lIndex = 0; lIndex < this.branches.length - 1; lIndex++) {
            const l = this.branches[lIndex];
            for (let rIndex = lIndex + 1; rIndex < this.branches.length; rIndex++) {
                const r = this.branches[rIndex];
                const result = intersectNodesRoot(l.rawIn, r.rawIn, l.$);
                if (!(result instanceof Disjoint))
                    continue;
                for (const entry of result) {
                    if (!entry.kind || entry.optional)
                        continue;
                    let lSerialized;
                    let rSerialized;
                    if (entry.kind === "domain") {
                        const lValue = entry.l;
                        const rValue = entry.r;
                        lSerialized = `"${typeof lValue === "string" ? lValue : lValue.domain}"`;
                        rSerialized = `"${typeof rValue === "string" ? rValue : rValue.domain}"`;
                    }
                    else if (entry.kind === "unit") {
                        lSerialized = entry.l.serializedValue;
                        rSerialized = entry.r.serializedValue;
                    }
                    else
                        continue;
                    const matching = candidates.find(d => arrayEquals(d.path, entry.path) && d.kind === entry.kind);
                    if (!matching) {
                        candidates.push({
                            kind: entry.kind,
                            cases: {
                                [lSerialized]: {
                                    branchIndices: [lIndex],
                                    condition: entry.l
                                },
                                [rSerialized]: {
                                    branchIndices: [rIndex],
                                    condition: entry.r
                                }
                            },
                            path: entry.path
                        });
                    }
                    else {
                        if (matching.cases[lSerialized]) {
                            matching.cases[lSerialized].branchIndices = appendUnique(matching.cases[lSerialized].branchIndices, lIndex);
                        }
                        else {
                            matching.cases[lSerialized] ??= {
                                branchIndices: [lIndex],
                                condition: entry.l
                            };
                        }
                        if (matching.cases[rSerialized]) {
                            matching.cases[rSerialized].branchIndices = appendUnique(matching.cases[rSerialized].branchIndices, rIndex);
                        }
                        else {
                            matching.cases[rSerialized] ??= {
                                branchIndices: [rIndex],
                                condition: entry.r
                            };
                        }
                    }
                }
            }
        }
        const viableCandidates = this.ordered ?
            viableOrderedCandidates(candidates, this.branches)
            : candidates;
        if (!viableCandidates.length)
            return null;
        const ctx = createCaseResolutionContext(viableCandidates, this);
        const cases = {};
        for (const k in ctx.best.cases) {
            const resolution = resolveCase(ctx, k);
            if (resolution === null) {
                cases[k] = true;
                continue;
            }
            // if all the branches ended up back in pruned, we'd loop if we continued
            // so just bail out- nothing left to discriminate
            if (resolution.length === this.branches.length)
                return null;
            if (this.ordered) {
                // ensure the original order of the pruned branches is preserved
                resolution.sort((l, r) => l.originalIndex - r.originalIndex);
            }
            const branches = resolution.map(entry => entry.branch);
            const caseNode = branches.length === 1 ?
                branches[0]
                : this.$.node("union", this.ordered ? { branches, ordered: true } : branches);
            Object.assign(this.referencesById, caseNode.referencesById);
            cases[k] = caseNode;
        }
        if (ctx.defaultEntries.length) {
            // we don't have to worry about order here as it is always preserved
            // within defaultEntries
            const branches = ctx.defaultEntries.map(entry => entry.branch);
            cases.default = this.$.node("union", this.ordered ? { branches, ordered: true } : branches, {
                prereduced: true
            });
            Object.assign(this.referencesById, cases.default.referencesById);
        }
        return Object.assign(ctx.location, {
            cases
        });
    }
}
const createCaseResolutionContext = (viableCandidates, node) => {
    const ordered = viableCandidates.sort((l, r) => l.path.length === r.path.length ?
        Object.keys(r.cases).length - Object.keys(l.cases).length
        // prefer shorter paths first
        : l.path.length - r.path.length);
    const best = ordered[0];
    const location = {
        kind: best.kind,
        path: best.path,
        optionallyChainedPropString: optionallyChainPropString(best.path)
    };
    const defaultEntries = node.branches.map((branch, originalIndex) => ({
        originalIndex,
        branch
    }));
    return {
        best,
        location,
        defaultEntries,
        node
    };
};
const resolveCase = (ctx, key) => {
    const caseCtx = ctx.best.cases[key];
    const discriminantNode = discriminantCaseToNode(caseCtx.condition, ctx.location.path, ctx.node.$);
    let resolvedEntries = [];
    const nextDefaults = [];
    for (let i = 0; i < ctx.defaultEntries.length; i++) {
        const entry = ctx.defaultEntries[i];
        if (caseCtx.branchIndices.includes(entry.originalIndex)) {
            const pruned = pruneDiscriminant(ctx.node.branches[entry.originalIndex], ctx.location);
            if (pruned === null) {
                // if any branch of the union has no constraints (i.e. is
                // unknown), the others won't affect the resolution type, but could still
                // remove additional cases from defaultEntries
                resolvedEntries = null;
            }
            else {
                resolvedEntries?.push({
                    originalIndex: entry.originalIndex,
                    branch: pruned
                });
            }
        }
        else if (
        // we shouldn't need a special case for alias to avoid the below
        // once alias resolution issues are improved:
        // https://github.com/arktypeio/arktype/issues/1026
        entry.branch.hasKind("alias") &&
            discriminantNode.hasKind("domain") &&
            discriminantNode.domain === "object")
            resolvedEntries?.push(entry);
        else {
            if (entry.branch.rawIn.overlaps(discriminantNode)) {
                // include cases where an object not including the
                // discriminant path might have that value present as an undeclared key
                const overlapping = pruneDiscriminant(entry.branch, ctx.location);
                resolvedEntries?.push({
                    originalIndex: entry.originalIndex,
                    branch: overlapping
                });
            }
            nextDefaults.push(entry);
        }
    }
    ctx.defaultEntries = nextDefaults;
    return resolvedEntries;
};
const viableOrderedCandidates = (candidates, originalBranches) => {
    const viableCandidates = candidates.filter(candidate => {
        const caseGroups = Object.values(candidate.cases).map(caseCtx => caseCtx.branchIndices);
        // compare each group against all subsequent groups.
        for (let i = 0; i < caseGroups.length - 1; i++) {
            const currentGroup = caseGroups[i];
            for (let j = i + 1; j < caseGroups.length; j++) {
                const nextGroup = caseGroups[j];
                // for each group pair, check for branches whose order was reversed
                for (const currentIndex of currentGroup) {
                    for (const nextIndex of nextGroup) {
                        if (currentIndex > nextIndex) {
                            if (originalBranches[currentIndex].overlaps(originalBranches[nextIndex])) {
                                // if the order was not preserved and the branches overlap,
                                // this is not a viable discriminant as it cannot guarantee the same behavior
                                return false;
                            }
                        }
                    }
                }
            }
        }
        // branch groups preserved order for non-disjoint pairs and is viable
        return true;
    });
    return viableCandidates;
};
const discriminantCaseToNode = (caseDiscriminant, path, $) => {
    let node = caseDiscriminant === "undefined" ? $.node("unit", { unit: undefined })
        : caseDiscriminant === "null" ? $.node("unit", { unit: null })
            : caseDiscriminant === "boolean" ? $.units([true, false])
                : caseDiscriminant;
    for (let i = path.length - 1; i >= 0; i--) {
        const key = path[i];
        node = $.node("intersection", typeof key === "number" ?
            {
                proto: "Array",
                // create unknown for preceding elements (could be optimized with safe imports)
                sequence: [...range(key).map(_ => ({})), node]
            }
            : {
                domain: "object",
                required: [{ key, value: node }]
            });
    }
    return node;
};
const optionallyChainPropString = (path) => path.reduce((acc, k) => acc + compileLiteralPropAccess(k, true), "data");
const serializedTypeOfDescriptions = registeredReference(jsTypeOfDescriptions);
const serializedPrintable = registeredReference(printable);
export const Union = {
    implementation,
    Node: UnionNode
};
const discriminantToJson = (discriminant) => ({
    kind: discriminant.kind,
    path: discriminant.path.map(k => typeof k === "string" ? k : compileSerializedValue(k)),
    cases: flatMorph(discriminant.cases, (k, node) => [
        k,
        node === true ? node
            : node.hasKind("union") && node.discriminantJson ? node.discriminantJson
                : node.json
    ])
});
const describeExpressionOptions = {
    delimiter: " | ",
    finalDelimiter: " | "
};
const expressBranches = (expressions) => describeBranches(expressions, describeExpressionOptions);
export const describeBranches = (descriptions, opts) => {
    const delimiter = opts?.delimiter ?? ", ";
    const finalDelimiter = opts?.finalDelimiter ?? " or ";
    if (descriptions.length === 0)
        return "never";
    if (descriptions.length === 1)
        return descriptions[0];
    if ((descriptions.length === 2 &&
        descriptions[0] === "false" &&
        descriptions[1] === "true") ||
        (descriptions[0] === "true" && descriptions[1] === "false"))
        return "boolean";
    // keep track of seen descriptions to avoid duplication
    const seen = {};
    const unique = descriptions.filter(s => (seen[s] ? false : (seen[s] = true)));
    const last = unique.pop();
    return `${unique.join(delimiter)}${unique.length ? finalDelimiter : ""}${last}`;
};
export const intersectBranches = (l, r, ctx) => {
    // If the corresponding r branch is identified as a subtype of an l branch, the
    // value at rIndex is set to null so we can avoid including previous/future
    // intersections in the reduced result.
    const batchesByR = r.map(() => []);
    for (let lIndex = 0; lIndex < l.length; lIndex++) {
        let candidatesByR = {};
        for (let rIndex = 0; rIndex < r.length; rIndex++) {
            if (batchesByR[rIndex] === null) {
                // rBranch is a subtype of an lBranch and
                // will not yield any distinct intersection
                continue;
            }
            if (l[lIndex].equals(r[rIndex])) {
                // Combination of subtype and supertype cases
                batchesByR[rIndex] = null;
                candidatesByR = {};
                break;
            }
            const branchIntersection = intersectOrPipeNodes(l[lIndex], r[rIndex], ctx);
            if (branchIntersection instanceof Disjoint) {
                // Doesn't tell us anything useful about their relationships
                // with other branches
                continue;
            }
            if (branchIntersection.equals(l[lIndex])) {
                // If the current l branch is a subtype of r, intersections
                // with previous and remaining branches of r won't lead to
                // distinct intersections.
                batchesByR[rIndex].push(l[lIndex]);
                candidatesByR = {};
                break;
            }
            if (branchIntersection.equals(r[rIndex])) {
                // If the current r branch is a subtype of l, set its batch to
                // null, removing any previous intersections and preventing any
                // of its remaining intersections from being computed.
                batchesByR[rIndex] = null;
            }
            else {
                // If neither l nor r is a subtype of the other, add their
                // intersection as a candidate (could still be removed if it is
                // determined l or r is a subtype of a remaining branch).
                candidatesByR[rIndex] = branchIntersection;
            }
        }
        for (const rIndex in candidatesByR) {
            // batchesByR at rIndex should never be null if it is in candidatesByR
            batchesByR[rIndex][lIndex] = candidatesByR[rIndex];
        }
    }
    // Compile the reduced intersection result, including:
    // 		1. Remaining candidates resulting from distinct intersections or strict subtypes of r
    // 		2. Original r branches corresponding to indices with a null batch (subtypes of l)
    const resultBranches = batchesByR.flatMap(
    // ensure unions returned from branchable intersections like sequence are flattened
    (batch, i) => batch?.flatMap(branch => branch.branches) ?? r[i]);
    return resultBranches.length === 0 ?
        Disjoint.init("union", l, r)
        : resultBranches;
};
export const reduceBranches = ({ branches, ordered }) => {
    if (branches.length < 2)
        return branches;
    const uniquenessByIndex = branches.map(() => true);
    for (let i = 0; i < branches.length; i++) {
        for (let j = i + 1; j < branches.length && uniquenessByIndex[i] && uniquenessByIndex[j]; j++) {
            if (branches[i].equals(branches[j])) {
                // if the two branches are equal, only "j" is marked as
                // redundant so at least one copy could still be included in
                // the final set of branches.
                uniquenessByIndex[j] = false;
                continue;
            }
            const intersection = intersectNodesRoot(branches[i].rawIn, branches[j].rawIn, branches[0].$);
            if (intersection instanceof Disjoint)
                continue;
            if (!ordered)
                assertDeterminateOverlap(branches[i], branches[j]);
            if (intersection.equals(branches[i].rawIn)) {
                // preserve ordered branches that are a subtype of a subsequent branch
                uniquenessByIndex[i] = !!ordered;
            }
            else if (intersection.equals(branches[j].rawIn))
                uniquenessByIndex[j] = false;
        }
    }
    return branches.filter((_, i) => uniquenessByIndex[i]);
};
const assertDeterminateOverlap = (l, r) => {
    if (!l.includesTransform && !r.includesTransform)
        return;
    if (!arrayEquals(l.shallowMorphs, r.shallowMorphs)) {
        throwParseError(writeIndiscriminableMorphMessage(l.expression, r.expression));
    }
    if (!arrayEquals(l.flatMorphs, r.flatMorphs, {
        isEqual: (l, r) => l.propString === r.propString &&
            (l.node.hasKind("morph") && r.node.hasKind("morph") ?
                l.node.hasEqualMorphs(r.node)
                : l.node.hasKind("intersection") && r.node.hasKind("intersection") ?
                    l.node.structure?.structuralMorphRef ===
                        r.node.structure?.structuralMorphRef
                    : false)
    })) {
        throwParseError(writeIndiscriminableMorphMessage(l.expression, r.expression));
    }
};
export const pruneDiscriminant = (discriminantBranch, discriminantCtx) => discriminantBranch.transform((nodeKind, inner) => {
    if (nodeKind === "domain" || nodeKind === "unit")
        return null;
    return inner;
}, {
    shouldTransform: (node, ctx) => {
        // safe to cast here as index nodes are never discriminants
        const propString = optionallyChainPropString(ctx.path);
        if (!discriminantCtx.optionallyChainedPropString.startsWith(propString))
            return false;
        if (node.hasKind("domain") && node.domain === "object")
            // if we've already checked a path at least as long as the current one,
            // we don't need to revalidate that we're in an object
            return true;
        if ((node.hasKind("domain") || discriminantCtx.kind === "unit") &&
            propString === discriminantCtx.optionallyChainedPropString)
            // if the discriminant has already checked the domain at the current path
            // (or a unit literal, implying a domain), we don't need to recheck it
            return true;
        // we don't need to recurse into index nodes as they will never
        // have a required path therefore can't be used to discriminate
        return node.children.length !== 0 && node.kind !== "index";
    }
});
export const writeIndiscriminableMorphMessage = (lDescription, rDescription) => `An unordered union of a type including a morph and a type with overlapping input is indeterminate:
Left: ${lDescription}
Right: ${rDescription}`;
export const writeOrderedIntersectionMessage = (lDescription, rDescription) => `The intersection of two ordered unions is indeterminate:
Left: ${lDescription}
Right: ${rDescription}`;