/**
 * TRAE原则演示类
 * 展示Testability(可测试性)、Reusability(可重用性)、Accessibility(可访问性)、Extensibility(可扩展性)
 */
import com.smart.home.basic.DeviceManager;
import com.smart.home.basic.SmartDevice;
import com.smart.home.basic.PowerControl;
import com.smart.home.advanced.SmartDoor;
import com.smart.home.advanced.SmartSafe;
import com.smart.home.advanced.Lockable;
import com.smart.home.advanced.Monitored;
import com.smart.home.advanced.Alarmable;
import com.smart.home.advanced.SecurityCamera;
import com.smart.home.challenge.SmartLightBulb;
import com.smart.home.challenge.SmartAirConditioner;
import com.smart.home.challenge.SmartSpeaker;
import com.smart.home.challenge.SmartCurtain;
import java.util.List;
import java.util.ArrayList;
import java.util.Optional;

/**
 * 智能设备测试工具类
 * 提供通用的设备测试方法，展示工厂方法模式的应用
 */
class DeviceTestUtil {
    // 工厂方法：创建设备管理器
    public static DeviceManager createDeviceManager() {
        return new DeviceManager();
    }
    
    // 通用测试方法：验证设备状态
    public static void verifyDeviceStatus(SmartDevice device, String expectedStatus) {
        String actualStatus = device.getStatusDescription();
        System.out.println("   - 验证状态: " + actualStatus);
        if (actualStatus.contains(expectedStatus)) {
            System.out.println("     * 状态验证通过");
        } else {
            System.out.println("     * 状态验证失败，期望包含: " + expectedStatus);
        }
    }
}

public class TRAEPrincipleDemo {
    
    /**
     * 主方法
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        System.out.println("===== TRAE原则程序测验 =====");
        System.out.println("TRAE: Testability(可测试性)、Reusability(可重用性)、Accessibility(可访问性)、Extensibility(可扩展性)");
        
        // 1. 可测试性 (Testability) 演示
        demonstrateTestability();
        
        // 2. 可重用性 (Reusability) 演示
        demonstrateReusability();
        
        // 3. 可访问性 (Accessibility) 演示
        demonstrateAccessibility();
        
        // 4. 可扩展性 (Extensibility) 演示
        demonstrateExtensibility();
        
        System.out.println("\n===== TRAE原则测验完成 =====");
    }
    
    /**
     * 演示可测试性 (Testability)
     * 通过接口隔离和依赖注入实现易于测试的设计
     * 增强了异常处理和参数验证以提高代码健壮性
     */
    private static void demonstrateTestability() {
        System.out.println("\n1. 可测试性 (Testability) 演示：");
        System.out.println("   - 使用接口隔离原则，每个接口职责单一，易于模拟测试");
        System.out.println("   - 通过接口实现松耦合，便于单元测试和集成测试");
        System.out.println("   - 增加异常处理和参数验证，提高测试健壮性");
        
        // 测试场景1: 智能设备基本功能测试
        System.out.println("   测试场景1: 智能灯光控制功能测试");
        
        try {
            // 使用工厂方法创建测试对象，符合依赖注入原则
            DeviceManager testManager = DeviceTestUtil.createDeviceManager();
            
            // 参数验证示例
            String deviceId = "TEST_LIGHT";
            String deviceName = "测试灯泡";
            
            if (deviceId == null || deviceId.trim().isEmpty()) {
                throw new IllegalArgumentException("设备ID不能为空");
            }
            
            SmartLightBulb testLight = new SmartLightBulb(deviceId, deviceName);
            testManager.addDevice(testLight);
            
            // 验证初始状态
            System.out.println("   - 初始状态测试: " + testLight.getStatusDescription());
            
            // 执行测试操作
            System.out.println("   - 执行测试操作...");
            testManager.turnOnDevice(deviceId);
            
            // 参数边界测试
            testLight.setBrightness(0); // 边界值测试
            System.out.println("   - 亮度边界值测试(0%): " + testLight.getStatusDescription());
            
            testLight.setBrightness(100); // 边界值测试
            System.out.println("   - 亮度边界值测试(100%): " + testLight.getStatusDescription());
            
            // 正常值测试
            testLight.setBrightness(75);
            testLight.setColor("蓝色");
            
            // 使用工具类验证状态
            DeviceTestUtil.verifyDeviceStatus(testLight, "蓝色");
            DeviceTestUtil.verifyDeviceStatus(testLight, "75%");
            
        } catch (IllegalArgumentException e) {
            System.out.println("   - 参数验证异常: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("   - 测试过程中出现异常: " + e.getMessage());
        }
        
        // 测试场景2: 安全设备功能测试和异常处理
        System.out.println("\n   测试场景2: 智能门锁安全功能测试");
        
        try {
            SmartDoor testDoor = new SmartDoor("测试门锁");
            
            // 使用断言进行状态验证
            boolean initialLockedState = testDoor.isLocked();
            System.out.println("   - 初始锁定状态: " + initialLockedState);
            
            // 测试锁定/解锁功能
            System.out.println("   - 执行锁定操作");
            testDoor.lock();
            System.out.println("   - 锁定后状态: " + testDoor.isLocked());
            
            System.out.println("   - 执行解锁操作");
            testDoor.unlock();
            System.out.println("   - 解锁后状态: " + testDoor.isLocked());
            
            // 测试边界条件和异常场景
            System.out.println("   - 重复锁定测试:");
            testDoor.lock(); // 先锁定
            testDoor.lock(); // 重复锁定
            
            // 演示异常情况处理
            System.out.println("   - 演示异常状态处理");
            // 假设尝试在已锁定状态下执行某些操作
            
        } catch (SecurityException e) {
            System.out.println("   - 安全异常: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("   - 测试异常: " + e.getMessage());
        }
        
        // 测试场景3: 空值和边界情况测试
        System.out.println("\n   测试场景3: 空值和边界情况测试");
        try {
            DeviceManager nullTestManager = DeviceTestUtil.createDeviceManager();
            // 测试设备不存在的情况
            System.out.println("   - 测试设备不存在场景...");
            nullTestManager.turnOnDevice("NON_EXISTENT_DEVICE");
        } catch (IllegalArgumentException e) {
            System.out.println("   - 预期的异常捕获: " + e.getMessage());
        }
        
        System.out.println("   \n结论：通过接口编程和职责单一原则，实现了组件间的松耦合，提高了可测试性");
        System.out.println("   - 每个接口职责明确，便于模拟和测试");
        System.out.println("   - 组件间依赖通过接口而非具体实现，便于替换测试对象");
        System.out.println("   - 添加异常处理和参数验证，提高了测试的健壮性");
        System.out.println("   - 使用工具类封装通用测试方法，减少代码重复");
    }
    
    /**
     * 演示可重用性 (Reusability)
     * 通过接口组合实现功能的复用，并应用策略模式和装饰器模式
     */
    private static void demonstrateReusability() {
        System.out.println("\n2. 可重用性 (Reusability) 演示：");
        System.out.println("   - 接口可以被多个不同的类重用实现");
        System.out.println("   - 不同类型的接口在不同设备上的复用");
        System.out.println("   - 策略模式和装饰器模式的应用增强了代码的可重用性");
        
        try {
            // 使用工厂方法创建设备管理器
            DeviceManager manager = DeviceTestUtil.createDeviceManager();
            
            // 演示1: 策略模式 - PowerControl接口的重用
            System.out.println("   演示1: 策略模式 - PowerControl接口的重用：");
            
            // 创建不同的设备实现相同接口
            SmartAirConditioner ac = new SmartAirConditioner("AC001", "客厅空调");
            SmartLightBulb light = new SmartLightBulb("LIGHT001", "卧室灯");
            
            // 参数验证
            if (ac == null || light == null) {
                throw new IllegalArgumentException("设备对象创建失败");
            }
            
            manager.addDevice(ac);
            manager.addDevice(light);
            
            // 通过相同的接口方法控制不同设备 - 策略模式应用
            System.out.println("   - 使用统一电源控制策略操作不同设备");
            powerControlStrategy(ac, true);
            powerControlStrategy(light, true);
            
            // 演示2: Lockable接口的重用和装饰器模式
            System.out.println("\n   演示2: 装饰器模式 - Lockable接口的增强复用：");
            SmartDoor frontDoor = new SmartDoor("前门智能锁");
            SmartSafe safe = new SmartSafe("保险箱");
            
            // 使用增强的锁定策略
            lockableStrategy(frontDoor, true, "标准安全级别");
            lockableStrategy(safe, true, "高级安全级别");
            
            // 演示3: 状态检查方法的重用和结果格式化
            System.out.println("\n   演示3: 统一状态报告策略：");
            reportLockStatus(frontDoor);
            reportLockStatus(safe);
            
            // 演示4: 混合接口组合复用
            System.out.println("\n   演示4: 混合接口组合复用：");
            List<SmartDevice> devices = new ArrayList<>();
            devices.add(ac);
            devices.add(light);
            devices.add(frontDoor);
            
            // 统一处理不同接口能力的设备
            processMixedDevices(devices);
            
        } catch (IllegalArgumentException e) {
            System.out.println("   - 参数验证异常: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("   - 可重用性演示异常: " + e.getMessage());
        }
        
        System.out.println("   \n结论：接口的复用使得系统组件可以被多种场景使用，减少代码冗余");
        System.out.println("   - 策略模式允许在运行时选择算法或行为");
        System.out.println("   - 装饰器模式允许动态地向对象添加额外的责任");
        System.out.println("   - 统一接口减少了重复代码，提高了系统的可维护性");
        System.out.println("   - 异常处理和参数验证增强了代码的健壮性");
    }
    
    /**
     * 电源控制策略 - 策略模式实现
     * @param device 支持电源控制的设备
     * @param turnOn 是否开启设备
     */
    private static void powerControlStrategy(PowerControl device, boolean turnOn) {
        if (turnOn) {
            device.turnOn();
            System.out.println("     * 设备已开启");
        } else {
            device.turnOff();
            System.out.println("     * 设备已关闭");
        }
    }
    
    /**
     * 锁定策略 - 装饰器模式实现
     * @param device 支持锁定的设备
     * @param lock 是否锁定
     * @param securityLevel 安全级别
     */
    private static void lockableStrategy(Lockable device, boolean lock, String securityLevel) {
        System.out.println("     * 应用" + securityLevel + "锁定策略");
        
        if (lock) {
            device.lock();
            System.out.println("     * 执行锁定操作");
        } else {
            device.unlock();
            System.out.println("     * 执行解锁操作");
        }
        
        // 装饰器模式 - 添加额外的日志记录功能
        System.out.println("     * 安全操作记录已生成");
    }
    
    /**
     * 统一锁定状态报告
     * @param device 支持锁定的设备
     */
    private static void reportLockStatus(Lockable device) {
        String status = device.isLocked() ? "已锁定" : "已解锁";
        // 假设device有getName方法
        String deviceName = "设备";
        if (device instanceof SmartDevice) {
            deviceName = ((SmartDevice)device).getDeviceName();
        }
        System.out.println("     * " + deviceName + " 锁定状态: " + status);
    }
    
    /**
     * 处理混合设备集合 - 展示适配器模式思想
     * @param devices 设备列表
     */
    private static void processMixedDevices(List<SmartDevice> devices) {
        System.out.println("     * 处理混合设备集合:");
        
        for (SmartDevice device : devices) {
            System.out.println("     * " + device.getDeviceName() + ":");
            
            // 根据设备实现的接口执行不同操作
            if (device instanceof PowerControl) {
                System.out.println("       - 支持电源控制");
            }
            
            if (device instanceof Lockable) {
                System.out.println("       - 支持锁定控制");
            }
        }
    }
    
    /**
     * 演示可访问性 (Accessibility)
     * 通过统一的接口使系统组件易于访问和使用
     * 增强了适配器模式和观察者模式的应用
     */
    private static void demonstrateAccessibility() {
        System.out.println("\n3. 可访问性 (Accessibility) 演示：");
        System.out.println("   - 所有设备实现了SmartDevice接口，提供统一的访问方式");
        System.out.println("   - DeviceManager提供了统一的设备管理和访问入口");
        System.out.println("   - 适配器模式和观察者模式增强了系统的可访问性");
        
        try {
            // 创建混合设备场景
            DeviceManager manager = DeviceTestUtil.createDeviceManager();
            
            // 添加不同类型的设备
            DeviceAdapter deviceAdapter = new DeviceAdapter();
            deviceAdapter.addDevice(manager, "SPK001", "智能音箱", "SmartSpeaker");
            deviceAdapter.addDevice(manager, "AC003", "卧室空调", "SmartAirConditioner");
            deviceAdapter.addDevice(manager, "LIGHT003", "客厅灯", "SmartLightBulb");
            
            // 获取所有设备
            List<SmartDevice> allDevices = Optional.ofNullable(manager.getAllDevices())
                .orElseThrow(() -> new IllegalStateException("无法获取设备列表"));
            
            if (allDevices.isEmpty()) {
                System.out.println("   - 警告: 设备列表为空");
                return;
            }
            
            // 创建设备状态监听器 - 观察者模式
            DeviceStatusObserver statusObserver = new DeviceStatusObserver();
            
            // 演示1: 通过统一接口访问不同设备信息 - 适配器模式
            System.out.println("   演示1: 设备信息适配器模式：");
            deviceInfoAdapter(allDevices);
            
            // 演示2: 通过接口类型识别和访问特定功能 - 命令模式
            System.out.println("\n   演示2: 功能访问命令模式：");
            executeDeviceCommand(allDevices, "powerOn");
            
            // 演示3: 设备状态变化通知 - 观察者模式
            System.out.println("\n   演示3: 设备状态观察模式：");
            // 注册设备状态变化通知
            statusObserver.registerDevices(allDevices);
            
            // 改变设备状态，触发观察者通知
            for (SmartDevice device : allDevices) {
                if (device instanceof PowerControl) {
                    ((PowerControl) device).turnOff();
                    // 模拟状态变化通知
                    statusObserver.notifyStatusChanged(device, "关闭");
                }
            }
            
            // 演示4: 设备信息过滤和查询 - 过滤器模式
            System.out.println("\n   演示4: 设备过滤查询模式：");
            filterAndQueryDevices(allDevices, "空调");
            
        } catch (IllegalArgumentException e) {
            System.out.println("   - 参数错误: " + e.getMessage());
        } catch (IllegalStateException e) {
            System.out.println("   - 系统错误: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("   - 访问性演示异常: " + e.getMessage());
        }
        
        System.out.println("   \n结论：统一接口提供了一致的访问方式，降低了使用复杂度");
        System.out.println("   - 适配器模式简化了不同设备接口的访问方式");
        System.out.println("   - 观察者模式实现了设备状态变化的实时通知");
        System.out.println("   - 命令模式封装了设备操作，提高了代码的可维护性");
        System.out.println("   - 过滤器模式优化了设备查询和访问体验");
        System.out.println("   - 异常处理和参数验证增强了系统的健壮性");
    }
    
    /**
     * 设备适配器类 - 适配器模式实现
     * 统一不同设备的创建和管理方式
     */
    static class DeviceAdapter {
        public void addDevice(DeviceManager manager, String deviceId, String deviceName, String deviceType) {
            try {
                SmartDevice device = null;
                
                // 根据设备类型创建不同的设备实例
                switch (deviceType) {
                    case "SmartSpeaker":
                        device = new SmartSpeaker(deviceId, deviceName);
                        break;
                    case "SmartAirConditioner":
                        device = new SmartAirConditioner(deviceId, deviceName);
                        break;
                    case "SmartLightBulb":
                        device = new SmartLightBulb(deviceId, deviceName);
                        break;
                    default:
                        throw new IllegalArgumentException("不支持的设备类型: " + deviceType);
                }
                
                if (device != null) {
                    manager.addDevice(device);
                    System.out.println("     * 已添加" + deviceName);
                }
            } catch (Exception e) {
                System.out.println("     * 设备添加失败: " + e.getMessage());
            }
        }
    }
    
    /**
     * 设备状态观察者 - 观察者模式实现
     * 监听和处理设备状态变化
     */
    static class DeviceStatusObserver {
        public void registerDevices(List<SmartDevice> devices) {
            System.out.println("     * 已注册设备状态观察者");
        }
        
        public void notifyStatusChanged(SmartDevice device, String newStatus) {
            System.out.println("     * 状态通知: " + device.getDeviceName() + " 状态变为 " + newStatus);
        }
    }
    
    /**
     * 设备信息适配器方法
     * 统一格式输出设备信息
     */
    private static void deviceInfoAdapter(List<SmartDevice> devices) {
        System.out.println("     * 设备信息标准化输出:");
        
        for (SmartDevice device : devices) {
            try {
                System.out.println("     * 设备信息卡:");
                System.out.println("       - 名称: " + device.getDeviceName());
                System.out.println("       - ID: " + device.getDeviceId());
                System.out.println("       - 类型: " + device.getDeviceType());
                System.out.println("       - 状态: " + device.getStatusDescription());
            } catch (Exception e) {
                System.out.println("       - 获取设备信息时出错: " + e.getMessage());
            }
        }
    }
    
    /**
     * 设备命令执行器 - 命令模式
     * 统一执行不同设备的操作命令
     */
    private static void executeDeviceCommand(List<SmartDevice> devices, String command) {
        System.out.println("     * 执行命令: " + command);
        
        for (SmartDevice device : devices) {
            try {
                switch (command) {
                    case "powerOn":
                        if (device instanceof PowerControl) {
                            ((PowerControl) device).turnOn();
                            System.out.println("       - " + device.getDeviceName() + " 已开启");
                        }
                        break;
                    case "powerOff":
                        if (device instanceof PowerControl) {
                            ((PowerControl) device).turnOff();
                            System.out.println("       - " + device.getDeviceName() + " 已关闭");
                        }
                        break;
                    default:
                        System.out.println("       - 未知命令: " + command);
                }
            } catch (Exception e) {
                System.out.println("       - 执行命令失败: " + e.getMessage());
            }
        }
    }
    
    /**
     * 设备过滤和查询 - 过滤器模式
     * 根据条件过滤和查询设备
     */
    private static void filterAndQueryDevices(List<SmartDevice> devices, String keyword) {
        System.out.println("     * 过滤条件: 名称包含'" + keyword + "'");
        
        boolean found = false;
        for (SmartDevice device : devices) {
            try {
                if (device.getDeviceName().contains(keyword)) {
                    System.out.println("       - 找到匹配设备: " + device.getDeviceName());
                    found = true;
                }
            } catch (Exception e) {
                System.out.println("       - 过滤设备时出错: " + e.getMessage());
            }
        }
        
        if (!found) {
            System.out.println("       - 未找到匹配设备");
        }
    }
    }
    
    /**
     * 演示可扩展性 (Extensibility)
     * 通过接口隔离和组合实现系统的轻松扩展
     * 增强了模板方法模式、工厂方法模式和责任链模式的应用
     */
    private static void demonstrateExtensibility() {
        System.out.println("\n4. 可扩展性 (Extensibility) 演示：");
        System.out.println("   - 接口隔离原则使系统可以在不修改现有代码的情况下扩展");
        System.out.println("   - 设备可以根据需要组合实现多个接口，实现功能的灵活组合");
        System.out.println("   - 应用多种设计模式增强系统扩展性");
        
        try {
            // 使用工厂方法创建设备管理器
            DeviceManager manager = DeviceTestUtil.createDeviceManager();
            
            // 设备创建工厂
            SmartDeviceFactory deviceFactory = new SmartDeviceFactory();
            
            // 添加基础设备
            manager.addDevice(deviceFactory.createDevice("AC002", "书房空调", "SmartAirConditioner"));
            manager.addDevice(deviceFactory.createDevice("LIGHT002", "厨房灯", "SmartLightBulb"));
            
            // ===== 演示1: 模板方法模式 - 设备初始化流程 =====
            System.out.println("   演示1: 模板方法模式 - 设备初始化流程：");
            
            // 创建智能窗帘并使用模板方法初始化
            SmartCurtain livingRoomCurtain = new SmartCurtain("CURTAIN001", "客厅窗帘");
            DeviceInitializationTemplate curtainInit = new CurtainInitialization(livingRoomCurtain);
            
            // 使用模板方法执行标准初始化流程
            curtainInit.initializeDevice();
            manager.addDevice(livingRoomCurtain);
            
            // 演示智能窗帘特有的功能
            System.out.println("   - 智能窗帘特有功能操作：");
            manager.turnOnDevice("CURTAIN001");
            livingRoomCurtain.openCurtain();
            livingRoomCurtain.setCurtainPosition(50); // 设置窗帘位置为50%
            DeviceTestUtil.verifyDeviceStatus(livingRoomCurtain, "50%");
            
            // ===== 演示2: 责任链模式 - 多级安全设备处理 =====
            System.out.println("\n   演示2: 责任链模式 - 多级安全设备处理：");
            
            // 创建安全处理责任链
            SecurityHandler cameraHandler = new CameraSecurityHandler();
            SecurityHandler safeHandler = new SafeSecurityHandler();
            
            // 构建责任链
            cameraHandler.setNextHandler(safeHandler);
            
            // 创建安全设备
            SecurityCamera livingRoomCamera = new SecurityCamera("客厅摄像头");
            SmartSafe mainSafe = new SmartSafe("主卧保险箱");
            
            // 使用责任链处理不同安全设备
            System.out.println("   - 执行安全设备初始化责任链：");
            cameraHandler.handleSecurity(livingRoomCamera);
            cameraHandler.handleSecurity(mainSafe);
            
            // 演示各设备功能
            System.out.println("   - 监控设备功能测试：");
            livingRoomCamera.startMonitoring();
            System.out.println("     * " + livingRoomCamera.getMonitoringStatus());
            
            System.out.println("   - 报警功能测试：");
            livingRoomCamera.setAlarmSensitivity(8);
            livingRoomCamera.triggerAlarm();
            livingRoomCamera.stopAlarm();
            
            // ===== 演示3: 工厂方法模式 - 动态创建设备 =====
            System.out.println("\n   演示3: 工厂方法模式 - 动态创建设备：");
            
            // 动态创建新类型设备
            SmartDevice newDevice = deviceFactory.createDevice("NEW_DEVICE", "新功能设备", "Unknown");
            if (newDevice != null) {
                manager.addDevice(newDevice);
                System.out.println("     * 新设备已添加: " + newDevice.getDeviceName());
            }
            
            // ===== 演示4: 原型模式 - 设备复制与定制 =====
            System.out.println("\n   演示4: 原型模式 - 设备复制与定制：");
            
            // 尝试复制现有设备并定制
            SmartDevice copiedDevice = deviceFactory.cloneDevice(livingRoomCurtain, "CURTAIN002", "卧室窗帘");
            if (copiedDevice instanceof SmartCurtain) {
                manager.addDevice(copiedDevice);
                ((SmartCurtain) copiedDevice).setCurtainPosition(25);
                System.out.println("     * 复制设备状态: " + copiedDevice.getStatusDescription());
            }
            
            // 展示所有智能设备的状态 - 使用观察者模式通知
            System.out.println("\n   所有智能设备列表和状态：");
            List<SmartDevice> allDevices = Optional.ofNullable(manager.getAllDevices())
                .orElse(new ArrayList<>());
                
            DeviceStatusObserver observer = new DeviceStatusObserver();
            observer.registerDevices(allDevices);
            
            for (SmartDevice device : allDevices) {
                try {
                    System.out.println("   - " + device.getDeviceName() + ": " + device.getStatusDescription());
                    // 模拟状态通知
                    observer.notifyStatusChanged(device, "已加载");
                } catch (Exception e) {
                    System.out.println("   - 获取" + device.getDeviceName() + "状态时出错: " + e.getMessage());
                }
            }
            
        } catch (IllegalArgumentException e) {
            System.out.println("   - 参数错误: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("   - 扩展性演示异常: " + e.getMessage());
        }
        
        System.out.println("   \n结论：基于接口的设计实现了出色的可扩展性");
        System.out.println("   - 开闭原则：系统对扩展开放，对修改关闭");
        System.out.println("   - 接口隔离：每个接口职责单一，设备只需实现必要接口");
        System.out.println("   - 组合优于继承：通过接口组合实现功能复用和灵活扩展");
        System.out.println("   - 低耦合：新增设备类型不影响现有系统功能");
        System.out.println("   - 设计模式：模板方法、工厂方法、责任链等模式进一步增强了可扩展性");
        System.out.println("   - 异常处理：完善的异常处理机制提高了系统的健壮性");
    }
    
    /**
     * 设备初始化模板 - 模板方法模式
     * 定义设备初始化的骨架流程
     */
    abstract static class DeviceInitializationTemplate {
        protected SmartDevice device;
        
        public DeviceInitializationTemplate(SmartDevice device) {
            this.device = device;
        }
        
        // 模板方法 - 定义初始化流程骨架
        public final void initializeDevice() {
            System.out.println("     * 开始设备初始化流程");
            checkDevice();
            configureBasicSettings();
            initializeSpecificFeatures();
            testFunctionality();
            System.out.println("     * 设备初始化完成");
        }
        
        // 抽象方法 - 子类实现特定功能初始化
        protected abstract void initializeSpecificFeatures();
        
        // 具体方法 - 通用检查步骤
        private void checkDevice() {
            System.out.println("       - 检查设备连接状态");
        }
        
        // 具体方法 - 通用配置步骤
        private void configureBasicSettings() {
            System.out.println("       - 配置基础参数");
        }
        
        // 具体方法 - 通用测试步骤
        private void testFunctionality() {
            System.out.println("       - 测试设备功能");
        }
    }
    
    /**
     * 窗帘初始化实现 - 模板方法模式具体实现
     */
    static class CurtainInitialization extends DeviceInitializationTemplate {
        public CurtainInitialization(SmartDevice device) {
            super(device);
        }
        
        @Override
        protected void initializeSpecificFeatures() {
            if (device instanceof SmartCurtain) {
                SmartCurtain curtain = (SmartCurtain) device;
                System.out.println("       - 初始化窗帘特有功能");
                System.out.println("       - 设置窗帘初始位置");
                curtain.setCurtainPosition(0); // 完全关闭位置
            }
        }
    }
    
    /**
     * 智能设备工厂 - 工厂方法模式
     * 负责创建各种类型的智能设备
     */
    static class SmartDeviceFactory {
        public SmartDevice createDevice(String deviceId, String deviceName, String deviceType) {
            try {
                switch (deviceType) {
                    case "SmartAirConditioner":
                        return new SmartAirConditioner(deviceId, deviceName);
                    case "SmartLightBulb":
                        return new SmartLightBulb(deviceId, deviceName);
                    case "SmartSpeaker":
                        return new SmartSpeaker(deviceId, deviceName);
                    case "SmartCurtain":
                        return new SmartCurtain(deviceId, deviceName);
                    default:
                        System.out.println("     * 警告: 未知设备类型，返回默认设备");
                        // 这里可以返回一个默认设备或null，取决于系统设计
                        return null;
                }
            } catch (Exception e) {
                System.out.println("     * 设备创建失败: " + e.getMessage());
                return null;
            }
        }
        
        // 原型模式 - 复制现有设备
        public SmartDevice cloneDevice(SmartDevice original, String newId, String newName) {
            try {
                System.out.println("     * 复制设备: " + original.getDeviceName() + " -> " + newName);
                
                // 根据原始设备类型创建新实例
                if (original instanceof SmartCurtain) {
                    return new SmartCurtain(newId, newName);
                } else if (original instanceof SmartLightBulb) {
                    return new SmartLightBulb(newId, newName);
                } else if (original instanceof SmartAirConditioner) {
                    return new SmartAirConditioner(newId, newName);
                } else {
                    return null;
                }
            } catch (Exception e) {
                System.out.println("     * 设备复制失败: " + e.getMessage());
                return null;
            }
        }
    }
    
    /**
     * 安全处理器接口 - 责任链模式
     */
    interface SecurityHandler {
        void setNextHandler(SecurityHandler next);
        void handleSecurity(SmartDevice device);
    }
    
    /**
     * 摄像头安全处理器 - 责任链模式具体实现
     */
    static class CameraSecurityHandler implements SecurityHandler {
        private SecurityHandler nextHandler;
        
        @Override
        public void setNextHandler(SecurityHandler next) {
            this.nextHandler = next;
        }
        
        @Override
        public void handleSecurity(SmartDevice device) {
            if (device instanceof SecurityCamera) {
                System.out.println("     * 摄像头安全处理器: 处理" + device.getDeviceName());
                SecurityCamera camera = (SecurityCamera) device;
                camera.setAlarmSensitivity(7); // 默认灵敏度
                System.out.println("       - 配置默认监控参数");
            } else if (nextHandler != null) {
                // 传递给下一个处理器
                nextHandler.handleSecurity(device);
            }
        }
    }
    
    /**
     * 保险箱安全处理器 - 责任链模式具体实现
     */
    static class SafeSecurityHandler implements SecurityHandler {
        private SecurityHandler nextHandler;
        
        @Override
        public void setNextHandler(SecurityHandler next) {
            this.nextHandler = next;
        }
        
        @Override
        public void handleSecurity(SmartDevice device) {
            if (device instanceof SmartSafe) {
                System.out.println("     * 保险箱安全处理器: 处理" + device.getDeviceName());
                SmartSafe safe = (SmartSafe) device;
                safe.lock(); // 默认锁定
                System.out.println("       - 设置高级安全级别");
            } else if (nextHandler != null) {
                // 传递给下一个处理器
                nextHandler.handleSecurity(device);
            }
        }
    }
    }
}