package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.dlineage.util.DlineageUtil;

/**
 * Matches the star links and model columns of a relation's sources against one star link of its target, the link a
 * star expansion is publishing. Obtained from {@link Column#starLinkMatcher(int)} once per expansion, it decides the
 * matches the analyzer used to decide on the target link's folded display, with the same comparisons: a target link
 * matches a source link or model column under {@link DlineageUtil#sameColumnNormalName}, and is named by a model
 * column whose folded name equals its own folded display.
 *
 * <p>Internal contract of the lineage analyzer.
 */
public final class StarLinkMatcher {

        private final String foldedDisplay;

        private final StarLinkKey key;

        StarLinkMatcher(String foldedDisplay, StarLinkKey key) {
                this.foldedDisplay = foldedDisplay;
                this.key = key;
        }

        /** Whether the star link at {@code ordinal} of {@code source} is this link's column. */
        public boolean matches(Column source, int ordinal) {
                if (StarLinkStore.IDENTITY) {
                        Object other = source.starLinkKey(ordinal);
                        if (other instanceof StarLinkKey && StarLinkStore.identifiers(key, (StarLinkKey) other)) {
                                return decided("matches", key.equals(other), source.starLinkDisplay(ordinal));
                        }
                }
                return DlineageUtil.sameColumnNormalName(foldedDisplay, source.starLinkDisplay(ordinal));
        }

        /** Whether {@code model} is this link's column, compared as the analyzer compared a model name. */
        public boolean matchesColumn(Column model) {
                if (StarLinkStore.IDENTITY) {
                        StarLinkKey other = StarLinkStore.modelKey(model);
                        if (StarLinkStore.identifiers(key, other)) {
                                return decided("matchesColumn", key.equals(other), model.getName());
                        }
                }
                return DlineageUtil.sameColumnNormalName(foldedDisplay, StarLinkStore.legacyFold(model.getName()));
        }

        /** Whether {@code model} carries exactly this link's name. */
        public boolean isNamedBy(Column model) {
                if (StarLinkStore.IDENTITY) {
                        StarLinkKey other = StarLinkStore.modelKey(model);
                        if (StarLinkStore.identifiers(key, other)) {
                                return decided("isNamedBy", key.equals(other), model.getName());
                        }
                }
                return StarLinkStore.legacyFold(model.getName()).equals(foldedDisplay);
        }

        /**
         * Whether the star links of {@code source} hold another identity's column under this link's folded display: a
         * column the grouping by display would take for this link's, and which, grouped by identity, is a different
         * column (PostgreSQL {@code "Amount"} where this link is {@code amount}). A star that holds it is not inferred to
         * hold this link's column as well; false while links are grouped by display, and for a label.
         */
        public boolean isDisplacedIn(Column source) {
                if (!StarLinkStore.IDENTITY || key == null || !key.isIdentifier() || source == null) {
                        return false;
                }
                for (int k = 0; k < source.starLinkCount(); k++) {
                        Object other = source.starLinkKey(k);
                        if (other instanceof StarLinkKey && ((StarLinkKey) other).isIdentifier() && !key.equals(other)
                                        && DlineageUtil.sameColumnNormalName(foldedDisplay, source.starLinkDisplay(k))) {
                                return true;
                        }
                }
                return false;
        }

        /**
         * The key this link is remembered by among the target links that already have an explicit source. A source link
         * is looked up in that set by {@link Column#starLinkKey(int)}.
         */
        public Object key() {
                return StarLinkStore.IDENTITY && key != null ? key : foldedDisplay;
        }

        String foldedDisplay() {
                return foldedDisplay;
        }

        StarLinkKey identity() {
                return key;
        }

        /** Reports an identity answer that the legacy comparison disputes; the legacy comparison runs for the census only. */
        private boolean decided(String predicate, boolean identity, String other) {
                if (StarLinkStore.censusOn()) {
                        boolean answer = "matches".equals(predicate) ? DlineageUtil.sameColumnNormalName(foldedDisplay, other)
                                        : "isNamedBy".equals(predicate) ? other != null && foldedDisplay.equals(StarLinkStore.legacyFold(other))
                                        : DlineageUtil.sameColumnNormalName(foldedDisplay, StarLinkStore.legacyFold(other));
                        if (identity != answer) {
                                StarLinkStore.census("PREDICATE_DIFF " + predicate, foldedDisplay + " ~ " + other);
                        }
                }
                return identity;
        }
}