import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.concurrent.ConcurrentHashMap; // 用于线程安全的设备注册

// 案例名称：智能家居设备控制平台的设备创建模块

// 枚举：设备类型
enum DeviceType {
    LIGHT, AIR_CONDITIONER, SPEAKER
}

// 枚举：设备厂商
enum Manufacturer {
    XIAOMI, HUAWEI, PHILIPS
}

/**
 * 智能设备抽象接口 (产品抽象)
 */
interface SmartDevice {
    void turnOn();
    void turnOff();
    void displayInfo();
}

/**
 * 智能灯接口 (具体产品抽象)
 * 实现 Cloneable 接口，支持原型模式
 */
interface SmartLight extends SmartDevice, Cloneable {
    void setBrightness(int brightness);
    SmartLight clone() throws CloneNotSupportedException; // 声明克隆方法
}

/**
 * 智能空调接口 (具体产品抽象)
 */
interface SmartAirConditioner extends SmartDevice {
    void setTemperature(int temperature);
}

/**
 * 智能音箱接口 (具体产品抽象)
 * 这是一个复杂对象，将通过建造者模式构建
 */
interface SmartSpeaker extends SmartDevice {
    void playMusic(String song);
    void setVoiceAssistant(String assistant);
    void setWiFiModule(String module);
    void setSoundSettings(String settings);
}

/**
 * 附件类 (用于建造者模式中音箱的复杂部件)
 * 实现 Serializable 接口，确保深克隆时能被序列化
 */
class SpeakerComponent implements Serializable {
    private String name;
    private String version;

    public SpeakerComponent(String name, String version) {
        this.name = name;
        this.version = version;
    }

    public String getName() {
        return name;
    }

    public String getVersion() {
        return version;
    }

    @Override
    public String toString() {
        return name + " (v" + version + ")";
    }
}

/**
 * 单例模式：设备中心管理器
 * 负责设备的注册和管理，确保只有一个实例
 */
class DeviceManager {
    // 使用 volatile 关键字确保多线程环境下的可见性
    private static volatile DeviceManager instance;
    // 使用 ConcurrentHashMap 确保线程安全的设备列表
    private ConcurrentHashMap<String, SmartDevice> registeredDevices;
    private int deviceCount = 0;

    // 私有构造函数，防止外部实例化
    private DeviceManager() {
        registeredDevices = new ConcurrentHashMap<>();
        System.out.println("DeviceManager: 设备管理器已初始化（单例）");
    }

    // 获取单例实例的静态方法 (双重检查锁定，线程安全)
    public static DeviceManager getInstance() {
        if (instance == null) { // 第一次检查，避免不必要的同步
            synchronized (DeviceManager.class) { // 同步块，确保只有一个线程创建实例
                if (instance == null) { // 第二次检查，防止多个线程同时通过第一次检查
                    instance = new DeviceManager();
                }
            }
        }
        return instance;
    }

    // 注册设备
    public void registerDevice(SmartDevice device) {
        String deviceId = "device-" + (++deviceCount);
        registeredDevices.put(deviceId, device);
        System.out.println("DeviceManager: 设备 " + device.getClass().getSimpleName() + " 已注册，ID: " + deviceId);
    }

    // 获取所有注册设备
    public List<SmartDevice> getAllDevices() {
        return new ArrayList<>(registeredDevices.values());
    }

    // 清空所有设备 (仅用于测试或特定管理场景)
    public void clearDevices() {
        registeredDevices.clear();
        deviceCount = 0;
        System.out.println("DeviceManager: 所有设备已清空。");
    }
}

/**
 * 抽象工厂模式：设备工厂接口 (Abstract Factory)
 * 定义了创建不同类型设备的方法
 */
interface DeviceFactory {
    SmartLight createLight();
    SmartAirConditioner createAirConditioner();
    SmartSpeaker createSpeaker();
}

// ------------------- 具体产品实现 -------------------

/**
 * 小米智能灯 (具体产品)
 * 实现 SmartLight 接口和 Cloneable 接口
 */
class XiaomiLight implements SmartLight {
    private int brightness;

    public XiaomiLight() {
        this.brightness = 80; // 默认亮度
        System.out.println("XiaomiLight: 初始化小米智能灯（默认亮度" + brightness + "%，支持米家协议）");
    }

    @Override
    public void turnOn() {
        System.out.println("XiaomiLight: 灯已开启，亮度 " + brightness + "%");
    }

    @Override
    public void turnOff() {
        System.out.println("XiaomiLight: 灯已关闭");
    }

    @Override
    public void setBrightness(int brightness) {
        this.brightness = brightness;
        System.out.println("XiaomiLight: 亮度设置为 " + brightness + "%");
    }

    @Override
    public void displayInfo() {
        System.out.println("XiaomiLight: 亮度 " + brightness + "%，支持米家协议");
    }

    // 原型模式：实现浅克隆 (对于简单字段，浅克隆即深克隆)
    @Override
    public SmartLight clone() throws CloneNotSupportedException {
        // 对于只包含基本类型和String的类，浅克隆通常足够。
        // 如果包含复杂对象，需要手动实现深克隆或利用序列化。
        System.out.println("XiaomiLight: 正在克隆小米智能灯...");
        return (SmartLight) super.clone();
    }
}

/**
 * 华为智能灯 (具体产品)
 */
class HuaweiLight implements SmartLight {
    private int brightness;

    public HuaweiLight() {
        this.brightness = 70;
        System.out.println("HuaweiLight: 初始化华为智能灯（默认亮度" + brightness + "%，支持鸿蒙智联）");
    }

    @Override
    public void turnOn() {
        System.out.println("HuaweiLight: 灯已开启，亮度 " + brightness + "%");
    }

    @Override
    public void turnOff() {
        System.out.println("HuaweiLight: 灯已关闭");
    }

    @Override
    public void setBrightness(int brightness) {
        this.brightness = brightness;
        System.out.println("HuaweiLight: 亮度设置为 " + brightness + "%");
    }

    @Override
    public void displayInfo() {
        System.out.println("HuaweiLight: 亮度 " + brightness + "%，支持鸿蒙智联");
    }

    @Override
    public SmartLight clone() throws CloneNotSupportedException {
        System.out.println("HuaweiLight: 正在克隆华为智能灯...");
        return (SmartLight) super.clone();
    }
}

/**
 * 飞利浦智能灯 (具体产品)
 */
class PhilipsLight implements SmartLight {
    private int brightness;

    public PhilipsLight() {
        this.brightness = 90;
        System.out.println("PhilipsLight: 初始化飞利浦智能灯（默认亮度" + brightness + "%，支持Hue生态）");
    }

    @Override
    public void turnOn() {
        System.out.println("PhilipsLight: 灯已开启，亮度 " + brightness + "%");
    }

    @Override
    public void turnOff() {
        System.out.println("PhilipsLight: 灯已关闭");
    }

    @Override
    public void setBrightness(int brightness) {
        this.brightness = brightness;
        System.out.println("PhilipsLight: 亮度设置为 " + brightness + "%");
    }

    @Override
    public void displayInfo() {
        System.out.println("PhilipsLight: 亮度 " + brightness + "%，支持Hue生态");
    }

    @Override
    public SmartLight clone() throws CloneNotSupportedException {
        System.out.println("PhilipsLight: 正在克隆飞利浦智能灯...");
        return (SmartLight) super.clone();
    }
}

/**
 * 小米智能空调 (具体产品)
 */
class XiaomiAirConditioner implements SmartAirConditioner {
    private int temperature;

    public XiaomiAirConditioner() {
        this.temperature = 26;
        System.out.println("XiaomiAirConditioner: 初始化小米智能空调（默认温度" + temperature + "℃）");
    }

    @Override
    public void turnOn() {
        System.out.println("XiaomiAirConditioner: 空调已开启，当前温度 " + temperature + "℃");
    }

    @Override
    public void turnOff() {
        System.out.println("XiaomiAirConditioner: 空调已关闭");
    }

    @Override
    public void setTemperature(int temperature) {
        this.temperature = temperature;
        System.out.println("XiaomiAirConditioner: 温度设置为 " + temperature + "℃");
    }

    @Override
    public void displayInfo() {
        System.out.println("XiaomiAirConditioner: 当前温度 " + temperature + "℃");
    }
}

/**
 * 华为智能空调 (具体产品)
 */
class HuaweiAirConditioner implements SmartAirConditioner {
    private int temperature;

    public HuaweiAirConditioner() {
        this.temperature = 25;
        System.out.println("HuaweiAirConditioner: 初始化华为智能空调（默认温度" + temperature + "℃）");
    }

    @Override
    public void turnOn() {
        System.out.println("HuaweiAirConditioner: 空调已开启，当前温度 " + temperature + "℃");
    }

    @Override
    public void turnOff() {
        System.out.println("HuaweiAirConditioner: 空调已关闭");
    }

    @Override
    public void setTemperature(int temperature) {
        this.temperature = temperature;
        System.out.println("HuaweiAirConditioner: 温度设置为 " + temperature + "℃");
    }

    @Override
    public void displayInfo() {
        System.out.println("HuaweiAirConditioner: 当前温度 " + temperature + "℃");
    }
}

/**
 * 飞利浦智能空调 (具体产品)
 */
class PhilipsAirConditioner implements SmartAirConditioner {
    private int temperature;

    public PhilipsAirConditioner() {
        this.temperature = 24;
        System.out.println("PhilipsAirConditioner: 初始化飞利浦智能空调（默认温度" + temperature + "℃）");
    }

    @Override
    public void turnOn() {
        System.out.println("PhilipsAirConditioner: 空调已开启，当前温度 " + temperature + "℃");
    }

    @Override
    public void turnOff() {
        System.out.println("PhilipsAirConditioner: 空调已关闭");
    }

    @Override
    public void setTemperature(int temperature) {
        this.temperature = temperature;
        System.out.println("PhilipsAirConditioner: 温度设置为 " + temperature + "℃");
    }

    @Override
    public void displayInfo() {
        System.out.println("PhilipsAirConditioner: 当前温度 " + temperature + "℃");
    }
}

/**
 * 智能音箱具体实现 (产品类，由建造者模式构建)
 */
class SmartSpeakerImpl implements SmartSpeaker, Serializable { // 同样需要序列化以便深克隆
    private String voiceAssistant;
    private String wiFiModule;
    private String soundSettings;
    private SpeakerComponent dspChip; // 复杂部件

    public SmartSpeakerImpl() {
        System.out.println("SmartSpeakerImpl: 正在组装智能音箱...");
    }

    @Override
    public void turnOn() {
        System.out.println("SmartSpeakerImpl: 音箱已开启");
    }

    @Override
    public void turnOff() {
        System.out.println("SmartSpeakerImpl: 音箱已关闭");
    }

    @Override
    public void playMusic(String song) {
        System.out.println("SmartSpeakerImpl: 正在播放 " + song);
    }

    @Override
    public void setVoiceAssistant(String assistant) {
        this.voiceAssistant = assistant;
    }

    @Override
    public void setWiFiModule(String module) {
        this.wiFiModule = module;
    }

    @Override
    public void setSoundSettings(String settings) {
        this.soundSettings = settings;
    }

    public void setDspChip(SpeakerComponent dspChip) {
        this.dspChip = dspChip;
    }

    @Override
    public void displayInfo() {
        System.out.println("SmartSpeakerImpl 配置:");
        System.out.println("  语音助手: " + voiceAssistant);
        System.out.println("  Wi-Fi 模块: " + wiFiModule);
        System.out.println("  音效设置: " + soundSettings);
        if (dspChip != null) {
            System.out.println("  DSP 芯片: " + dspChip);
        }
    }
}

// ------------------- 建造者模式实现 -------------------

/**
 * 抽象建造者：音箱建造者 (Abstract Builder)
 */
interface SpeakerBuilder {
    void buildVoiceAssistant();
    void buildWiFiModule();
    void buildSoundSettings();
    void buildDspChip(); // 构建复杂部件
    SmartSpeaker getSpeaker();
}

/**
 * 小米音箱建造者 (Concrete Builder)
 */
class XiaomiSpeakerBuilder implements SpeakerBuilder {
    private SmartSpeakerImpl speaker = new SmartSpeakerImpl();

    @Override
    public void buildVoiceAssistant() {
        speaker.setVoiceAssistant("小爱同学");
    }

    @Override
    public void buildWiFiModule() {
        speaker.setWiFiModule("Wi-Fi 5 (802.11ac)");
    }

    @Override
    public void buildSoundSettings() {
        speaker.setSoundSettings("小米澎湃音效");
    }

    @Override
    public void buildDspChip() {
        speaker.setDspChip(new SpeakerComponent("Xiaomi DSP", "v1.0"));
    }

    @Override
    public SmartSpeaker getSpeaker() {
        return speaker;
    }
}

/**
 * 华为音箱建造者 (Concrete Builder)
 */
class HuaweiSpeakerBuilder implements SpeakerBuilder {
    private SmartSpeakerImpl speaker = new SmartSpeakerImpl();

    @Override
    public void buildVoiceAssistant() {
        speaker.setVoiceAssistant("小艺");
    }

    @Override
    public void buildWiFiModule() {
        speaker.setWiFiModule("Wi-Fi 6 (802.11ax)");
    }

    @Override
    public void buildSoundSettings() {
        speaker.setSoundSettings("华为Histen音效");
    }

    @Override
    public void buildDspChip() {
        speaker.setDspChip(new SpeakerComponent("Huawei HiSilicon", "v2.0"));
    }

    @Override
    public SmartSpeaker getSpeaker() {
        return speaker;
    }
}

/**
 * 飞利浦音箱建造者 (Concrete Builder)
 */
class PhilipsSpeakerBuilder implements SpeakerBuilder {
    private SmartSpeakerImpl speaker = new SmartSpeakerImpl();

    @Override
    public void buildVoiceAssistant() {
        speaker.setVoiceAssistant("Google Assistant");
    }

    @Override
    public void buildWiFiModule() {
        speaker.setWiFiModule("Wi-Fi 5 (802.11ac)");
    }

    @Override
    public void buildSoundSettings() {
        speaker.setSoundSettings("Philips Fidelio 音效");
    }

    @Override
    public void buildDspChip() {
        speaker.setDspChip(new SpeakerComponent("Philips Audio Engine", "v1.5"));
    }

    @Override
    public SmartSpeaker getSpeaker() {
        return speaker;
    }
}

/**
 * 指挥者：音箱建造指挥者 (Director)
 */
class SpeakerDirector {
    private SpeakerBuilder builder;

    public SpeakerDirector(SpeakerBuilder builder) {
        this.builder = builder;
    }

    public SmartSpeaker construct() {
        builder.buildVoiceAssistant();
        builder.buildWiFiModule();
        builder.buildSoundSettings();
        builder.buildDspChip(); // 构建复杂部件
        return builder.getSpeaker();
    }
}

// ------------------- 抽象工厂具体实现 -------------------

/**
 * 小米设备工厂 (Concrete Abstract Factory)
 */
class XiaomiDeviceFactory implements DeviceFactory {
    @Override
    public SmartLight createLight() {
        return new XiaomiLight();
    }

    @Override
    public SmartAirConditioner createAirConditioner() {
        return new XiaomiAirConditioner();
    }

    @Override
    public SmartSpeaker createSpeaker() {
        // 使用建造者模式创建复杂音箱
        SpeakerBuilder builder = new XiaomiSpeakerBuilder();
        SpeakerDirector director = new SpeakerDirector(builder);
        return director.construct();
    }
}

/**
 * 华为设备工厂 (Concrete Abstract Factory)
 */
class HuaweiDeviceFactory implements DeviceFactory {
    @Override
    public SmartLight createLight() {
        return new HuaweiLight();
    }

    @Override
    public SmartAirConditioner createAirConditioner() {
        return new HuaweiAirConditioner();
    }

    @Override
    public SmartSpeaker createSpeaker() {
        // 使用建造者模式创建复杂音箱
        SpeakerBuilder builder = new HuaweiSpeakerBuilder();
        SpeakerDirector director = new SpeakerDirector(builder);
        return director.construct();
    }
}

/**
 * 飞利浦设备工厂 (Concrete Abstract Factory)
 */
class PhilipsDeviceFactory implements DeviceFactory {
    @Override
    public SmartLight createLight() {
        return new PhilipsLight();
    }

    @Override
    public SmartAirConditioner createAirConditioner() {
        return new PhilipsAirConditioner();
    }

    @Override
    public SmartSpeaker createSpeaker() {
        // 使用建造者模式创建复杂音箱
        SpeakerBuilder builder = new PhilipsSpeakerBuilder();
        SpeakerDirector director = new SpeakerDirector(builder);
        return director.construct();
    }
}

/**
 * 客户端：模拟用户交互和设备创建
 */
public class SmartHomeClient {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        DeviceManager deviceManager = DeviceManager.getInstance(); // 获取单例设备管理器

        System.out.println("欢迎使用智能家居系统");

        while (true) {
            System.out.println("\n请选择设备类型：[LIGHT, AIR_CONDITIONER, SPEAKER] (输入 'EXIT' 退出)");
            String deviceTypeInput = scanner.nextLine().toUpperCase();

            if (deviceTypeInput.equals("EXIT")) {
                System.out.println("感谢使用，再见！");
                break;
            }

            DeviceType selectedDeviceType;
            try {
                selectedDeviceType = DeviceType.valueOf(deviceTypeInput);
            } catch (IllegalArgumentException e) {
                System.out.println("无效的设备类型，请重新输入。");
                continue;
            }

            System.out.println("请选择设备厂商：[XIAOMI, HUAWEI, PHILIPS]");
            String manufacturerInput = scanner.nextLine().toUpperCase();

            Manufacturer selectedManufacturer;
            try {
                selectedManufacturer = Manufacturer.valueOf(manufacturerInput);
            } catch (IllegalArgumentException e) {
                System.out.println("无效的设备厂商，请重新输入。");
                continue;
            }

            DeviceFactory factory = null;
            switch (selectedManufacturer) {
                case XIAOMI:
                    factory = new XiaomiDeviceFactory();
                    break;
                case HUAWEI:
                    factory = new HuaweiDeviceFactory();
                    break;
                case PHILIPS:
                    factory = new PhilipsDeviceFactory();
                    break;
            }

            SmartDevice device = null;
            if (factory != null) {
                switch (selectedDeviceType) {
                    case LIGHT:
                        device = factory.createLight();
                        break;
                    case AIR_CONDITIONER:
                        device = factory.createAirConditioner();
                        break;
                    case SPEAKER:
                        device = factory.createSpeaker();
                        break;
                }
            }

            if (device != null) {
                System.out.println("\n数据：已创建设备：" + device.getClass().getSimpleName());
                device.displayInfo();
                deviceManager.registerDevice(device); // 注册设备到管理器

                // 演示原型模式：如果创建的是智能灯，则提供克隆选项
                if (device instanceof SmartLight) {
                    System.out.println("是否部署多个房间的同款灯具？(Y/N)");
                    String cloneChoice = scanner.nextLine().toUpperCase();
                    if (cloneChoice.equals("Y")) {
                        try {
                            SmartLight originalLight = (SmartLight) device;
                            SmartLight clonedLight2 = originalLight.clone();
                            System.out.println("设备克隆成功：Room2 使用 " + clonedLight2.getClass().getSimpleName());
                            clonedLight2.setBrightness(60); // 修改克隆体的属性，不影响原件
                            clonedLight2.displayInfo();
                            deviceManager.registerDevice(clonedLight2);

                            SmartLight clonedLight3 = originalLight.clone();
                            System.out.println("设备克隆成功：Room3 使用 " + clonedLight3.getClass().getSimpleName());
                            clonedLight3.setBrightness(50); // 再次修改克隆体的属性
                            clonedLight3.displayInfo();
                            deviceManager.registerDevice(clonedLight3);

                            System.out.println("\n原始灯具信息（未受克隆体修改影响）：");
                            originalLight.displayInfo(); // 验证原始灯具未受影响
                        } catch (CloneNotSupportedException e) {
                            System.err.println("克隆失败: " + e.getMessage());
                        }
                    }
                }
            } else {
                System.out.println("设备创建失败，请检查您的选择。");
            }
        }
        scanner.close();
    }
}