package gudusoft.gsqlparser.dlineage.symbol;

import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierService;

/**
 * The key of a local symbol of the lineage model: a variable, a cursor, a declared type, a trigger correlation name or
 * a table variable, by the scope it is declared in and its name as written.
 *
 * <p>The scope is the declaring routine's frozen scope (see {@link LocalScopes}), or an overload pool's
 * ({@link IdentityScope}), or null at top level. The name is keyed by the analysis's identifier rules under the object
 * type of its namespace. Declared locals (variables, cursors, declared types, table variables) share one namespace, as
 * a cursor and a variable of one name are one name in a declare section; a trigger's correlation names are another.</p>
 */
public final class LocalSymbolKey {

    /** Which names a local symbol competes with. */
    public enum Namespace {
        /** Variables, cursors, declared types and table variables of a declare section or parameter list. */
        DECLARED(ESQLDataObjectType.dotParameter),
        /** A trigger's correlation names ({@code :NEW}, {@code :OLD}, REFERENCING aliases): aliases of a table. */
        CORRELATION(ESQLDataObjectType.dotTable);

        final ESQLDataObjectType type;

        Namespace(ESQLDataObjectType type) {
            this.type = type;
        }
    }

    /** What a local symbol is; its namespace decides its identity and the object type its name is compared under. */
    public enum Kind {
        VARIABLE(Namespace.DECLARED),
        CURSOR(Namespace.DECLARED),
        TYPE(Namespace.DECLARED),
        TABLE_VARIABLE(Namespace.DECLARED),
        CORRELATION(Namespace.CORRELATION);

        final Namespace namespace;

        Kind(Namespace namespace) {
            this.namespace = namespace;
        }

        public Namespace getNamespace() {
            return namespace;
        }
    }

    private final Object scope;
    /** The name's CanonKey, or its exact spelling (a String) when the rules cannot key it. */
    private final Object name;
    /** The name as written: to key it again under another namespace's rules. Not part of the identity. */
    private final String written;
    private final IdentifierService service;
    private final Kind kind;
    private final int hash;

    private LocalSymbolKey(Object scope, Object name, String written, IdentifierService service, Kind kind) {
        this.scope = scope;
        this.name = name;
        this.written = written;
        this.service = service;
        this.kind = kind;
        this.hash = (31 * (scope == null ? 0 : scope.hashCode()) + name.hashCode()) * 31 + kind.namespace.hashCode();
    }

    /**
     * The key of {@code name}, a single identifier as written (a leading {@code :} already removed), declared in
     * {@code scope}; null only for an empty name. A spelling the rules cannot read keys by its exact spelling.
     */
    public static LocalSymbolKey of(Object scope, String name, Kind kind) {
        return of(scope, name, kind, service());
    }

    public static LocalSymbolKey of(Object scope, String name, Kind kind, IdentifierService service) {
        if (name == null || name.isEmpty() || kind == null) {
            return null;
        }
        if (service == null) {
            // No identifier rules known on this thread: the exact spelling only.
            return new LocalSymbolKey(scope, name, name, null, kind);
        }
        try {
            return new LocalSymbolKey(scope,
                    service.canonKeyOf(name, kind.namespace.type, IdentifierInputForm.SQL_LEXICAL), name, service, kind);
        } catch (RuntimeException unkeyable) {
            // A spelling the rules cannot read is still one name: it matches its exact spelling only, never a fold.
            return new LocalSymbolKey(scope, name, name, service, kind);
        }
    }

    private static IdentifierService service() {
        return ModelBindingManager.getGlobalIdentifierService();
    }

    public Object getScope() {
        return scope;
    }

    public Kind getKind() {
        return kind;
    }

    /** The same name in another scope (a lookup walking a lexical chain). */
    public LocalSymbolKey inScope(Object otherScope) {
        return new LocalSymbolKey(otherScope, name, written, service, kind);
    }

    /** The same written name and scope, keyed as a trigger correlation name (under that namespace's rules). */
    public LocalSymbolKey asCorrelation() {
        return kind == Kind.CORRELATION ? this : of(scope, written, Kind.CORRELATION, service);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof LocalSymbolKey)) {
            return false;
        }
        LocalSymbolKey that = (LocalSymbolKey) o;
        return hash == that.hash && kind.namespace == that.kind.namespace && name.equals(that.name)
                && (scope == null ? that.scope == null : scope.equals(that.scope));
    }

    @Override
    public int hashCode() {
        return hash;
    }

    /** For diagnostics only. */
    @Override
    public String toString() {
        return (scope == null ? "" : scope + ".") + (name instanceof CanonKey ? ((CanonKey) name).getCanonText()
                : "'" + name + "'") + "<" + kind + ">";
    }
}