package gudusoft.gsqlparser.dlineage.routine;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EParameterMode;
import gudusoft.gsqlparser.catalog.runtime.CatalogLookupName;
import gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind;
import gudusoft.gsqlparser.nodes.TParameterDeclaration;
import gudusoft.gsqlparser.nodes.TParameterDeclarationList;
import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierService;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

/**
 * One declared routine: its name as written (one interpretation), its kind, its parameters, and the scope it
 * is declared in when it is local to another routine.
 *
 * <p>Its {@link #identity() identity} is the routine it declares: the name's keys, the namespace it lives in,
 * and the parameters as far as the vendor tells routines of one name apart by them ({@link Signature}). Two
 * declarations with one identity are one routine declared twice ({@code CREATE OR REPLACE}, a package
 * specification and its body); where the vendor overloads, a same-named declaration with other parameters is
 * another routine. Parameter counts are only lookup aliases: a call supplies arguments, not types, and matches
 * a declaration when the number of arguments lies between its required inputs and its inputs, or equals its
 * parameter count.</p>
 */
public final class RoutineDeclaration {

    /** How much of its parameter list a vendor identifies a routine by. */
    public enum Signature {
        /** The name alone: the vendor does not overload (SQL Server, MySQL, BigQuery, HANA, ...), or a standalone
         *  Oracle routine, which CREATE OR REPLACE replaces whatever its parameters. */
        NAME_ONLY,
        /** The number of parameters (DB2 procedures). */
        COUNT,
        /** The types of the input parameters (PostgreSQL and its family: OUT parameters are not part of it). */
        INPUT_TYPES,
        /** The types of all parameters (DB2 functions, Snowflake, Teradata functions). */
        TYPES,
        /** Kind, parameter names, modes and types: an Oracle package member or local routine, matched between a
         *  specification and its body as Oracle matches it. */
        NAMED_TYPES
    }

    /** The signature a vendor identifies a routine of this kind by. */
    public static Signature signatureOf(EDbVendor vendor, CatalogObjectKind kind, boolean memberOrLocal) {
        switch (vendor) {
        case dbvoracle:
        case dbvdameng:
            return memberOrLocal ? Signature.NAMED_TYPES : Signature.NAME_ONLY;
        case dbvpostgresql:
        case dbvgreenplum:
        case dbvedb:
        case dbvgaussdb:
        case dbvredshift:
            return Signature.INPUT_TYPES;
        case dbvdb2:
            return kind == CatalogObjectKind.PROCEDURE ? Signature.COUNT : Signature.TYPES;
        case dbvsnowflake:
            return Signature.TYPES;
        case dbvteradata:
            return kind == CatalogObjectKind.FUNCTION ? Signature.TYPES : Signature.NAME_ONLY;
        default:
            return Signature.NAME_ONLY;
        }
    }

    /** Whether the vendor tells routines of this kind apart by their parameters (their identity is not the name alone). */
    public static boolean identityOverloads(EDbVendor vendor, CatalogObjectKind kind, boolean memberOrLocal) {
        return signatureOf(vendor, kind, memberOrLocal) != Signature.NAME_ONLY;
    }

    /**
     * Whether declarations of this kind are keyed with their argument counts, so a call is looked up by its
     * argument count: where the vendor overloads routines of the kind, and wherever the legacy registry keyed them
     * so (standalone Oracle routines, MySQL, HANA). A count alias on a routine alone under its name finds nothing it
     * should not; the identity stays the name alone.
     */
    public static boolean usesCountAliases(EDbVendor vendor, CatalogObjectKind kind, boolean memberOrLocal) {
        return identityOverloads(vendor, kind, memberOrLocal)
                || gudusoft.gsqlparser.dlineage.util.DlineageUtil.supportFunctionOverride(vendor);
    }

    /** Whether a call site keys its lookup with the argument count: some routine of the vendor uses count aliases. */
    public static boolean callsCounted(EDbVendor vendor) {
        return usesCountAliases(vendor, CatalogObjectKind.FUNCTION, true)
                || usesCountAliases(vendor, CatalogObjectKind.PROCEDURE, true);
    }

    /** The namespace a kind lives in: one for functions and procedures (as today), except where the vendor
     *  keeps them apart (DB2); triggers apart everywhere. */
    static CatalogObjectKind namespaceOf(EDbVendor vendor, CatalogObjectKind kind) {
        if (kind == CatalogObjectKind.TRIGGER) {
            return CatalogObjectKind.TRIGGER;
        }
        if (vendor == EDbVendor.dbvdb2 && (kind == CatalogObjectKind.FUNCTION || kind == CatalogObjectKind.PROCEDURE)) {
            return kind;
        }
        return CatalogObjectKind.ROUTINE;
    }

    private final Object origin;
    private Object representative;
    private final RoutineName name;
    private final CatalogObjectKind namespace;
    private final List<ArgumentTypeKey> types;
    private final int totalCount;
    private final int inputCount;
    private final int requiredCount;
    private final boolean unboundedInputs;
    private final boolean signatureAliases;
    private final Identity identity;

    RoutineDeclaration(Object origin, RoutineName name, CatalogObjectKind namespace, List<ArgumentTypeKey> types,
            int totalCount, int inputCount, int requiredCount, boolean unboundedInputs, boolean signatureAliases,
            Identity identity) {
        this.origin = origin;
        this.representative = origin;
        this.name = name;
        this.namespace = namespace;
        this.types = types == null ? null : Collections.unmodifiableList(types);
        this.totalCount = totalCount;
        this.inputCount = inputCount;
        this.requiredCount = requiredCount;
        this.unboundedInputs = unboundedInputs;
        this.signatureAliases = signatureAliases;
        this.identity = identity;
    }

    /**
     * A declaration from its AST: {@code scope} the routine it is local to (null for a top-level or package
     * routine). A statement with no parameter list ({@code parameters} null: Oracle {@code CREATE PROCEDURE p IS},
     * DB2 {@code CREATE FUNCTION f ()}) declares a routine with no parameters.
     */
    public static RoutineDeclaration of(Object origin, RoutineName name, TParameterDeclarationList parameters,
            Object scope, EDbVendor vendor, IdentifierService service) {
        boolean memberOrLocal = name.isPackageMember() || scope != null;
        int size = parameters == null ? 0 : parameters.size();
        List<ArgumentTypeKey> types = new ArrayList<ArgumentTypeKey>(size);
        List<EParameterMode> modes = new ArrayList<EParameterMode>(size);
        List<Object> parameterNames = new ArrayList<Object>(size);
        List<ArgumentTypeKey> inputTypes = new ArrayList<ArgumentTypeKey>(size);
        int total = size;
        int inputs = 0;
        int required = 0;
        boolean unbounded = false;
        if (parameters != null) {
            for (int i = 0; i < parameters.size(); i++) {
                TParameterDeclaration parameter = parameters.getParameterDeclarationItem(i);
                ArgumentTypeKey type = ArgumentTypeKey.of(parameter.getDataType(), vendor, service);
                EParameterMode mode = parameter.getParameterMode();
                types.add(type);
                modes.add(mode);
                parameterNames.add(parameterKey(parameter, service));
                if (mode != EParameterMode.out && mode != EParameterMode.output) {
                    // IN, INOUT, VARIADIC, or no mode written (IN).
                    inputs++;
                    inputTypes.add(type);
                    if (mode == EParameterMode.variadic) {
                        // Any number of arguments, none included.
                        unbounded = true;
                    } else if (parameter.getDefaultValue() == null) {
                        required++;
                    }
                }
            }
        }
        Signature signature = signatureOf(vendor, name.getKind(), memberOrLocal);
        Object key;
        switch (signature) {
        case COUNT:
            key = Integer.valueOf(total);
            break;
        case INPUT_TYPES:
            key = inputTypes;
            break;
        case TYPES:
            key = types;
            break;
        case NAMED_TYPES:
            key = Arrays.asList(name.getKind(), types, modes, parameterNames);
            break;
        default:
            key = null;
        }
        CatalogObjectKind namespace = namespaceOf(vendor, name.getKind());
        return new RoutineDeclaration(origin, name, namespace, types, total, inputs, required, unbounded,
                usesCountAliases(vendor, name.getKind(), memberOrLocal),
                new Identity(name, namespace, scope, key));
    }

    /** {@link #of(Object, RoutineName, TParameterDeclarationList, Object, EDbVendor, IdentifierService)} for a
     *  top-level routine; {@code model} is not kept (the typed registry holds declarations, not legacy models). */
    public static RoutineDeclaration of(Object model, Object origin, RoutineName name, TParameterDeclarationList parameters,
            EDbVendor vendor, IdentifierService service) {
        return of(origin, name, parameters, null, vendor, service);
    }

    private static Object parameterKey(TParameterDeclaration parameter, IdentifierService service) {
        if (parameter.getParameterName() == null) {
            return "";
        }
        String text = parameter.getParameterName().toString();
        try {
            return service.canonKeyOf(text, ESQLDataObjectType.dotParameter, IdentifierInputForm.SQL_LEXICAL);
        } catch (IllegalArgumentException notKeyable) {
            return text;
        }
    }

    /** A routine known only from a call or an EXEC of a module never defined here: a name and a count. */
    public static RoutineDeclaration ofCall(Object origin, RoutineName name, Integer argumentCount, EDbVendor vendor) {
        int count = argumentCount == null ? 0 : argumentCount;
        CatalogObjectKind namespace = namespaceOf(vendor, name.getKind());
        return new RoutineDeclaration(origin, name, namespace, null, count, count, count, false, argumentCount != null,
                new Identity(name, namespace, null, argumentCount));
    }

    /** The statement or node this occurrence was declared by. */
    public Object getOrigin() {
        return origin;
    }

    /** The first occurrence of this declaration's identity: the one a later occurrence replaced keeps its place. */
    public Object getRepresentative() {
        return representative;
    }

    void setRepresentative(Object representative) {
        this.representative = representative;
    }

    public RoutineName getName() {
        return name;
    }

    public CatalogObjectKind getNamespace() {
        return namespace;
    }

    public List<ArgumentTypeKey> getTypes() {
        return types;
    }

    public int getTotalCount() {
        return totalCount;
    }

    /** Whether the declaration is keyed with its signature (a lookup by name only reaches it by the fallback). */
    public boolean hasSignatureAliases() {
        return signatureAliases;
    }

    /**
     * Whether a call with {@code count} arguments can be this routine: any count for a routine keyed by its name
     * alone, else its parameter count, or a count from its required inputs up to its inputs (no upper bound with a
     * VARIADIC parameter).
     */
    public boolean acceptsCount(int count) {
        return !signatureAliases || count == totalCount
                || (count >= requiredCount && (unboundedInputs || count <= inputCount));
    }

    public Identity identity() {
        return identity;
    }

    /** The identity of a declared routine. */
    public static final class Identity {
        private final List<Object> containers;
        private final CanonKey terminal;
        private final CatalogObjectKind namespace;
        private final Object scope;
        private final Object signature;

        Identity(RoutineName name, CatalogObjectKind namespace, Object scope, Object signature) {
            List<Object> keys = new ArrayList<Object>();
            for (RoutineName.Level level : name.getContainers()) {
                keys.add(level.getState() == CatalogLookupName.SlotState.PRESENT ? level.getKey()
                        : level.getRole() + ":" + level.getState());
            }
            this.containers = keys;
            this.namespace = namespace;
            this.terminal = name.terminalKey(name.getKind());
            this.scope = scope;
            this.signature = signature;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (!(o instanceof Identity)) {
                return false;
            }
            Identity other = (Identity) o;
            return namespace == other.namespace && scope == other.scope && containers.equals(other.containers)
                    && terminal.equals(other.terminal) && Objects.equals(signature, other.signature);
        }

        @Override
        public int hashCode() {
            return Objects.hash(namespace, System.identityHashCode(scope), containers, terminal, signature);
        }
    }

    /** The scope a declaration is local to, if any: visible only to lookups inside it. */
    Object scope() {
        return identity.scope;
    }

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