package publicway;

public class OpenDoor {
    // 常量定义
    private static final String HEADER = "DDCC0008F0";
    private static final String FUNCTION_CODE_PREFIX = "515AA55AA5";
    
    // 开门类型常量
    public static final int TYPE_ISSUE_CARD = 1;
    public static final int TYPE_ADMIN = 2;
    
    // 参数范围常量
    private static final int MIN_SLOT_NUMBER = 0;
    private static final int MAX_SLOT_NUMBER = 255;
    
    // 默认间隔时间（毫秒）
    private static final int DEFAULT_INTERVAL_MS = 250;
    
    /**
     * 开一个柜门
     * 
     * @param slotNumber 柜门编号 (0-255)
     * @param type 开门类型 (1:发卡开门, 2:管理员开门)
     * @return 生成的指令字符串
     * @throws IllegalArgumentException 当参数超出范围时抛出
     * @throws RuntimeException 当生成指令过程中发生错误时抛出
     */
    public static String openOneDoor(int slotNumber, int type) {
        // 参数校验
        validateParameters(slotNumber, type);
        
        try {
            String functionCode = buildFunctionCode(type);
            String slotHex = formatSlotNumber(slotNumber);
            String baseContent = HEADER + slotHex + functionCode;
            
            return buildFinalCommand(baseContent);
        } catch (Exception e) {
            throw new RuntimeException("生成开门指令时发生错误", e);
        }
    }
    
    /**
     * 批量打开多个卡槽（从1到N）
     * 
     * @param totalSlots 卡槽总数N (1-255)
     * @param intervalMs 发送指令间隔时间（毫秒），默认250ms
     * @param type 开门类型 (1:发卡开门, 2:管理员开门)
     * @return 生成的指令字符串数组
     * @throws IllegalArgumentException 当参数超出范围时抛出
     */
    public static String[] openAllSlots(int totalSlots, Integer intervalMs, int type) {
        // 参数校验
        if (totalSlots < 1 || totalSlots > MAX_SLOT_NUMBER) {
            throw new IllegalArgumentException(
                String.format("卡槽总数必须在1-%d范围内", MAX_SLOT_NUMBER));
        }
        
        validateType(type);
        
        // 使用默认间隔时间如果未提供
        int actualInterval = intervalMs != null ? intervalMs : DEFAULT_INTERVAL_MS;
        if (actualInterval < 0) {
            throw new IllegalArgumentException("间隔时间不能为负数");
        }
        
        String[] commands = new String[totalSlots];
        
        try {
            for (int i = 0; i < totalSlots; i++) {
                int slotNumber = i + 1; // 从1开始
                String command = openOneDoor(slotNumber, type);
                commands[i] = command;
                
                // 如果不是最后一个指令，则等待指定间隔
                if (i < totalSlots - 1 && actualInterval > 0) {
                    try {
                        Thread.sleep(actualInterval);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException("开门指令发送被中断", e);
                    }
                }
            }
            
            System.out.println(String.format("成功生成 %d 个开门指令，间隔 %d 毫秒", totalSlots, actualInterval));
            return commands;
            
        } catch (Exception e) {
            throw new RuntimeException("生成批量开门指令时发生错误", e);
        }
    }
    
    /**
     * 批量打开多个卡槽（使用默认间隔时间）
     * 
     * @param totalSlots 卡槽总数N (1-255)
     * @param type 开门类型 (1:发卡开门, 2:管理员开门)
     * @return 生成的指令字符串数组
     */
    public static String[] openAllSlots(int totalSlots, int type) {
        return openAllSlots(totalSlots, null, type);
    }
    
    /**
     * 异步批量打开多个卡槽（不阻塞当前线程）
     * 
     * @param totalSlots 卡槽总数N (1-255)
     * @param intervalMs 发送指令间隔时间（毫秒）
     * @param type 开门类型 (1:发卡开门, 2:管理员开门)
     * @param callback 回调接口，用于接收生成的指令和处理进度
     */
    public static void openAllSlotsAsync(int totalSlots, Integer intervalMs, int type, OpenDoorCallback callback) {
        // 参数校验
        if (totalSlots < 1 || totalSlots > MAX_SLOT_NUMBER) {
            if (callback != null) {
                callback.onError(new IllegalArgumentException(
                    String.format("卡槽总数必须在1-%d范围内", MAX_SLOT_NUMBER)));
            }
            return;
        }
        
        if (callback == null) {
            throw new IllegalArgumentException("回调接口不能为null");
        }
        
        validateType(type);
        
        // 在新线程中执行批量开门
        new Thread(() -> {
            try {
                int actualInterval = intervalMs != null ? intervalMs : DEFAULT_INTERVAL_MS;
                String[] commands = new String[totalSlots];
                
                for (int i = 0; i < totalSlots; i++) {
                    int slotNumber = i + 1;
                    String command = openOneDoor(slotNumber, type);
                    commands[i] = command;
                    
                    // 通知进度
                    callback.onProgress(slotNumber, totalSlots, command);
                    
                    // 等待间隔
                    if (i < totalSlots - 1 && actualInterval > 0) {
                        Thread.sleep(actualInterval);
                    }
                }
                
                callback.onComplete(commands);
                
            } catch (Exception e) {
                callback.onError(e);
            }
        }).start();
    }
    
    /**
     * 验证输入参数
     */
    private static void validateParameters(int slotNumber, int type) {
        if (slotNumber < MIN_SLOT_NUMBER || slotNumber > MAX_SLOT_NUMBER) {
            throw new IllegalArgumentException(
                String.format("柜门编号必须在%d-%d范围内", MIN_SLOT_NUMBER, MAX_SLOT_NUMBER));
        }
        
        validateType(type);
    }
    
    /**
     * 验证开门类型
     */
    private static void validateType(int type) {
        if (type != TYPE_ISSUE_CARD && type != TYPE_ADMIN) {
            throw new IllegalArgumentException("开门类型参数无效，应为1或2");
        }
    }
    
    /**
     * 构建功能码
     */
    private static String buildFunctionCode(int type) {
        return FUNCTION_CODE_PREFIX + String.format("%02X", type);
    }
    
    /**
     * 格式化柜门编号为16进制
     */
    private static String formatSlotNumber(int slotNumber) {
        return String.format("%02X", slotNumber);
    }
    
    /**
     * 构建最终指令（添加CRC校验）
     */
    private static String buildFinalCommand(String baseContent) {
        byte[] cmdBytes = HexUtil.hexStringToBytes(baseContent);
        String crc = HexUtil.calculate(cmdBytes);
        String finalContent = baseContent + crc;
        
        System.out.println("生成的开门指令: " + finalContent);
        return finalContent;
    }
    
    /**
     * 开门回调接口
     */
    public interface OpenDoorCallback {
        /**
         * 进度回调
         * @param currentSlot 当前处理的卡槽编号
         * @param totalSlots 总卡槽数量
         * @param command 生成的指令
         */
        void onProgress(int currentSlot, int totalSlots, String command);
        
        /**
         * 完成回调
         * @param commands 所有生成的指令数组
         */
        void onComplete(String[] commands);
        
        /**
         * 错误回调
         * @param error 异常信息
         */
        void onError(Exception error);
    }
}