package chushihua;

import xitongshezhi.Fkj;
import xitongshezhi.SystemDebugDialog;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * 在线轮询类 - 优化版本
 * 专门用于定时轮询有卡的卡槽并发送查询指令
 * 与原有的轮询查询类互补，专注于在线设备的持续监控
 */
public class lunxunzaixian {
    private static final AtomicBoolean isRunning = new AtomicBoolean(false);
    private static final AtomicBoolean isPaused = new AtomicBoolean(false);
    private static final AtomicBoolean shouldStop = new AtomicBoolean(false);
    private static Thread onlinePollingThread;
    
    // 可配置的轮询参数（不再是final）
    private static int cycleInterval = 60000; // 完整轮询周期间隔：60秒
    private static int slotInterval = 200;    // 卡槽间查询间隔：200毫秒
    
    // 卡槽相关常量
    private static final int MIN_SLOT = 1;
    private static final int MAX_SLOT = 60;
    
    // 性能优化配置
    private static final int BATCH_SIZE = 5; // 批量查询大小
    private static int consecutiveFailures = 0;
    private static final int MAX_CONSECUTIVE_FAILURES = 3;
    
    /**
     * 启动在线轮询 - 优化版本
     * @return true-启动成功, false-启动失败
     */
    public static boolean startOnlinePolling() {
        if (isRunning.get()) {
            SystemDebugDialog.appendAsciiData("Online polling is already in progress");
            return true;
        }
        
        // 检查串口连接状态
        if (!checkSerialConnectionWithRetry()) {
            System.err.println("串口未连接，无法启动在线轮询");
            return false;
        }
        
        isRunning.set(true);
        isPaused.set(false);
        shouldStop.set(false);
        consecutiveFailures = 0;
        
        try {
            onlinePollingThread = new Thread(new OnlinePollingTask(), "Online-Polling-Thread");
            onlinePollingThread.setDaemon(true);
            onlinePollingThread.start();
            System.out.println("在线轮询已启动，周期间隔: " + cycleInterval + "ms, 卡槽间隔: " + slotInterval + "ms");
            return true;
        } catch (Exception e) {
            System.err.println("启动在线轮询线程时发生异常: " + e.getMessage());
            isRunning.set(false);
            shouldStop.set(true);
            return false;
        }
    }
    
    /**
     * 停止在线轮询 - 修复版本
     * @return true-停止成功, false-停止失败
     */
    public static boolean stopOnlinePolling() {
        if (!isRunning.get()) {
            System.out.println("在线轮询未在运行");
            return false;
        }
        
        shouldStop.set(true);
        isRunning.set(false);
        isPaused.set(false);
        
        if (onlinePollingThread != null) {
            onlinePollingThread.interrupt();
            try {
                onlinePollingThread.join(3000); // 等待3秒
                // 检查线程是否还在运行
                if (onlinePollingThread.isAlive()) {
                    System.err.println("在线轮询线程未在3秒内停止，标记为守护线程并忽略");
                    // 不强制停止，而是确保它是守护线程
                    onlinePollingThread.setDaemon(true);
                }
            } catch (InterruptedException e) {
                System.err.println("停止在线轮询时被中断: " + e.getMessage());
                Thread.currentThread().interrupt();
            } catch (Exception e) {
                System.err.println("停止在线轮询线程时发生异常: " + e.getMessage());
            } finally {
                onlinePollingThread = null;
            }
        }
        
        shouldStop.set(false);
        System.out.println("在线轮询已停止");
        return true;
    }
    
    /**
     * 暂停在线轮询
     * @return true-暂停成功, false-暂停失败
     */
    public static boolean pauseOnlinePolling() {
        if (!isRunning.get()) {
            System.out.println("在线轮询未在运行，无法暂停");
            return false;
        }
        
        if (isPaused.get()) {
            System.out.println("在线轮询已经处于暂停状态");
            return false;
        }
        
        isPaused.set(true);
        System.out.println("在线轮询已暂停");
        return true;
    }
    
    /**
     * 恢复在线轮询
     * @return true-恢复成功, false-恢复失败
     */
    public static boolean resumeOnlinePolling() {
        if (!isRunning.get()) {
            System.out.println("在线轮询未在运行，无法恢复");
            return false;
        }
        
        if (!isPaused.get()) {
            System.out.println("在线轮询未处于暂停状态");
            return false;
        }
        
        // 恢复前检查串口连接
        if (!checkSerialConnectionWithRetry()) {
            System.err.println("串口未连接，无法恢复在线轮询");
            return false;
        }
        
        isPaused.set(false);
        synchronized (lunxunzaixian.class) {
            lunxunzaixian.class.notifyAll(); // 唤醒等待的线程
        }
        System.out.println("在线轮询已恢复");
        return true;
    }
    
    /**
     * 检查在线轮询状态
     * @return true-正在运行, false-已停止
     */
    public static boolean isOnlinePolling() {
        return isRunning.get();
    }
    
    /**
     * 检查是否暂停
     * @return true-已暂停, false-未暂停
     */
    public static boolean isOnlinePaused() {
        return isPaused.get();
    }
    
    /**
     * 重新启动在线轮询
     * @return true-重启成功, false-重启失败
     */
    public static boolean restartOnlinePolling() {
        stopOnlinePolling();
        
        // 等待一小段时间确保线程完全停止
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        
        return startOnlinePolling();
    }
    
    /**
     * 设置轮询间隔参数
     * @param cycleMs 完整轮询周期间隔（毫秒）
     * @param slotMs 卡槽间查询间隔（毫秒）
     */
    public static void setPollingIntervals(int cycleMs, int slotMs) {
        cycleInterval = Math.max(cycleMs, 1000); // 最小1秒
        slotInterval = Math.max(slotMs, 50);     // 最小50毫秒
        System.out.println("在线轮询间隔已设置 - 周期间隔: " + cycleInterval + "ms, 卡槽间隔: " + slotInterval + "ms");
        
        // 如果正在运行，重新启动以应用新的间隔
        if (isRunning.get()) {
            restartOnlinePolling();
        }
    }
    
    /**
     * 获取当前轮询间隔配置
     * @return 间隔配置字符串
     */
    public static String getPollingIntervals() {
        return String.format("周期间隔: %dms, 卡槽间隔: %dms", cycleInterval, slotInterval);
    }
    
    /**
     * 获取在线轮询统计信息
     * @return 统计信息字符串
     */
    public static String getOnlinePollingStats() {
        int totalSlots = MAX_SLOT - MIN_SLOT + 1;
        int cardSlots = countCardSlots();
        
        String status;
        if (!isRunning.get()) {
            status = "已停止";
        } else if (isPaused.get()) {
            status = "已暂停";
        } else {
            status = "运行中";
        }
        
        return String.format("在线轮询状态: %s, 有卡卡槽: %d/%d, 周期间隔: %ds, 卡槽间隔: %dms", 
                           status, cardSlots, totalSlots, cycleInterval/1000, slotInterval);
    }
    
    /**
     * 统计有卡的卡槽数量
     * @return 有卡的卡槽数量
     */
    private static int countCardSlots() {
        if (SlotManager.slotArray == null) {
            return 0;
        }
        
        int count = 0;
        for (Fkj slot : SlotManager.slotArray) {
            if (slot != null && "1".equals(slot.getHasCard())) {
                count++;
            }
        }
        return count;
    }
    
    /**
     * 带重试的串口连接检查
     */
    private static boolean checkSerialConnectionWithRetry() {
        for (int i = 0; i < 3; i++) {
            if (lunxun.checkSerialConnection()) {
                return true;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return false;
    }
    
    /**
     * 在线轮询任务内部类 - 优化版本
     * 专门轮询有卡的卡槽，优化资源使用
     */
    private static class OnlinePollingTask implements Runnable {
        @Override
        public void run() {
            System.out.println("在线轮询线程开始运行");
            
            while (isRunning.get() && !Thread.currentThread().isInterrupted() && !shouldStop.get()) {
                try {
                    // 检查是否暂停
                    if (isPaused.get()) {
                        synchronized (lunxunzaixian.class) {
                            while (isPaused.get() && isRunning.get() && !shouldStop.get()) {
                                lunxunzaixian.class.wait(1000); // 等待1秒或直到被唤醒
                            }
                        }
                        continue;
                    }
                    
                    // 检查串口连接状态
                    if (!checkSerialConnectionWithRetry()) {
                        System.err.println("串口连接断开，暂停在线轮询");
                        pauseOnlinePolling();
                        continue;
                    }
                    
                    // 执行一轮有卡卡槽的轮询
                    if (pollCardSlotsOptimized()) {
                        consecutiveFailures = 0; // 重置连续失败计数
                    } else {
                        consecutiveFailures++;
                        if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
                            System.err.println("连续失败次数过多，暂停在线轮询");
                            pauseOnlinePolling();
                        }
                    }
                    
                    // 等待完整周期间隔
                    Thread.sleep(cycleInterval);
                    
                } catch (InterruptedException e) {
                    System.out.println("在线轮询线程被中断");
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    System.err.println("在线轮询过程中发生异常: " + e.getMessage());
                    consecutiveFailures++;
                    
                    // 发生异常时等待一段时间再继续
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
            
            System.out.println("在线轮询线程结束运行");
        }
        
        /**
         * 优化版本：批量轮询有卡卡槽
         * @return true-轮询成功, false-轮询失败
         */
        private boolean pollCardSlotsOptimized() {
            if (SlotManager.slotArray == null) {
                System.err.println("卡槽数组未初始化");
                return false;
            }
            
            List<Integer> cardSlots = new ArrayList<>();
            
            // 第一阶段：收集所有有卡卡槽
            for (int i = 0; i < SlotManager.slotArray.length; i++) {
                if (!isRunning.get() || Thread.currentThread().isInterrupted() || shouldStop.get()) {
                    break;
                }
                
                Fkj slot = SlotManager.slotArray[i];
                if (slot != null && "1".equals(slot.getHasCard())) {
                    cardSlots.add(i + 1);
                }
            }
            
            if (cardSlots.isEmpty()) {
                if (lunxun.DEBUG_ENABLED) {
                    System.out.println("没有找到有卡的卡槽");
                }
                return true;
            }
            
            int polledCount = 0;
            int totalCardSlots = cardSlots.size();
            
            // 第二阶段：批量查询有卡卡槽
            for (int i = 0; i < cardSlots.size(); i += BATCH_SIZE) {
                if (!isRunning.get() || Thread.currentThread().isInterrupted() || shouldStop.get()) {
                    break;
                }
                
                int end = Math.min(i + BATCH_SIZE, cardSlots.size());
                List<Integer> batch = cardSlots.subList(i, end);
                
                // 批次内查询
                for (int slotNumber : batch) {
                    if (sendQueryToCardSlot(slotNumber)) {
                        polledCount++;
                    }
                }
                
                // 批次间间隔
                if (end < cardSlots.size()) {
                    try {
                        Thread.sleep(slotInterval * BATCH_SIZE);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
            
            if (polledCount > 0 && lunxun.DEBUG_ENABLED) {
                System.out.println("在线轮询完成，成功查询 " + polledCount + "/" + totalCardSlots + " 个有卡卡槽");
            }
            
            return polledCount > 0;
        }
        
        /**
         * 向指定有卡卡槽发送查询指令
         * @param slotNumber 卡槽编号
         * @return true-发送成功, false-发送失败
         */
        private boolean sendQueryToCardSlot(int slotNumber) {
            try {
                // 使用原有的立即查询功能
                boolean result = lunxun.sendImmediateQuery(slotNumber);
                
                if (result) {
                    // 记录调试信息（减少输出频率）
                    if (lunxun.DEBUG_ENABLED && (slotNumber == 1 || slotNumber % 10 == 0)) {
                        System.out.println("在线轮询 - 查询有卡卡槽 " + slotNumber);
                    }
                    return true;
                } else {
                    System.err.println("在线轮询 - 查询有卡卡槽 " + slotNumber + " 失败");
                    return false;
                }
                
            } catch (Exception e) {
                System.err.println("在线轮询 - 查询有卡卡槽 " + slotNumber + " 时发生异常: " + e.getMessage());
                return false;
            }
        }
    }
    
    /**
     * 手动触发立即轮询（不等待周期）- 优化版本
     * @return 成功查询的卡槽数量
     */
    public static int triggerImmediatePolling() {
        if (!isRunning.get() || isPaused.get()) {
            System.err.println("在线轮询未运行或已暂停，无法立即轮询");
            return 0;
        }
        
        if (!checkSerialConnectionWithRetry()) {
            System.err.println("串口未连接，无法执行立即轮询");
            return 0;
        }
        
        System.out.println("开始立即轮询有卡卡槽...");
        
        OnlinePollingTask task = new OnlinePollingTask();
        
        // 使用新的批量轮询方法
        int cardSlotCount = countCardSlots();
        
        // 在新线程中执行立即轮询，避免阻塞当前线程
        Thread immediateThread = new Thread(() -> {
            try {
                task.pollCardSlotsOptimized();
            } catch (Exception e) {
                System.err.println("立即轮询过程中发生异常: " + e.getMessage());
            }
        }, "Immediate-Online-Polling");
        
        immediateThread.setDaemon(true);
        immediateThread.start();
        
        return cardSlotCount;
    }
    
    /**
     * 设置在线轮询暂停状态（供其他类调用）
     * @param paused true-暂停轮询, false-恢复轮询
     * @return true-设置成功, false-设置失败
     */
    public static boolean setOnlinePollingPaused(boolean paused) {
        if (!isRunning.get()) {
            System.out.println("在线轮询未在运行，无法设置暂停状态");
            return false;
        }
        
        if (paused) {
            return pauseOnlinePolling();
        } else {
            return resumeOnlinePolling();
        }
    }
    
    /**
     * 获取性能统计信息
     */
    public static String getPerformanceStats() {
        return String.format("批量大小: %d, 周期间隔: %dms, 卡槽间隔: %dms", 
                           BATCH_SIZE, cycleInterval, slotInterval);
    }
}