/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.EDbVendor;

import java.util.*;

/**
 * Unified storage abstraction for catalog objects using canonical keys.
 *
 * <p>This class replaces GSP's legacy triple-index architecture
 * (schemaObjectList + objectIndex + tablesByName) with a clean, type-aware
 * storage system backed by LinkedHashMaps for O(1) lookups.</p>
 *
 * <p>Key improvements over legacy storage:</p>
 * <ul>
 *   <li>Canonical keys eliminate string suffix hacks ($function, $procedure, etc.)</li>
 *   <li>Per-type indexes for efficient type-specific lookups</li>
 *   <li>Vendor-aware case sensitivity via {@link NameService}</li>
 *   <li>Insertion order preservation for compatibility</li>
 *   <li>Full and partial name resolution support</li>
 * </ul>
 *
 * <p>Thread safety: This class is thread-safe. All public methods are synchronized
 * to support concurrent access from multiple threads without external synchronization.</p>
 *
 * @since 3.2.0.3 (Phase 1)
 */
public class CatalogStore {

    private final EDbVendor vendor;
    private final NameService nameService;
    private final IdentifierService identifierService;

    // Primary storage: canonical key -> object
    private final Map<Key, TSQLSchemaObject> objectIndex = new LinkedHashMap<>();

    // Per-type indexes for efficient type-specific lookups
    private final Map<Key, TSQLSchemaObject> tableIndex = new LinkedHashMap<>();
    private final Map<Key, TSQLSchemaObject> functionIndex = new LinkedHashMap<>();
    private final Map<Key, TSQLSchemaObject> procedureIndex = new LinkedHashMap<>();
    private final Map<Key, TSQLSchemaObject> packageIndex = new LinkedHashMap<>();
    private final Map<Key, TSQLSchemaObject> triggerIndex = new LinkedHashMap<>();
    private final Map<Key, TSQLSchemaObject> columnIndex = new LinkedHashMap<>();

    /**
     * 名称级（不含 catalog/schema）二级索引，用于“未给出完整路径”的部分查找。
     *
     * <p><b>为什么 value 是 {@code List<TSQLSchemaObject>}：</b></p>
     * <ul>
     *   <li>同名对象可存在于不同 catalog/schema 下：如 {@code db1.dbo.orders}
     *       与 {@code db1.sales.orders}。</li>
     *   <li>不同类型也可能同名（表/视图/函数等）；可在
     *       {@link #getByName(String, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType)}
     *       中按类型再筛。</li>
     *   <li>需要先收集全部候选，再依据默认 schema/search_path/上下文判定或报歧义。</li>
     * </ul>
     *
     * <p><b>典型场景：</b></p>
     * <pre>
     * -- 1) MSSQL：默认 schema 解析
     * USE db1;
     * SELECT * FROM orders;
     * -- 候选：db1.dbo.orders、db1.sales.orders
     * -- 解析器按默认 schema（如 dbo）或搜索路径挑选命中
     *
     * -- 2) BigQuery：默认 dataset
     * -- 当前上下文: project.dataset = p.ds
     * SELECT * FROM `users`;
     * -- 候选：p.ds.users、p.other_ds.users（若可见）
     *
     * -- 3) 歧义诊断
     * SELECT * FROM orders;
     * -- 多个候选且规则不能唯一确定时，抛出歧义错误或给出建议
     * </pre>
     *
     * <p><b>备注：</b></p>
     * <ul>
     *   <li>键为 {@link IdentifierService#keyForMap(String, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType)}
     *       （比较键，相等当且仅当 {@code areEqual}），不是规范化后的存储名。</li>
     *   <li>不用于“按 catalog/schema 分层列举”，此类需求请使用类型索引（如 {@code tableIndex}）并基于
     *       {@link QualifiedName#getCatalog()} / {@link QualifiedName#getSchema()} 过滤。</li>
     * </ul>
     */
    private final Map<String, List<TSQLSchemaObject>> objectsByName = new LinkedHashMap<>();

    /**
     * Creates a new CatalogStore for the specified database vendor.
     *
     * @param vendor the database vendor
     * @deprecated Use {@link #CatalogStore(EDbVendor, IdentifierService)} instead
     */
    @Deprecated
    public CatalogStore(EDbVendor vendor) {
        if (vendor == null) {
            throw new IllegalArgumentException("vendor cannot be null");
        }
        this.vendor = vendor;
        this.nameService = new NameService(vendor);
        this.identifierService = null;  // Will fall back to TSQLEnv.normalizeIdentifier
    }

    /**
     * Creates a new CatalogStore for the specified database vendor with IdentifierService.
     *
     * <p>This is the preferred constructor that uses IdentifierService for proper
     * per-object-type identifier normalization.</p>
     *
     * @param vendor the database vendor
     * @param identifierService the identifier service for normalization
     * @since 3.2.0.3 (Phase 3.5)
     */
    public CatalogStore(EDbVendor vendor, IdentifierService identifierService) {
        if (vendor == null) {
            throw new IllegalArgumentException("vendor cannot be null");
        }
        if (identifierService == null) {
            throw new IllegalArgumentException("identifierService cannot be null");
        }
        this.vendor = vendor;
        // The store's name service must observe the SAME configuration as the store's keys.
        // Building it from the bare vendor left every NameService comparison on the vendor
        // default while the indexes keyed under the analysis profile — the two halves of one
        // lookup disagreeing is exactly how a reference reports NOT_FOUND against an object
        // the index does hold.
        this.nameService = NameService.forIdentifierService(identifierService);
        this.identifierService = identifierService;
    }

    /**
     * Returns the database vendor associated with this store.
     *
     * @return the database vendor
     */
    public EDbVendor getVendor() {
        return vendor;
    }

    /**
     * Returns the name service used by this store.
     *
     * @return the name service
     */
    public NameService getNameService() {
        return nameService;
    }

    /**
     * Adds or updates an object in the store.
     *
     * <p>The object is indexed by its fully-qualified canonical name and also
     * added to type-specific and name-only indexes for efficient lookups.</p>
     *
     * @param object the schema object to add
     * @return the previous object with the same key, or null if none existed
     */
    public synchronized TSQLSchemaObject put(TSQLSchemaObject object) {
        if (object == null) {
            throw new IllegalArgumentException("object cannot be null");
        }

        // Create canonical key
        Key key = createKey(object);

        // Add to primary index
        TSQLSchemaObject previous = objectIndex.put(key, object);

        // Add to type-specific index
        Map<Key, TSQLSchemaObject> typeIndex = getTypeIndex(object.getDataObjectType());
        if (typeIndex != null) {
            typeIndex.put(key, object);
        }

        // Add to name-only index
        String normalizedName = normalizeObjectName(object);
        objectsByName.computeIfAbsent(normalizedName, k -> new ArrayList<>()).add(object);

        return previous;
    }

    /**
     * Finds an object by its fully-qualified name and type.
     *
     * <p>This is an O(1) lookup using the canonical key index.</p>
     *
     * @param catalog the catalog name (may be null)
     * @param schema the schema name (may be null)
     * @param objectName the object name (required)
     * @param type the object type
     * @return the matching object, or null if not found
     */
    public synchronized TSQLSchemaObject get(String catalog, String schema, String objectName, ESQLDataObjectType type) {
        if (objectName == null || type == null) {
            return null;
        }

        return objectIndex.get(key(catalog, schema, objectName, type, IdentifierInputForm.SQL_LEXICAL));
    }

    /**
     * Same lookup as {@link #get}, for components that are ALREADY normalized. {@link #get}
     * takes SQL text ({@code get("hr_db", "public", "employees")} folds and finds
     * {@code EMPLOYEES}); {@code TSQLEnv} normalizes before it asks, and passing its segments
     * to {@link #get} folded them a second time. The two forms need two entries: the same
     * string {@code Orders} is the table {@code ORDERS} as SQL text and the table
     * {@code "Orders"} as a normalized name.
     */
    public synchronized TSQLSchemaObject getNormalized(String catalog, String schema, String objectName,
                                                       ESQLDataObjectType type) {
        if (objectName == null || type == null) {
            return null;
        }
        return objectIndex.get(key(catalog, schema, objectName, type, IdentifierInputForm.CATALOG_STORED));
    }

    /**
     * Finds objects by name only, regardless of catalog/schema.
     *
     * <p>This is used for partial name resolution when the full path is not specified.</p>
     *
     * @param objectName the object name
     * @param type the object type (optional - null returns all types)
     * @return list of matching objects (may be empty, never null)
     */
    public synchronized List<TSQLSchemaObject> getByName(String objectName, ESQLDataObjectType type) {
        if (objectName == null) {
            return Collections.emptyList();
        }

//        if (type == null){
//          type = ESQLDataObjectType.dotTable; // Default to table type if none specified
//        }

        // The comparison key (keyForMap), not the stored name: two names the service calls equal
        // must find each other. MySQL lower_case_table_names=1 stores `İ` as İ but compares it
        // equal to i; SQL Server _AI stores café but compares it equal to cafe. A null type keeps
        // the "any type" reading it always had (keyForMap/normalize treat null alike).
        List<TSQLSchemaObject> candidates = objectsByName.get(nameKey(objectName, type));

        if (candidates == null || candidates.isEmpty()) {
            return Collections.emptyList();
        }

        // Filter by type if specified
        if (type != null) {
            List<TSQLSchemaObject> filtered = new ArrayList<>();
            for (TSQLSchemaObject obj : candidates) {
                if (obj.getDataObjectType() == type) {
                    filtered.add(obj);
                }
            }
            return filtered;
        }

        return new ArrayList<>(candidates);
    }

    /**
     * Finds all objects of a specific type.
     *
     * @param type the object type
     * @return collection of all objects of that type (may be empty, never null)
     */
    public synchronized Collection<TSQLSchemaObject> getByType(ESQLDataObjectType type) {
        if (type == null) {
            return Collections.emptyList();
        }

        Map<Key, TSQLSchemaObject> typeIndex = getTypeIndex(type);
        if (typeIndex == null) {
            return Collections.emptyList();
        }

        return new ArrayList<>(typeIndex.values());
    }

    /**
     * Removes an object from the store.
     *
     * @param object the object to remove
     * @return true if the object was removed, false if it was not present
     */
    public synchronized boolean remove(TSQLSchemaObject object) {
        if (object == null) {
            return false;
        }

        Key key = createKey(object);

        // Remove from primary index
        TSQLSchemaObject removed = objectIndex.remove(key);

        if (removed != null) {
            // Remove from type-specific index
            Map<Key, TSQLSchemaObject> typeIndex = getTypeIndex(object.getDataObjectType());
            if (typeIndex != null) {
                typeIndex.remove(key);
            }

            // Remove from name-only index
            String normalizedName = normalizeObjectName(object);
            List<TSQLSchemaObject> list = objectsByName.get(normalizedName);
            if (list != null) {
                list.remove(object);
                if (list.isEmpty()) {
                    objectsByName.remove(normalizedName);
                }
            }

            return true;
        }

        return false;
    }

    /**
     * Returns the total number of objects in the store.
     *
     * @return the total count
     */
    public synchronized int size() {
        return objectIndex.size();
    }

    /**
     * Removes all objects from the store.
     */
    public synchronized void clear() {
        objectIndex.clear();
        tableIndex.clear();
        functionIndex.clear();
        procedureIndex.clear();
        packageIndex.clear();
        triggerIndex.clear();
        columnIndex.clear();
        objectsByName.clear();
    }

    /**
     * Returns all objects in insertion order.
     *
     * @return collection of all objects (may be empty, never null)
     */
    public synchronized Collection<TSQLSchemaObject> getAll() {
        return new ArrayList<>(objectIndex.values());
    }

    /**
     * Creates a canonical key for an object.
     *
     * <p>The key is normalized according to vendor-specific rules.</p>
     */
    private Key createKey(TSQLSchemaObject object) {
        // An object's own names come from getName(): already normalized, i.e. stored names.
        String catalog = object.getSchema() != null && object.getSchema().getCatalog() != null
            ? object.getSchema().getCatalog().getName() : null;
        String schema = object.getSchema() != null ? object.getSchema().getName() : null;
        return key(catalog, schema, object.getName(), object.getDataObjectType(), IdentifierInputForm.CATALOG_STORED);
    }

    /**
     * The index key, built by the name service's canonical key
     * ({@link IdentifierService#canonKeyOf}) with the input form STATED for every component.
     *
     * <p>The key used to be {@code normalize(name)} on a name that was already normalized, which
     * was wrong twice over. It folded a second time, so Oracle {@code "Orders"} was keyed as
     * {@code ORDERS}, answered to {@code orders} and collided with a real table {@code ORDERS}.
     * And {@code normalize} preserves the spelling on a collation-based dialect, so on SQL Server
     * {@code SalesOrder} could not be found as {@code salesorder}; that case was only rescued by
     * TSQLEnv's legacy string index, which upper-cases the whole name. The canonical key is
     * case-insensitive exactly where the dialect is, and quote-state sensitive exactly where
     * the dialect is.</p>
     */
    private Key key(String catalog, String schema, String objectName, ESQLDataObjectType type,
                    IdentifierInputForm form) {
        return new Key(component(catalog, ESQLDataObjectType.dotCatalog, form),
            component(schema, ESQLDataObjectType.dotSchema, form),
            component(objectName, type, form), type);
    }

    private CanonKey component(String text, ESQLDataObjectType role, IdentifierInputForm form) {
        if (text == null || text.isEmpty()) {
            return null;
        }
        // TSQLEnv's placeholders for a tier the dialect does not have are not names of either form.
        if ((role == ESQLDataObjectType.dotCatalog && TSQLEnv.DEFAULT_DB_NAME.equals(text))
                || (role == ESQLDataObjectType.dotSchema && TSQLEnv.DEFAULT_SCHEMA_NAME.equals(text))) {
            form = IdentifierInputForm.CATALOG_STORED;
        }
        return keyService().canonKeyOf(text, role, form);
    }

    private IdentifierService keyService() {
        if (identifierService != null) {
            return identifierService;
        }
        if (fallbackKeyService == null) {
            // Only reachable through the deprecated vendor-only constructor, which states no
            // configuration at all; the vendor default is then the honest answer.
            fallbackKeyService = IdentifierService.defaultServiceFor(vendor);
        }
        return fallbackKeyService;
    }

    private IdentifierService fallbackKeyService;

    /** Index key: one canonical key per tier plus the object type. */
    private static final class Key {
        private final CanonKey catalog;
        private final CanonKey schema;
        private final CanonKey objectName;
        private final ESQLDataObjectType type;
        private final int hash;

        Key(CanonKey catalog, CanonKey schema, CanonKey objectName, ESQLDataObjectType type) {
            this.catalog = catalog;
            this.schema = schema;
            this.objectName = objectName;
            this.type = type;
            this.hash = Objects.hash(catalog, schema, objectName, type);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key k = (Key) o;
            return type == k.type && Objects.equals(objectName, k.objectName)
                && Objects.equals(schema, k.schema) && Objects.equals(catalog, k.catalog);
        }

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

    /**
     * The name-only index key of an object: its stored name ({@code getName()}, already
     * normalized) spelled back as SQL by the store's own profile, then keyed like a lookup.
     */
    private String normalizeObjectName(TSQLSchemaObject object) {
        String name = object.getName();
        if (name == null) {
            name = "";
        }
        ESQLDataObjectType type = object.getDataObjectType();
        // TSQLEnv's placeholders for a tier the dialect does not have are not stored names.
        boolean placeholder = (type == ESQLDataObjectType.dotCatalog && TSQLEnv.DEFAULT_DB_NAME.equals(name))
                || (type == ESQLDataObjectType.dotSchema && TSQLEnv.DEFAULT_SCHEMA_NAME.equals(name));
        if (!name.isEmpty() && type != null && !placeholder) {
            name = IdentifierCodec.encodeStored(keyService().getProfile(), type, name);
        }
        return nameKey(name, type);
    }

    /**
     * Name-only index key of a SQL spelling: {@link IdentifierService#keyForMap}, whose equality is
     * exactly {@link IdentifierService#areEqual}. Keyed by {@code normalize} (the stored name)
     * before, which split names the service equates.
     */
    private String nameKey(String lexical, ESQLDataObjectType type) {
        if (lexical == null || lexical.isEmpty()) {
            return lexical;
        }
        return keyService().keyForMap(lexical, type);
    }

    /**
     * Returns the type-specific index for the given object type.
     */
    private Map<Key, TSQLSchemaObject> getTypeIndex(ESQLDataObjectType type) {
        switch (type) {
            case dotTable:
                return tableIndex;
            case dotFunction:
                return functionIndex;
            case dotProcedure:
                return procedureIndex;
            case dotOraclePackage:
                return packageIndex;
            case dotTrigger:
                return triggerIndex;
            case dotColumn:
                return columnIndex;
            default:
                return null;
        }
    }

    /**
     * Immutable qualified name used as a canonical key.
     *
     * <p>This value object combines catalog.schema.object + type into a single
     * key with cached hashCode for efficient map lookups.</p>
     */
    public static class QualifiedName {
        private final String catalog;
        private final String schema;
        private final String objectName;
        private final ESQLDataObjectType type;
        private final int hashCode;

        public QualifiedName(String catalog, String schema, String objectName, ESQLDataObjectType type) {
            this.catalog = catalog;
            this.schema = schema;
            this.objectName = objectName;
            this.type = type;
            this.hashCode = computeHashCode();
        }

        public String getCatalog() {
            return catalog;
        }

        public String getSchema() {
            return schema;
        }

        public String getObjectName() {
            return objectName;
        }

        public ESQLDataObjectType getType() {
            return type;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (!(obj instanceof QualifiedName)) return false;

            QualifiedName other = (QualifiedName) obj;
            return Objects.equals(catalog, other.catalog)
                && Objects.equals(schema, other.schema)
                && Objects.equals(objectName, other.objectName)
                && type == other.type;
        }

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

        private int computeHashCode() {
            return Objects.hash(catalog, schema, objectName, type);
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            if (catalog != null) {
                sb.append(catalog).append('.');
            }
            if (schema != null) {
                sb.append(schema).append('.');
            }
            sb.append(objectName);
            sb.append(" (").append(type).append(')');
            return sb.toString();
        }
    }
}