package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.EFunctionType;
import gudusoft.gsqlparser.ESetOperatorType;
import gudusoft.gsqlparser.nodes.TCaseExpression;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TMergeInsertClause;
import gudusoft.gsqlparser.nodes.TMergeUpdateClause;
import gudusoft.gsqlparser.nodes.TOutputClause;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.stmt.TInsertSqlStatement;
import gudusoft.gsqlparser.stmt.TUpdateSqlStatement;

/**
 * The kind of a runtime result set, as a pure function of its runtime class, the parse tree node it is attached to
 * and its explicit descriptors (plan {@code docs/designs/data-lineage/09-sqllr-v2-runtime-driven-coverage-plan-zh.md},
 * Section 3.2).
 *
 * <p>{@code DataFlowAnalyzer.getResultSetName} decides the same kinds in the same branch order, but it also names the
 * result set: it allocates display counters ({@code DISPLAY_ID}), fills the name cache ({@code DISPLAY_NAME}) and
 * sets the target flag from the display options. That method stays as it is, for the legacy output. The SQL-LR
 * producer classifies with this class only: it allocates nothing, caches nothing, never sets a flag and never
 * resolves a name, so classifying cannot change a legacy byte or a display number.</p>
 *
 * <p>Internal API of the SQL-LR producer.</p>
 *
 * @since 4.2.17
 */
public final class ResultSetClassifier {

    /** The kinds, in the order {@code getResultSetName} tests them. */
    public enum Kind {
        /** An ARRAY(...) constructor ({@code ARRAY-n}). */
        ARRAY,
        /** A STRUCT(...) constructor ({@code STRUCT-n}). */
        STRUCT,
        /** An aliased query table ({@code RESULT_OF_<alias>-n}). */
        QUERY_TABLE_ALIAS,
        /** An aliased reference to a CTE ({@code RESULT_OF_<cte>_<alias>-n}). */
        CTE_ALIAS,
        /** An unaliased reference to a CTE ({@code CTE-<cte>-n}). */
        CTE,
        /** The SELECT of an INSERT ... SELECT ({@code INSERT-SELECT-n}). */
        INSERT_SELECT,
        /** The SELECT of an UPDATE ({@code UPDATE-SELECT-n}). */
        UPDATE_SELECT,
        /** A set operation ({@code RESULT_OF_<OPERATOR>-n}); see {@link Result#getSetOperator()}. */
        SET_OPERATION,
        /** The WHEN MATCHED UPDATE of a MERGE ({@code MERGE-UPDATE-n}). */
        MERGE_UPDATE,
        /** An OUTPUT clause ({@code OUTPUT-n}). */
        OUTPUT,
        /** The WHEN NOT MATCHED INSERT of a MERGE ({@code MERGE-INSERT-n}). */
        MERGE_INSERT,
        /** The SET of an UPDATE ({@code UPDATE-SET-n}). */
        UPDATE_SET,
        /** A CASE expression (named after the function). */
        CASE,
        /** A function call (named after the function). */
        FUNCTION,
        /** A PIVOT ({@code PIVOT-TABLE-n}). */
        PIVOT,
        /** An UNPIVOT ({@code UNPIVOT-TABLE-n}). */
        UNPIVOT,
        /** An alias result set ({@code ALIAS-n}). */
        ALIAS,
        /** Any other result set: a select list ({@code RS-n}). */
        SELECT_LIST
    }

    /** A classification: the kind and the descriptors that refine it. Plain values. */
    public static final class Result {
        private final Kind kind;
        private final ESetOperatorType setOperator;

        Result(Kind kind, ESetOperatorType setOperator) {
            this.kind = kind;
            this.setOperator = setOperator;
        }

        public Kind getKind() {
            return kind;
        }

        /** The operator of a {@link Kind#SET_OPERATION}, else {@code null}. */
        public ESetOperatorType getSetOperator() {
            return setOperator;
        }

        @Override
        public String toString() {
            return setOperator == null ? kind.name() : kind.name() + "(" + setOperator.name() + ")";
        }
    }

    private ResultSetClassifier() {
    }

    /** Classifies a result set; reads only, in {@code getResultSetName}'s branch order. */
    public static Result classify(ResultSet rs) {
        TParseTreeNode gsp = rs.getGspObject();
        // the parsed type, never getFunctionType(): its lookup of an unknown type caches a built-in check on the node,
        // and the lookup never answers array_t or struct_t, so the kind is the same (Codex review of slice 1a, #4)
        if (gsp instanceof TFunctionCall && ((TFunctionCall) gsp).getParsedFunctionType() == EFunctionType.array_t) {
            return new Result(Kind.ARRAY, null);
        }
        if (gsp instanceof TFunctionCall && ((TFunctionCall) gsp).getParsedFunctionType() == EFunctionType.struct_t) {
            return new Result(Kind.STRUCT, null);
        }
        if (rs instanceof QueryTable) {
            QueryTable table = (QueryTable) rs;
            boolean cte = table.getTableObject().getCTE() != null;
            if (table.getAlias() != null && table.getAlias().trim().length() > 0) {
                return new Result(cte ? Kind.CTE_ALIAS : Kind.QUERY_TABLE_ALIAS, null);
            }
            if (cte) {
                return new Result(Kind.CTE, null);
            }
        }
        if (rs instanceof SelectResultSet) {
            Object parent = ((SelectResultSet) rs).getSelectStmt().getParentStmt();
            if (parent instanceof TInsertSqlStatement) {
                return new Result(Kind.INSERT_SELECT, null);
            }
            if (parent instanceof TUpdateSqlStatement) {
                return new Result(Kind.UPDATE_SELECT, null);
            }
        }
        if (rs instanceof SelectSetResultSet) {
            return new Result(Kind.SET_OPERATION, ((SelectSetResultSet) rs).getSetOperatorType());
        }
        if (gsp instanceof TMergeUpdateClause) {
            return new Result(Kind.MERGE_UPDATE, null);
        }
        if (gsp instanceof TOutputClause) {
            return new Result(Kind.OUTPUT, null);
        }
        if (gsp instanceof TMergeInsertClause) {
            return new Result(Kind.MERGE_INSERT, null);
        }
        if (gsp instanceof TUpdateSqlStatement) {
            return new Result(Kind.UPDATE_SET, null);
        }
        if (gsp instanceof TCaseExpression) {
            return new Result(Kind.CASE, null);
        }
        if (gsp instanceof TFunctionCall || rs instanceof Function) {
            return new Result(Kind.FUNCTION, null);
        }
        if (rs instanceof PivotedTable) {
            return new Result(((PivotedTable) rs).isUnpivoted() ? Kind.UNPIVOT : Kind.PIVOT, null);
        }
        if (rs instanceof Alias) {
            return new Result(Kind.ALIAS, null);
        }
        return new Result(Kind.SELECT_LIST, null);
    }
}