/*
 * 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 NOT thread-safe. External synchronization
 * is required if accessed from multiple threads.</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<QualifiedName, TSQLSchemaObject> objectIndex = new LinkedHashMap<>();

    // Per-type indexes for efficient type-specific lookups
    private final Map<QualifiedName, TSQLSchemaObject> tableIndex = new LinkedHashMap<>();
    private final Map<QualifiedName, TSQLSchemaObject> functionIndex = new LinkedHashMap<>();
    private final Map<QualifiedName, TSQLSchemaObject> procedureIndex = new LinkedHashMap<>();
    private final Map<QualifiedName, TSQLSchemaObject> packageIndex = new LinkedHashMap<>();
    private final Map<QualifiedName, TSQLSchemaObject> triggerIndex = new LinkedHashMap<>();
    private final Map<QualifiedName, 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#normalize(String, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType)}
     *       规范化后的简单名。</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;
        this.nameService = new NameService(vendor);
        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 TSQLSchemaObject put(TSQLSchemaObject object) {
        if (object == null) {
            throw new IllegalArgumentException("object cannot be null");
        }

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

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

        // Add to type-specific index
        Map<QualifiedName, 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 TSQLSchemaObject get(String catalog, String schema, String objectName, ESQLDataObjectType type) {
        if (objectName == null || type == null) {
            return null;
        }

        // Normalize components to match stored keys
        String normalizedCatalog = normalizeComponent(catalog, type);
        String normalizedSchema = normalizeComponent(schema, type);
        String normalizedObject = normalizeComponent(objectName, type);

        QualifiedName key = new QualifiedName(normalizedCatalog, normalizedSchema, normalizedObject, type);
        return objectIndex.get(key);
    }

    /**
     * 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 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
//        }

        // Use IdentifierService if available, otherwise fall back to legacy method
        String normalizedName;
        if (identifierService != null) {
            normalizedName = identifierService.normalize(objectName, type);
        } else {
            normalizedName =  IdentifierService.normalizeStatic(vendor, type, objectName); // TSQLEnv.normalizeIdentifier(vendor, type, objectName);  //
        }
        List<TSQLSchemaObject> candidates = objectsByName.get(normalizedName);

        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 Collection<TSQLSchemaObject> getByType(ESQLDataObjectType type) {
        if (type == null) {
            return Collections.emptyList();
        }

        Map<QualifiedName, 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 boolean remove(TSQLSchemaObject object) {
        if (object == null) {
            return false;
        }

        QualifiedName key = createKey(object);

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

        if (removed != null) {
            // Remove from type-specific index
            Map<QualifiedName, 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 int size() {
        return objectIndex.size();
    }

    /**
     * Removes all objects from the store.
     */
    public 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 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 QualifiedName createKey(TSQLSchemaObject object) {
        String catalog = object.getSchema() != null && object.getSchema().getCatalog() != null
            ? normalizeComponent(object.getSchema().getCatalog().getName(), object.getDataObjectType())
            : null;
        String schema = object.getSchema() != null
            ? normalizeComponent(object.getSchema().getName(), object.getDataObjectType())
            : null;
        String name = normalizeComponent(object.getName(), object.getDataObjectType());

        return new QualifiedName(catalog, schema, name, object.getDataObjectType());
    }

    /**
     * Normalizes a name component (catalog/schema/object).
     */
    private String normalizeComponent(String component, ESQLDataObjectType type) {
        if (component == null || component.isEmpty()) {
            return null;
        }
        // Use IdentifierService if available, otherwise fall back to legacy method
        if (identifierService != null) {
            return identifierService.normalize(component, type);
        } else {
            return IdentifierService.normalizeStatic(vendor, type, component);
        }
    }

    /**
     * Normalizes an object's name for the name-only index.
     */
    private String normalizeObjectName(TSQLSchemaObject object) {
        String name = object.getName();
        if (name == null) {
            name = "";
        }
        // Use IdentifierService if available, otherwise fall back to legacy method
        if (identifierService != null) {
            return identifierService.normalize(name, object.getDataObjectType());
        } else {
            return IdentifierService.normalizeStatic(vendor, object.getDataObjectType(), name);
        }
    }

    /**
     * Returns the type-specific index for the given object type.
     */
    private Map<QualifiedName, 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();
        }
    }
}