package gudusoft.gsqlparser.sqlenv;

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

import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Composite Key Optimizer (Phase 4 - Couchbase 优化)
 *
 * <p>用于全大小写敏感数据库（Couchbase）的单次 Map 查找优化。
 *
 * <p><strong>核心思想：</strong>
 * <ul>
 * <li>将多级标识符编码为单个复合键（避免 3 次 Map 查找）
 * <li>格式：{@code len1#seg1|len2#seg2|len3#seg3|objectType}
 * <li>例如：{@code "3#db1|6#schema|5#table|dotTable"}
 * <li>性能：分层索引 2-4μs → 复合键 <200ns（~10x 提升）
 * </ul>
 *
 * <p><strong>适用条件（必须全部满足）：</strong>
 * <ol>
 * <li>数据库厂商：Couchbase（全标识符大小写敏感）
 * <li>标识符无引号（引号会改变大小写规则）
 * <li>USE_COMPOSITE_KEY_OPT = true（默认 false，谨慎开启）
 * </ol>
 *
 * <p><strong>性能特性：</strong>
 * <ul>
 * <li>查找时间：~200ns（vs 2-4μs 分层索引）
 * <li>内存开销：每个对象额外 ~32 bytes（复合键字符串）
 * <li>构建时间：~100ns（长度前缀编码）
 * </ul>
 *
 * <p>使用示例：
 * <pre>
 * CompositeKeyOptimizer optimizer = new CompositeKeyOptimizer(EDbVendor.dbvcouchbase);
 *
 * // 检查是否可以使用复合键
 * if (optimizer.canUseCompositeKey("db.schema.table")) {
 *     // 构建复合键
 *     String key = optimizer.buildCompositeKey("db.schema.table", ESQLDataObjectType.dotTable);
 *     // 结果: "2#db|6#schema|5#table|dotTable"
 *
 *     // 存储到单一 Map
 *     compositeKeyMap.put(key, tableObject);
 * }
 * </pre>
 *
 * @since 3.1.0.9
 */
public class CompositeKeyOptimizer {

    // 全局复合键索引（仅用于 Couchbase）
    // Key: compositeKey（如 "3#db1|6#schema|5#table|dotTable"）
    // Value: TSQLSchemaObject
    private final ConcurrentHashMap<String, TSQLSchemaObject> compositeKeyMap = new ConcurrentHashMap<>();

    private final EDbVendor vendor;
    private final boolean enabled;

    /**
     * 构造复合键优化器
     *
     * @param vendor 数据库厂商
     */
    public CompositeKeyOptimizer(EDbVendor vendor) {
        this.vendor = vendor;
        this.enabled = TBaseType.USE_COMPOSITE_KEY_OPT && isSupportedVendor(vendor);
    }

    /**
     * 检查厂商是否支持复合键优化
     *
     * <p>仅支持全标识符大小写敏感的数据库：
     * <ul>
     * <li>Couchbase: 全部 SENSITIVE
     * </ul>
     *
     * @param vendor 数据库厂商
     * @return true 如果支持
     */
    private boolean isSupportedVendor(EDbVendor vendor) {
        return vendor == EDbVendor.dbvcouchbase;
    }

    /**
     * 判断是否可以使用复合键快速路径
     *
     * <p>条件（必须全部满足）：
     * <ol>
     * <li>复合键优化已启用（USE_COMPOSITE_KEY_OPT = true）
     * <li>厂商支持（Couchbase）
     * <li>限定名没有引号字符（引号会改变大小写规则）
     * </ol>
     *
     * @param qualifiedName 完整限定名（如 "db.schema.table"）
     * @return true 如果可以使用复合键
     */
    public boolean canUseCompositeKey(String qualifiedName) {
        if (!enabled) {
            return false;
        }

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

        // 检查是否包含引号字符（", ', `, [, ]）
        return !containsQuoteChar(qualifiedName);
    }

    /**
     * 构建复合键（使用长度前缀编码避免冲突）
     *
     * <p>格式: {@code len1#segment1|len2#segment2|len3#segment3|objectType}
     *
     * <p>例如: {@code "3#db1|6#schema|5#table|dotTable"}
     *
     * <p><strong>优势：</strong>避免分隔符冲突（标识符可能包含 '.' 或 '|'）
     *
     * @param qualifiedName 完整限定名（如 "db.schema.table"）
     * @param objectType 对象类型
     * @return 复合键
     */
    public String buildCompositeKey(String qualifiedName, ESQLDataObjectType objectType) {
        if (qualifiedName == null || objectType == null) {
            return null;
        }

        List<String> segments = SQLUtil.parseNames(qualifiedName);
        if (segments.isEmpty()) {
            return null;
        }

        StringBuilder sb = new StringBuilder(segments.size() * 20);
        for (int i = 0; i < segments.size(); i++) {
            String seg = segments.get(i);
            if (i > 0) {
                sb.append('|');
            }
            sb.append(seg.length()).append('#').append(seg);
        }
        sb.append('|').append(objectType.name());
        return sb.toString();
    }

    /**
     * 添加对象到复合键索引
     *
     * @param qualifiedName 完整限定名
     * @param objectType 对象类型
     * @param object schema 对象
     */
    public void put(String qualifiedName, ESQLDataObjectType objectType, TSQLSchemaObject object) {
        if (!enabled || object == null) {
            return;
        }

        String key = buildCompositeKey(qualifiedName, objectType);
        if (key != null) {
            compositeKeyMap.put(key, object);
        }
    }

    /**
     * 从复合键索引查找对象
     *
     * @param qualifiedName 完整限定名
     * @param objectType 对象类型
     * @return 找到的对象，未找到时返回 null
     */
    public TSQLSchemaObject get(String qualifiedName, ESQLDataObjectType objectType) {
        if (!enabled) {
            return null;
        }

        String key = buildCompositeKey(qualifiedName, objectType);
        if (key == null) {
            return null;
        }

        TSQLSchemaObject result = compositeKeyMap.get(key);
        if (result != null && TBaseType.LOG_INDEX_HIT_RATE) {
            System.out.println("[CompositeKey] Hit: " + objectType + " - " + qualifiedName);
        }
        return result;
    }

    /**
     * 移除对象
     *
     * @param qualifiedName 完整限定名
     * @param objectType 对象类型
     * @return 被移除的对象，未找到时返回 null
     */
    public TSQLSchemaObject remove(String qualifiedName, ESQLDataObjectType objectType) {
        if (!enabled) {
            return null;
        }

        String key = buildCompositeKey(qualifiedName, objectType);
        if (key == null) {
            return null;
        }

        return compositeKeyMap.remove(key);
    }

    /**
     * 获取索引大小
     *
     * @return 索引中的对象数量
     */
    public int size() {
        return compositeKeyMap.size();
    }

    /**
     * 清空索引
     */
    public void clear() {
        compositeKeyMap.clear();
    }

    /**
     * 检查字符串是否包含引号字符
     *
     * <p>检查常见引号字符：", ', `, [, ]
     *
     * @param str 字符串
     * @return true 如果包含引号字符
     */
    private boolean containsQuoteChar(String str) {
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c == '"' || c == '\'' || c == '`' || c == '[' || c == ']') {
                return true;
            }
        }
        return false;
    }

    /**
     * 获取是否启用
     *
     * @return true 如果已启用
     */
    public boolean isEnabled() {
        return enabled;
    }

    /**
     * 获取厂商
     *
     * @return 数据库厂商
     */
    public EDbVendor getVendor() {
        return vendor;
    }

    /**
     * 获取统计信息（用于性能分析）
     *
     * @return 统计信息字符串
     */
    public String getStats() {
        return String.format(
            "CompositeKeyOptimizer[vendor=%s, enabled=%s, objects=%d]",
            vendor, enabled, compositeKeyMap.size()
        );
    }
}