package gudusoft.gsqlparser.sqlenv;

import java.text.Collator;
import java.util.*;

/**
 * 分桶索引（SQL Server COLLATION_BASED 专用）
 *
 * <p>用于优化 SQL Server 的 schema 对象查找，将 O(N) 全表扫描优化为 O(1) + O(bucket_size)。
 *
 * <p><strong>核心思想：</strong>
 * <ul>
 * <li>桶键 = the collation key of the name under the bucket's own collator, so a bucket is
 *     exactly one class of names the collator compares equal
 * <li>相同桶键的对象放在同一桶内
 * <li>查找时先定位桶（O(1)），再用 Collator 比较桶内对象（O(bucket_size)）
 * </ul>
 *
 * <p><strong>性能特性：</strong>
 * <ul>
 * <li>10,000 对象场景：从 ~20μs（全表扫描）优化到 ~800ns（分桶）
 * <li>性能提升：~25x
 * <li>内存开销：每个对象额外 ~8 bytes（HashMap overhead）
 * </ul>
 *
 * <p>使用示例：
 * <pre>
 * CollatorProvider provider = new CollatorProvider();
 * BucketedIndex index = new BucketedIndex(provider, "SQL_Latin1_General_CP1_CI_AS");
 *
 * // 添加对象
 * index.put("MyTable", tableObject);
 * index.put("MYTABLE", tableObject2);  // 同一桶（CI: one collation key）
 *
 * // 查找对象（使用 Collator 比较）
 * TSQLSchemaObject found = index.get("myTable");  // CI: 能找到
 * </pre>
 *
 * @since 3.1.0.9
 */
public class BucketedIndex {

    // 桶索引：bucketKey → 候选对象列表
    private final Map<String, List<TSQLSchemaObject>> buckets = new HashMap<>();

    private final CollatorProvider collatorProvider;
    private final String collationName;
    private final ESQLDataObjectType objectType;

    /**
     * 构造分桶索引
     *
     * @param collatorProvider Collator 提供者（ThreadLocal 缓存）
     * @param collationName SQL Server collation 名称
     * @param objectType 对象类型（用于日志）
     */
    public BucketedIndex(CollatorProvider collatorProvider, String collationName, ESQLDataObjectType objectType) {
        this.collatorProvider = collatorProvider;
        this.collationName = collationName;
        this.objectType = objectType;
    }

    /**
     * 添加对象到桶
     *
     * <p>语义：与 {@link java.util.HashMap#put} 一致——若桶内已存在与 {@code name} 在
     * collation 下相等的条目，则替换之；否则追加。这样 BucketedIndex 与 schemaObjectMap
     * （legacy）/ tables（hierarchical）三处索引在重复写入时一致采用 overwrite 语义，
     * 避免 {@link #get} 在 case-different 重复 put 后返回较早条目而 legacy/hierarchical
     * 返回较晚条目的不对称（slice S3 修复）。
     *
     * <p><strong>已知遗留问题（slice S3 范围外，待 S4 处理）：</strong>
     * {@link #computeBucketKey} 与 collator 比较都基于 raw {@code name}，不剥离 vendor
     * delimiter（{@code []} / {@code ""} / {@code ``}）。因此 SQL Server 下以加引号
     * 与不加引号写入的等价标识符（如 {@code "[FOO]"} 与 {@code "foo"}）会落入不同的桶，
     * 而 legacy {@code SQLUtil.getIdentifierNormalName} 会把两者归一化为同一 key
     * （{@code "FOO"}）。此差异在 SQL Server + bucketed flag 启用 + 直接构造重复 table
     * 的窄场景下出现；正常使用 {@code createTable} 不会触发，因为它在构造前会先
     * dedupe。后续修复方向：在 {@code computeBucketKey} 与 collator 比较时先剥离
     * vendor delimiter（需要在 {@link BucketedIndex} 引入 vendor / delimiter
     * stripper 上下文）。
     *
     * @param name 对象名称
     * @param object schema 对象
     */
    public void put(String name, TSQLSchemaObject object) {
        if (name == null || object == null) {
            return;
        }

        String bucketKey = computeBucketKey(name);

        // buckets 与桶内 ArrayList 均非线程安全；共享 TSQLEnv 下注册与查找并发进行
        synchronized (buckets) {
            List<TSQLSchemaObject> bucket = buckets.computeIfAbsent(bucketKey,
                k -> new ArrayList<>());

            Collator collator = collatorProvider.getCollator(collationName);
            for (int i = 0; i < bucket.size(); i++) {
                if (collator.compare(name, bucket.get(i).name) == 0) {
                    bucket.set(i, object);
                    return;
                }
            }
            bucket.add(object);
        }
    }

    /**
     * 查找对象（先定位桶，再 Collator 比较）
     *
     * @param name 对象名称
     * @return 找到的对象，未找到时返回 null
     */
    public TSQLSchemaObject get(String name) {
        if (name == null) {
            return null;
        }

        String bucketKey = computeBucketKey(name);

        synchronized (buckets) {
            List<TSQLSchemaObject> candidates = buckets.get(bucketKey);
            if (candidates == null || candidates.isEmpty()) {
                return null;  // 桶不存在
            }

            // 在候选列表中使用 Collator 比较（通常 < 20 个对象）
            Collator collator = collatorProvider.getCollator(collationName);
            for (TSQLSchemaObject candidate : candidates) {
                if (collator.compare(name, candidate.name) == 0) {
                    return candidate;  // 找到匹配
                }
            }

            return null;  // 未找到
        }
    }

    /**
     * 移除对象
     *
     * @param name 对象名称
     * @param object 要移除的对象
     * @return true 如果成功移除
     */
    public boolean remove(String name, TSQLSchemaObject object) {
        if (name == null || object == null) {
            return false;
        }

        String bucketKey = computeBucketKey(name);

        synchronized (buckets) {
            List<TSQLSchemaObject> bucket = buckets.get(bucketKey);
            if (bucket != null) {
                boolean removed = bucket.remove(object);
                if (bucket.isEmpty()) {
                    buckets.remove(bucketKey);  // 清理空桶
                }
                return removed;
            }

            return false;
        }
    }

    /**
     * 获取所有对象（用于遍历）
     *
     * @return 所有对象的列表
     */
    public List<TSQLSchemaObject> getAllObjects() {
        List<TSQLSchemaObject> result = new ArrayList<>();
        synchronized (buckets) {
            for (List<TSQLSchemaObject> bucket : buckets.values()) {
                result.addAll(bucket);
            }
        }
        return result;
    }

    /**
     * 获取桶数量（用于调试）
     *
     * @return 桶的数量
     */
    public int getBucketCount() {
        synchronized (buckets) {
            return buckets.size();
        }
    }

    /**
     * 获取对象数量
     *
     * @return 对象总数
     */
    public int getObjectCount() {
        int count = 0;
        synchronized (buckets) {
            for (List<TSQLSchemaObject> bucket : buckets.values()) {
                count += bucket.size();
            }
        }
        return count;
    }

    /**
     * 计算桶键：the collation key of the name under the SAME collator the bucket compares with.
     *
     * <p>Two names fall in one bucket exactly when the collator compares them equal (Java
     * {@link java.text.CollationKey} equality is {@code compare == 0}), so a bucket is one
     * equivalence class and a lookup can never miss an equal name in another bucket. The
     * earlier key (ASCII lower case + length) assumed only ASCII letters vary between equal
     * names: under {@code _AI} {@code café} and {@code cafe} were equal but bucketed apart, and
     * under {@code _CI} so were {@code Ä} and {@code ä}, and {@code ß} and {@code ss} (different
     * lengths).
     *
     * @param name 对象名称
     * @return 桶键
     */
    private String computeBucketKey(String name) {
        byte[] key = collatorProvider.getCollator(collationName).getCollationKey(name).toByteArray();
        return new String(key, java.nio.charset.StandardCharsets.ISO_8859_1);
    }

    /**
     * 获取桶统计信息（用于性能分析）
     *
     * @return 桶统计信息字符串
     */
    public String getBucketStats() {
        synchronized (buckets) {
            if (buckets.isEmpty()) {
                return "Empty index";
            }

            int totalObjects = 0;
            int maxBucketSize = 0;
            int minBucketSize = Integer.MAX_VALUE;

            for (List<TSQLSchemaObject> bucket : buckets.values()) {
                int size = bucket.size();
                totalObjects += size;
                maxBucketSize = Math.max(maxBucketSize, size);
                minBucketSize = Math.min(minBucketSize, size);
            }

            double avgBucketSize = (double) totalObjects / buckets.size();

            return String.format(
                "Buckets: %d, Objects: %d, Avg/Min/Max per bucket: %.2f/%d/%d",
                buckets.size(), totalObjects, avgBucketSize, minBucketSize, maxBucketSize
            );
        }
    }
}