import java.util.*;
import java.util.concurrent.*;

/**
 * 定时任务实体：封装任务过期时间和执行逻辑
 */
class Task {
    // 任务过期时间戳（绝对时间，单位：ms）
    long expireTime;
    // 任务执行逻辑
    Runnable task;

    public Task(long delayMs, Runnable task) {
        // 基于系统当前时间 + 延迟时间 = 绝对过期时间
        this.expireTime = System.currentTimeMillis() + delayMs;
        this.task = task;
    }

    // 判断任务是否已经过期
    public boolean isExpired() {
        return System.currentTimeMillis() >= expireTime;
    }
}

/**
 * 单层时间轮 基础轮：所有层级的时间轮都基于此实现
 */
class TimeWheel {
    // 每一格时间（指针每次跳动的时间间隔）
    private final long tickMs;
    // 轮盘槽位数量
    private final int wheelSize;
    // 当前层总周期 = 格子时间 * 槽位数（走完一圈的时间）
    private final long interval;
    // 当前指针所在的时间（累计走过的总时间）
    private long currentTime;
    // 每个槽位存放一个任务链表（同一时刻到期的任务存在同一个链表）
    private final LinkedList<Task>[] slots;
    // 上一层时间轮（高层）：当前层走完一圈，驱动上层指针跳动
    private TimeWheel upperWheel;

    @SuppressWarnings("unchecked")
    public TimeWheel(long tickMs, int wheelSize) {
        this.tickMs = tickMs;
        this.wheelSize = wheelSize;
        this.interval = tickMs * wheelSize;
        this.currentTime = System.currentTimeMillis();
        this.slots = new LinkedList[wheelSize];
        // 初始化所有槽位的任务链表（避免空指针）
        for (int i = 0; i < wheelSize; i++) {
            slots[i] = new LinkedList<>();
        }
    }

    // 设置上层时间轮（绑定层级关系）
    public void setUpperWheel(TimeWheel upperWheel) {
        this.upperWheel = upperWheel;
    }

    /**
     * 添加任务到当前时间轮
     * @param task 要添加的任务
     * @return 是否添加成功（false：延迟超过当前层周期，需交给上层）
     */
    public boolean addTask(Task task) {
        long delay = task.expireTime - currentTime;
        // 任务已经过期，直接执行
        if (delay <= 0) {
            task.task.run();
            return true;
        }
        // 延迟时间超过当前轮总周期 -> 无法存放，交给上层时间轮处理
        if (delay >= interval) {
            return false;
        }

        // 计算任务应该落在当前轮的哪个槽位
        long slotIndex = (currentTime + delay) / tickMs;
        int index = (int) (slotIndex % wheelSize);
        slots[index].add(task);
        return true;
    }

    /**
     * 时间指针向前推进一格（核心方法）
     * 1. 推进指针时间
     * 2. 执行当前槽位所有到期任务
     * 3. 未到期任务重新分配槽位
     * 4. 判断是否走完一圈，驱动上层指针跳动
     */
    public void tick() {
        // 1、指针前进一格：累加当前层的每格时间
        currentTime += tickMs;

        // 2、计算当前指针落在哪个槽位（取模确保槽位在合法范围）
        int slotIdx = (int) (currentTime / tickMs % wheelSize);
        LinkedList<Task> slotTasks = slots[slotIdx];

        // 3、处理当前槽位的所有任务（避免并发修改，先复制到临时列表）
        if (!slotTasks.isEmpty()) {
            List&lt;Task&gt; temp = new ArrayList<>(slotTasks);
            slotTasks.clear(); // 清空当前槽，避免重复处理

            for (Task task : temp) {
                if (task.isExpired()) {
                    // 任务到期：直接执行
                    task.task.run();
                } else {
                    // 任务未到期：重新加入当前轮，重新分配槽位（为下沉做准备）
                    this.addTask(task);
                }
            }
        }

        // 4、关键：判断当前轮是否刚走完一整圈，驱动上层指针跳动
        if (currentTime % interval == 0 && upperWheel != null) {
            upperWheel.tick();
        }
    }
}

/**
 * 多层时间轮 完整实现（模仿 Kafka 三层时间轮）
 * 层级关系：Level3（高层）→ Level2（中层）→ Level1（底层）
 */
public class MultiLevelTimeWheel {
    // 三层时间轮实例
    private final TimeWheel level1; // 底层（精度最高）
    private final TimeWheel level2; // 中层
    private final TimeWheel level3; // 高层

    // 定时调度器：驱动底层指针持续跳动（每10ms跳一次）
    private final ScheduledExecutorService scheduler;

    public MultiLevelTimeWheel() {
        // 1. 构建三层时间轮（从高层到底层，逐层绑定）
        level3 = new TimeWheel(36 * 1000L, 60); // 1格=36s，60槽，周期36分钟
        level2 = new TimeWheel(600L, 60);      // 1格=600ms，60槽，周期36s
        level1 = new TimeWheel(10L, 60);       // 1格=10ms，60槽，周期600ms

        // 2. 绑定层级联动：底层走完一圈→中层动；中层走完一圈→高层动
        level1.setUpperWheel(level2);
        level2.setUpperWheel(level3);

        // 3. 启动驱动：每10ms触发一次底层的tick()，驱动整个时间轮
        scheduler = Executors.newSingleThreadScheduledExecutor();
        scheduler.scheduleAtFixedRate(this::driveTick, 0, 10, TimeUnit.MILLISECONDS);
    }

    // 驱动整个多层时间轮转动（仅驱动底层，上层靠底层触发）
    private void driveTick() {
        level1.tick();
    }

    /**
     * 对外提供的任务添加接口
     * @param delayMs 任务延迟时间（单位：ms）
     * @param runnable 任务执行逻辑
     */
    public void addTask(long delayMs, Runnable runnable) {
        Task task = new Task(delayMs, runnable);
        // 从最底层开始尝试放入，放不进去就逐级往上抛
        boolean success = level1.addTask(task);
        if (!success) {
            success = level2.addTask(task);
        }
        if (!success) {
            level3.addTask(task);
        }
    }

    // 关闭时间轮（释放资源）
    public void close() {
        scheduler.shutdown();
    }
}

// ===================== 测试主类：验证下沉流程和任务执行 =====================
class TimeWheelTest {
    public static void main(String[] args) {
        MultiLevelTimeWheel multiWheel = new MultiLevelTimeWheel();

        System.out.println("=== 多层时间轮测试开始 ===");
        long startTime = System.currentTimeMillis();

        // 测试1：短延迟任务（500ms）→ 直接放入底层，到期执行
        multiWheel.addTask(500, () -> {
            System.out.printf("[短任务-500ms] 执行时间：%dms%n", System.currentTimeMillis() - startTime);
        });

        // 测试2：中延迟任务（5000ms=5s）→ 先放入中层，下沉到底层执行
        multiWheel.addTask(5000, () -> {
            System.out.printf("[中任务-5s] 执行时间：%dms%n", System.currentTimeMillis() - startTime);
        });

        // 测试3：长延迟任务（20000ms=20s）→ 先放入中层，下沉到底层执行
        multiWheel.addTask(20000, () -> {
            System.out.printf("[长任务-20s] 执行时间：%dms%n", System.currentTimeMillis() - startTime);
        });

        // 测试4：超长延迟任务（40000ms=40s）→ 先放入高层，下沉到中层，再下沉到底层执行
        multiWheel.addTask(40000, () -> {
            System.out.printf("[超长任务-40s] 执行时间：%dms%n", System.currentTimeMillis() - startTime);
        });

        // 运行足够长时间，确保所有任务执行完成
        try {
            Thread.sleep(45000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        multiWheel.close();
        System.out.println("=== 多层时间轮测试结束 ===");
    }
}

public void tick() {
    // 1. 指针前进一格：累加当前层的每格时间（比如底层每次加10ms）
    currentTime += tickMs;

    // 2. 计算当前指针所在的槽位（确保槽位在0~wheelSize-1之间）
    int slotIdx = (int) (currentTime / tickMs % wheelSize);
    LinkedList<Task> slotTasks = slots[slotIdx];

    // 3. 处理当前槽位的任务：执行到期任务，未到期任务重新分配
    if (!slotTasks.isEmpty()) {
        List<Task> temp = new ArrayList<>(slotTasks);
        slotTasks.clear();

        for (Task task : temp) {
            if (task.isExpired()) {
                task.task.run(); // 到期任务执行
            } else {
                this.addTask(task); // 未到期，重新入队（为下沉做准备）
            }
        }
    }

    // 4. 关键：判断当前轮是否刚走完一整圈，驱动上层指针跳动
    if (currentTime % interval == 0 && upperWheel != null) {
        upperWheel.tick();
    }
}

// 领域层类 - 包含核心业务逻辑
public class Order {
    private Long id;
    private User user;
    private List<OrderItem> items;
    private OrderStatus status;
    
    // 领域方法：业务规则在此实现
    public void addItem(Product product, int qty) {
        if (status != OrderStatus.CREATED) {
            throw new IllegalStateException("只能修改待支付订单");
        }
        items.add(new OrderItem(product, qty));
        recalculateTotal();
    }
    
    public void pay() {
        this.status = OrderStatus.PAID;
    }
}

public class Student {
    private String id;
    private String name;
    
    public Enrollment enroll(Course course) {
        if (course.hasCapacity()) {
            return new Enrollment(this, course);
        }
        throw new RuntimeException("课程已满");
    }
}

public class Course {
    private String code;
    private String name;
    private int capacity;
    private int enrolledCount;
    private Teacher teacher;
    
    public boolean hasCapacity() {
        return enrolledCount < capacity;
    }
}

import org.springframework.ai.vectorstore.SearchRequest;

private PromptResult buildPromptWithSources(String message, String knowledgeBaseId) {
    if (knowledgeBaseId == null) {
        log.debug("[Prompt构建] 未指定知识库，直接返回用户消息");
        return new PromptResult(message, null);
    }

    log.info("[Prompt构建] 知识库ID: {}, 开始检索相关文档", knowledgeBaseId);

    // 使用 SearchRequest 设置相似度阈值和返回数量
    SearchRequest searchRequest = SearchRequest.builder()
        .query(message)
        .topK(20)                    // 增加初始检索数量，后续再过滤
        .similarityThreshold(0.5)    // 设置相似度阈值 0.5（可根据实际情况调整）
        .build();

    List<Document> relevantDocs = vectorStore.similaritySearch(searchRequest);
    log.debug("[Prompt构建] 检索到 {} 个相关文档", relevantDocs.size());
    
    // ... 后续逻辑保持不变
}

private PromptResult buildPromptWithSources(String message, String knowledgeBaseId) {
    // ... 前面的代码 ...

    List<Document> relevantDocs = vectorStore.similaritySearch(searchRequest);
    
    // 按相似度分数排序（从高到低）
    relevantDocs.sort((d1, d2) -> {
        Double score1 = (Double) d1.getMetadata().get("distance");
        Double score2 = (Double) d2.getMetadata().get("distance");
        return Double.compare(score2 != null ? score2 : 0, score1 != null ? score1 : 0);
    });

    // 过滤并限制结果
    List<Document> filteredDocs = relevantDocs.stream()
        .filter(doc -> {
            // 知识库ID过滤
            Object kbId = doc.getMetadata().get(Constants.VectorStore.METADATA_KNOWLEDGE_BASE_ID);
            boolean kbMatch = kbId != null && kbId.equals(knowledgeBaseId);
            
            // 相似度过滤（如果 SearchRequest 的阈值不够，可以在这里二次过滤）
            Double score = (Double) doc.getMetadata().get("distance");
            boolean scoreMatch = score == null || score >= 0.7; // 相似度阈值
            
            return kbMatch && scoreMatch;
        })
        .limit(Constants.Chat.MAX_CONTEXT_LENGTH)
        .collect(Collectors.toList());

    // ... 后续代码 ...
}

public static final class VectorStore {
    public static final int CHUNK_SIZE = 800;      // 从 1000 调整为 800
    public static final int CHUNK_OVERLAP = 100;   // 从 200 调整为 100
    // ... 其他常量
}

List<DocumentSourceDTO> documentSources = docsByDocumentId.entrySet().stream()
    .map(entry -> {
        String docId = entry.getKey();
        List<Document> docChunks = entry.getValue();
        Document firstDoc = docChunks.get(0);

        Object docName = firstDoc.getMetadata().get(Constants.VectorStore.METADATA_DOCUMENT_NAME);
        Object kbName = firstDoc.getMetadata().get(Constants.VectorStore.METADATA_KNOWLEDGE_BASE_NAME);
        
        // 获取相似度分数
        Double score = (Double) firstDoc.getMetadata().get("distance");
        if (score == null) {
            score = 0.0;
        }

        // 收集所有分块的片段内容
        List<String> snippets = docChunks.stream()
            .map(doc -> {
                String text = doc.getText();
                return text.length() > 200 ? text.substring(0, 200) + "..." : text;
            })
            .collect(Collectors.toList());

        return DocumentSourceDTO.builder()
            .documentId(docId.equals("unknown") ? null : docId)
            .documentName(docName != null ? docName.toString() : "未知文档")
            .knowledgeBaseName(kbName != null ? kbName.toString() : "未知知识库")
            .score(score)  // 设置相似度分数
            .snippet(snippets.isEmpty() ? "" : snippets.get(0))
            .snippets(snippets)
            .build();
    })
    // 按相似度分数排序
    .sorted((s1, s2) -> Double.compare(s2.getScore() != null ? s2.getScore() : 0, 
                                       s1.getScore() != null ? s1.getScore() : 0))
    .collect(Collectors.toList());

// 从 metadata 中获取的是余弦距离
Object distanceObj = doc.getMetadata().get("distance");
double distance = ((Number) distanceObj).doubleValue();

// 转换为相似度（范围 0~1）
double similarity = 1.0 - distance;

// 推荐阈值范围
double similarityThreshold = 0.5;  // 平衡精度和召回率（当前推荐）
double similarityThreshold = 0.55; // 更严格，可能过滤部分内容
double similarityThreshold = 0.45; // 更宽松，可能包含更多内容