package gudusoft.gsqlparser.dlineage.routine;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.util.SQLUtil;

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

/**
 * A key of the routine alias registry, the lineage model's name-keyed index of routines, on typed names.
 *
 * <p>The legacy index keys a routine by text: its name folded by the legacy normal-name function, followed by one of
 * three alias suffixes rendered from the declaration ({@code (int,int)}, {@code (2)}, {@code (in1)}), appended
 * unchanged. This key keeps that suffix as the same raw text, so aliases and overloads behave exactly as before, and
 * replaces the folded name with the name's levels as written, in positional order, each keyed by the analysis's
 * identifier rules. The routine level is keyed under the routine rules. Every qualifier is keyed under the schema
 * rules, whether it is a server, a database, a schema or a package: which one it is cannot be known at a call, and
 * two keys compare level by level.</p>
 *
 * <p>An explicitly empty middle level ({@code db..p}) is a level of its own, so {@code db..p} keeps three levels, as
 * its legacy text did. A database link ({@code p@link}) is part of the key, as the legacy kept {@code @link} in the
 * text.</p>
 */
public final class RoutineAliasKey {

    /** The routine level's comparison type. Procedures and functions share one index, and one rule group. */
    static final ESQLDataObjectType ROUTINE_TYPE = ESQLDataObjectType.dotProcedure;
    /** Every qualifier's comparison type. */
    static final ESQLDataObjectType QUALIFIER_TYPE = ESQLDataObjectType.dotSchema;

    /** The level of the empty qualifier in {@code db..p}. */
    private static final Object EMPTY_LEVEL = new Object() {
        @Override
        public String toString() {
            return "<empty>";
        }
    };

    private final List<Object> levels;
    private final CanonKey dblink;
    private final String signature;
    private final CanonKey storedSignature;
    /**
     * Whether a level's text as written contains {@code (} ({@code [P(]}): the legacy lookup chose its branch by a
     * {@code (} anywhere in the key text, so such a name is looked up as the legacy looked up a name with a suffix.
     */
    private final boolean parenInName;
    /**
     * The routine level keyed as a qualifier: a package's name is a routine-level name of its own, and a qualifier of
     * its members' names ({@link #qualifiedBy}), where it must compare with a call's qualifier.
     */
    private final CanonKey routineAsQualifier;
    private final int hash;

    private RoutineAliasKey(List<Object> levels, CanonKey dblink, String signature, CanonKey storedSignature,
            boolean parenInName, CanonKey routineAsQualifier) {
        this.levels = Collections.unmodifiableList(levels);
        this.dblink = dblink;
        this.signature = signature;
        this.storedSignature = storedSignature;
        this.parenInName = parenInName;
        this.routineAsQualifier = routineAsQualifier;
        int h = levels.hashCode();
        h = 31 * h + (dblink == null ? 0 : dblink.hashCode());
        h = 31 * h + (signature == null ? 0 : signature.hashCode());
        this.hash = h;
    }

    /** The analysis's identifier service, or the vendor default when no analysis has published one. */
    public static IdentifierService service() {
        IdentifierService service = ModelBindingManager.getGlobalIdentifierService();
        if (service != null) {
            return service;
        }
        EDbVendor vendor = ModelBindingManager.getGlobalVendor();
        return vendor == null ? null : IdentifierService.defaultServiceFor(vendor);
    }

    /**
     * The key of a routine name as written at a call or a declaration, with the legacy alias suffix
     * {@code signature} (null when the legacy key had none). Null when the name has no routine level.
     */
    public static RoutineAliasKey written(TObjectName name, String signature) {
        return written(name, signature, service());
    }

    public static RoutineAliasKey written(TObjectName name, String signature, IdentifierService service) {
        if (name == null || service == null) {
            return null;
        }
        try {
            return writtenKey(name, signature, service);
        } catch (RuntimeException unkeyable) {
            // A name the identifier rules cannot key (it could not be declared or called either) names nothing here.
            return null;
        }
    }

    private static RoutineAliasKey writtenKey(TObjectName name, String signature, IdentifierService service) {
        TSourceToken server = name.getServerToken();
        TSourceToken database = name.getDatabaseToken();
        TSourceToken schema = name.getSchemaToken();
        TSourceToken pkg = name.getPackageToken();
        TSourceToken object = name.getObjectToken();
        TSourceToken part = name.getPartToken();
        if (part != null && !part.toString().isEmpty()) {
            // A name the parser split as object.part (DB2 CALL s.p): the part is the routine.
            if (database == null) {
                database = schema;
            }
            schema = object;
            object = part;
        }
        if (object == null || object.toString().isEmpty()) {
            return null;
        }
        List<Object> levels = new ArrayList<Object>(5);
        boolean paren = false;
        for (TSourceToken qualifier : new TSourceToken[] {server, database, schema, pkg}) {
            if (qualifier != null) {
                levels.add(qualifierLevel(qualifier.toString(), service));
                paren |= qualifier.toString().indexOf('(') >= 0;
            }
        }
        levels.add(routineKey(object.toString(), service));
        paren |= object.toString().indexOf('(') >= 0;
        CanonKey dblink = null;
        if (name.getDblink() != null && name.getDblink().toString() != null && !name.getDblink().toString().isEmpty()) {
            dblink = service.canonKeyOf(name.getDblink().toString(), ESQLDataObjectType.dotDblink,
                    IdentifierInputForm.SQL_LEXICAL);
            paren |= name.getDblink().toString().indexOf('(') >= 0;
        }
        return new RoutineAliasKey(levels, dblink, signature, storedSignature(signature, service), paren,
                qualifierKey(object.toString(), service));
    }

    /**
     * The key of a name whose levels are already separate identifiers as written: a model's database and schema
     * fields and its routine name. Never a way to split a rendered, dotted name; an empty level is the empty
     * qualifier of {@code db..p}.
     */
    public static RoutineAliasKey ofWrittenLevels(List<String> qualifiers, String routine, String signature,
            IdentifierService service) {
        if (routine == null || routine.isEmpty() || service == null) {
            return null;
        }
        List<Object> levels = new ArrayList<Object>();
        boolean paren = routine.indexOf('(') >= 0;
        if (qualifiers != null) {
            for (String qualifier : qualifiers) {
                levels.add(qualifierLevel(qualifier, service));
                paren |= qualifier != null && qualifier.indexOf('(') >= 0;
            }
        }
        levels.add(routineKey(routine, service));
        return new RoutineAliasKey(levels, null, signature, storedSignature(signature, service), paren,
                qualifierKey(routine, service));
    }

    /**
     * The key of a routine name given as legacy normal-name text ({@code SCHEMA.NAME(suffix)}), for the deprecated
     * text-keyed API of {@code ModelBindingManager} only. That text is already a stored spelling (the legacy maps
     * compared it as stored text: {@code foo} there is not {@code FOO}), so its levels are keyed as stored names: the text
     * before its last {@code (} (when it ends with {@code )}) is split into levels, and the rest is the alias suffix.
     * Null when it names nothing.
     */
    public static RoutineAliasKey ofLegacyText(String text) {
        return ofLegacyText(text, service());
    }

    /** {@link #ofLegacyText(String)} under the given analysis's identifier rules. */
    public static RoutineAliasKey ofLegacyText(String text, IdentifierService service) {
        if (text == null || text.isEmpty() || service == null) {
            return null;
        }
        String name = text;
        String signature = null;
        int cut = text.lastIndexOf('(');
        if (text.endsWith(")") && cut > 0) {
            name = text.substring(0, cut);
            signature = text.substring(cut);
        }
        try {
            List<String> segments = SQLUtil.parseNames(name);
            if (segments == null || segments.isEmpty()) {
                return null;
            }
            List<Object> levels = new ArrayList<Object>(segments.size());
            boolean paren = false;
            for (int i = 0; i < segments.size(); i++) {
                String segment = segments.get(i);
                if (segment == null || segment.isEmpty()) {
                    return null;
                }
                levels.add(service.canonKeyOf(segment, i == segments.size() - 1 ? ROUTINE_TYPE : QUALIFIER_TYPE,
                        IdentifierInputForm.CATALOG_STORED));
                paren |= segment.indexOf('(') >= 0;
            }
            String routine = segments.get(segments.size() - 1);
            return new RoutineAliasKey(levels, null, signature, storedSignature(signature, service), paren,
                    service.canonKeyOf(routine, QUALIFIER_TYPE, IdentifierInputForm.CATALOG_STORED));
        } catch (RuntimeException unkeyable) {
            return null;
        }
    }

    /**
     * A qualifier level. The empty one of {@code db..p} is SQL Server's default schema there, as the legacy normalizer
     * read it (the session's schema, else {@code dbo}); elsewhere it stays an empty level.
     */
    private static Object qualifierLevel(String text, IdentifierService service) {
        if (text != null && !text.isEmpty()) {
            return qualifierKey(text, service);
        }
        EDbVendor vendor = service.getProfile() == null ? null : service.getProfile().getVendor();
        if (vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql) {
            String schema = ModelBindingManager.getGlobalSchema();
            return qualifierKey(schema != null ? schema : "dbo", service);
        }
        return EMPTY_LEVEL;
    }

    static CanonKey qualifierKey(String text, IdentifierService service) {
        return service.canonKeyOf(text, QUALIFIER_TYPE, IdentifierInputForm.SQL_LEXICAL);
    }

    static CanonKey routineKey(String text, IdentifierService service) {
        return service.canonKeyOf(text, ROUTINE_TYPE, IdentifierInputForm.SQL_LEXICAL);
    }

    /**
     * The alias suffix as the legacy leaf comparison saw it: part of one stored routine name, compared by the
     * routine rules (so {@code (MyType)} and {@code (mytype)} are one suffix where routine names ignore case).
     */
    private static CanonKey storedSignature(String signature, IdentifierService service) {
        if (signature == null || signature.isEmpty()) {
            return null;
        }
        return service.canonKeyOf(signature, ROUTINE_TYPE, IdentifierInputForm.CATALOG_STORED);
    }

    /**
     * The key of a model's display name ({@code Procedure}, {@code OraclePackage}), built beside the composition that
     * renders it, branch for branch: the composition appends written segments and filled-in database or schema
     * values, and this appends the matching levels. A written segment's level is the written name's own level when the
     * name's levels line up with the composition's segments; a filled-in value is keyed as one identifier.
     */
    public static final class Display {
        private final RoutineAliasKey written;
        private final List<String> segments;
        private final IdentifierService service;
        private final List<Object> levels = new ArrayList<Object>();
        private boolean paren;
        private boolean failed;

        public Display(TObjectName name, List<String> segments) {
            this.service = service();
            RoutineAliasKey key = null;
            try {
                key = written(name, null, service);
            } catch (RuntimeException failure) {
                failed = true;
            }
            this.written = key != null && segments != null && key.size() == segments.size() ? key : null;
            this.segments = segments;
            if (service == null) {
                failed = true;
            }
        }

        /** The composition appended written segment {@code index} as a qualifier. */
        public void segment(int index) {
            if (failed) {
                return;
            }
            try {
                levels.add(written != null ? written.levels.get(index) : qualifierLevel(segments.get(index), service));
                paren |= segments.get(index) != null && segments.get(index).indexOf('(') >= 0;
            } catch (RuntimeException failure) {
                failed = true;
            }
        }

        /** The composition appended a filled-in database or schema value. */
        public void field(String value) {
            if (failed) {
                return;
            }
            try {
                levels.add(qualifierLevel(value, service));
                paren |= value != null && value.indexOf('(') >= 0;
            } catch (RuntimeException failure) {
                failed = true;
            }
        }

        /** The composition appended the routine's own (last) segment: the key of the display name, or null. */
        public RoutineAliasKey finish() {
            if (failed) {
                return null;
            }
            try {
                if (segments == null || segments.isEmpty()) {
                    return null;
                }
                String last = segments.get(segments.size() - 1);
                paren |= last != null && last.indexOf('(') >= 0;
                if (written != null) {
                    levels.add(written.getRoutineKey());
                    return new RoutineAliasKey(levels, written.dblink, null, null, paren, written.routineAsQualifier);
                }
                levels.add(routineKey(last, service));
                return new RoutineAliasKey(levels, null, null, null, paren, qualifierKey(last, service));
            } catch (RuntimeException failure) {
                return null;
            }
        }
    }

    /** This key with {@code qualifiers}' levels in front, for a member of the package {@code qualifiers} names. */
    public RoutineAliasKey qualifiedBy(RoutineAliasKey qualifiers) {
        if (qualifiers == null) {
            return this;
        }
        List<Object> joined = new ArrayList<Object>(qualifiers.levels.size() + levels.size());
        joined.addAll(qualifiers.levels.subList(0, qualifiers.levels.size() - 1));
        joined.add(qualifiers.routineAsQualifier);
        joined.addAll(levels);
        return new RoutineAliasKey(joined, dblink, signature, storedSignature, parenInName || qualifiers.parenInName,
                routineAsQualifier);
    }

    /** This key's levels with another alias suffix. */
    public RoutineAliasKey withSignature(String otherSignature) {
        return withSignature(otherSignature, service());
    }

    public RoutineAliasKey withSignature(String otherSignature, IdentifierService service) {
        if (otherSignature == null ? signature == null : otherSignature.equals(signature)) {
            return this;
        }
        return new RoutineAliasKey(new ArrayList<Object>(levels), dblink, otherSignature,
                service == null ? null : storedSignature(otherSignature, service), parenInName, routineAsQualifier);
    }

    /** This key without an alias suffix: the name alone. */
    public RoutineAliasKey nameOnly() {
        return signature == null ? this
                : new RoutineAliasKey(new ArrayList<Object>(levels), dblink, null, null, parenInName, routineAsQualifier);
    }

    public int size() {
        return levels.size();
    }

    public boolean isQualified() {
        return levels.size() > 1;
    }

    public boolean hasSignature() {
        return signature != null;
    }

    /** Whether the legacy lookup took this key's text for a name with a suffix: it has one, or a {@code (} as written. */
    public boolean looksSuffixed() {
        return signature != null || parenInName;
    }

    /**
     * This key with {@code qualifier} as written in front, a single identifier (a model's schema field); for a lookup
     * the legacy made by prefixing that text.
     */
    public RoutineAliasKey withQualifier(String qualifier) {
        return withQualifier(qualifier, service());
    }

    public RoutineAliasKey withQualifier(String qualifier, IdentifierService service) {
        if (qualifier == null || service == null) {
            return this;
        }
        List<Object> joined = new ArrayList<Object>(levels.size() + 1);
        joined.add(qualifierLevel(qualifier, service));
        joined.addAll(levels);
        return new RoutineAliasKey(joined, dblink, signature, storedSignature,
                parenInName || qualifier.indexOf('(') >= 0, routineAsQualifier);
    }

    /** The alias suffix as raw text, or null. */
    public String getSignature() {
        return signature;
    }

    /** The routine level's key. */
    public CanonKey getRoutineKey() {
        return (CanonKey) levels.get(levels.size() - 1);
    }

    /** The name's levels (a {@code CanonKey}, or the empty level), outermost first. */
    public List<Object> getLevels() {
        return levels;
    }

    boolean sameName(RoutineAliasKey other) {
        return levels.equals(other.levels) && sameLink(other);
    }

    boolean sameRoutine(RoutineAliasKey other) {
        return getRoutineKey().equals(other.getRoutineKey()) && sameLink(other);
    }

    private boolean sameLink(RoutineAliasKey other) {
        return dblink == null ? other.dblink == null : dblink.equals(other.dblink);
    }

    /** The legacy {@code startsWith} of the full key text, once the names are equal: the suffix as raw text. */
    boolean signatureStartsWith(RoutineAliasKey other) {
        return signature != null && other.signature != null && signature.startsWith(other.signature);
    }

    /** The legacy leaf comparison's suffix part: both suffixes, as stored routine-name text. */
    boolean sameStoredSignature(RoutineAliasKey other) {
        if (signature == null || other.signature == null) {
            return signature == null && other.signature == null;
        }
        if (storedSignature == null || other.storedSignature == null) {
            return signature.equals(other.signature);
        }
        return storedSignature.equals(other.storedSignature);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (!(o instanceof RoutineAliasKey)) {
            return false;
        }
        RoutineAliasKey that = (RoutineAliasKey) o;
        return hash == that.hash && levels.equals(that.levels) && sameLink(that)
                && (signature == null ? that.signature == null : signature.equals(that.signature));
    }

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

    /** For diagnostics only: never compare or key by this text. */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < levels.size(); i++) {
            if (i > 0) {
                sb.append('.');
            }
            Object level = levels.get(i);
            sb.append(level instanceof CanonKey ? ((CanonKey) level).getCanonText() : String.valueOf(level));
        }
        if (dblink != null) {
            sb.append('@').append(dblink.getCanonText());
        }
        if (signature != null) {
            sb.append(signature);
        }
        return sb.toString();
    }
}