package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.List;

/**
 * Hierarchical Resolver (Phase 2 - 分层索引解析器)
 *
 * <p>使用分层索引（LinkedHashMap）进行 O(1) schema 对象查找。
 *
 * <p><strong>核心设计：</strong>
 * <ul>
 * <li>每一层使用 IdentifierService 生成索引键
 * <li>支持部分限定名（table, schema.table, catalog.schema.table）
 * <li>当 USE_HIERARCHICAL_INDEX = false 时，回退到 legacy 查找
 * </ul>
 *
 * <p>使用示例：
 * <pre>
 * TSQLEnv env = ...;
 * HierarchicalResolver resolver = new HierarchicalResolver();
 *
 * // 查找表
 * TSQLTable table = resolver.findTable(env, "mydb.myschema.mytable");
 *
 * // 查找列
 * TSQLColumn column = resolver.findColumn(table, "mycolumn");
 * </pre>
 *
 * @since 3.1.0.9
 */
public class HierarchicalResolver {

    /**
     * 查找 schema 对象（通用方法）
     *
     * <p>支持三种限定名格式：
     * <ul>
     * <li>单段：table（仅对象名）
     * <li>双段：schema.table（schema + 对象名）
     * <li>三段：catalog.schema.table（catalog + schema + 对象名）
     * </ul>
     *
     * @param env SQL 环境
     * @param qualifiedName 限定名（可能是部分限定）
     * @param objectType 对象类型
     * @return schema 对象，未找到时返回 null
     */
    public TSQLSchemaObject findSchemaObject(TSQLEnv env, String qualifiedName, ESQLDataObjectType objectType) {
        if (!TBaseType.USE_HIERARCHICAL_INDEX) {
            // Feature flag disabled, use legacy search
            return null;
        }

        if (qualifiedName == null || qualifiedName.isEmpty()) {
            return null;
        }

        try {
            // 解析限定名为段列表（catalog, schema, object）
            List<String> segments = SQLUtil.parseNames(qualifiedName);
            if (segments.isEmpty()) {
                return null;
            }

            int segmentCount = segments.size();

            // 根据段数决定查找策略
            if (segmentCount == 1) {
                // 单段：仅对象名，需要在当前 schema 中查找
                return findInCurrentSchema(env, segments.get(0), objectType);
            } else if (segmentCount == 2) {
                // 双段：schema.object
                String schemaName = segments.get(0);
                String objectName = segments.get(1);
                return findInSchema(env, null, schemaName, objectName, objectType);
            } else if (segmentCount == 3) {
                // 三段：catalog.schema.object
                String catalogName = segments.get(0);
                String schemaName = segments.get(1);
                String objectName = segments.get(2);
                return findInSchema(env, catalogName, schemaName, objectName, objectType);
            } else {
                // 超过 3 段，不支持
                return null;
            }
        } catch (Throwable ignore) {
            // 任何异常都回退到 legacy 查找
            return null;
        }
    }

    /**
     * 在当前 schema 中查找对象
     *
     * @param env SQL 环境
     * @param objectName 对象名
     * @param objectType 对象类型
     * @return schema 对象，未找到时返回 null
     */
    private TSQLSchemaObject findInCurrentSchema(TSQLEnv env, String objectName, ESQLDataObjectType objectType) {
        // Get default catalog and schema names
        String defaultCatalogName = env.getDefaultCatalogName();
        String defaultSchemaName = env.getDefaultSchemaName();

        if (defaultSchemaName == null) {
            return null;
        }

        // Find the schema object in the default schema
        return findInSchema(env, defaultCatalogName, defaultSchemaName, objectName, objectType);
    }

    /**
     * 在指定 schema 中查找对象
     *
     * @param env SQL 环境
     * @param catalogName catalog 名称（可为 null，表示当前 catalog）
     * @param schemaName schema 名称
     * @param objectName 对象名
     * @param objectType 对象类型
     * @return schema 对象，未找到时返回 null
     */
    private TSQLSchemaObject findInSchema(TSQLEnv env, String catalogName, String schemaName,
                                          String objectName, ESQLDataObjectType objectType) {
        // 1. 找到 catalog
        TSQLCatalog catalog;
        if (catalogName == null || catalogName.isEmpty()) {
            // Use default catalog
            String defaultCatalog = env.getDefaultCatalogName();
            if (defaultCatalog == null) {
                return null;
            }
            catalog = env.getSQLCatalog(defaultCatalog, false);
        } else {
            catalog = env.getSQLCatalog(catalogName, false);
        }

        if (catalog == null) {
            return null;
        }

        // 2. 找到 schema
        TSQLSchema schema = catalog.searchSchema(schemaName);
        if (schema == null) {
            return null;
        }

        // 3. 找到对象
        return schema.findSchemaObject(objectType, objectName);
    }

    /**
     * 查找表（便捷方法）
     *
     * @param env SQL 环境
     * @param qualifiedName 限定名
     * @return 表对象，未找到时返回 null
     */
    public TSQLTable findTable(TSQLEnv env, String qualifiedName) {
        TSQLSchemaObject obj = findSchemaObject(env, qualifiedName, ESQLDataObjectType.dotTable);
        return (obj instanceof TSQLTable) ? (TSQLTable) obj : null;
    }

    /**
     * 查找函数（便捷方法）
     *
     * @param env SQL 环境
     * @param qualifiedName 限定名
     * @return 函数对象，未找到时返回 null
     */
    public TSQLFunction findFunction(TSQLEnv env, String qualifiedName) {
        TSQLSchemaObject obj = findSchemaObject(env, qualifiedName, ESQLDataObjectType.dotFunction);
        return (obj instanceof TSQLFunction) ? (TSQLFunction) obj : null;
    }

    /**
     * 查找存储过程（便捷方法）
     *
     * @param env SQL 环境
     * @param qualifiedName 限定名
     * @return 存储过程对象，未找到时返回 null
     */
    public TSQLProcedure findProcedure(TSQLEnv env, String qualifiedName) {
        TSQLSchemaObject obj = findSchemaObject(env, qualifiedName, ESQLDataObjectType.dotProcedure);
        return (obj instanceof TSQLProcedure) ? (TSQLProcedure) obj : null;
    }

    /**
     * 查找列（便捷方法）
     *
     * @param table 表对象
     * @param columnName 列名
     * @return 列对象，未找到时返回 null
     */
    public TSQLColumn findColumn(TSQLTable table, String columnName) {
        if (!TBaseType.USE_HIERARCHICAL_INDEX) {
            return null;
        }

        if (table == null || columnName == null || columnName.isEmpty()) {
            return null;
        }

        try {
            return table.getColumn(columnName);
        } catch (Throwable ignore) {
            return null;
        }
    }

    /**
     * 批量查找列（便捷方法）
     *
     * <p>用于 SELECT * 等场景，需要获取表的所有列。
     *
     * @param table 表对象
     * @return 列列表，表不存在时返回空列表
     */
    public List<TSQLColumn> findAllColumns(TSQLTable table) {
        if (table == null) {
            return java.util.Collections.emptyList();
        }

        try {
            return table.getColumnList();
        } catch (Throwable ignore) {
            return java.util.Collections.emptyList();
        }
    }
}