//USBTarget.interface
public interface USBTarget {
    void charge5V();
}

//AmericanCharger
public class AmericanCharger {
    public void supply110V(){
        System.out.println("American Charger, output 110V");
    }
}

//ChineseCharger
public class ChineseCharger{
    public void supply220V(){
        System.out.println("Chinese Charger, output 220V");
    }
}

//AmericanAdapter(核心)
public class AmericanAdapter implements USBTarget {
    private AmericanCharger americanCharger;

    public AmericanAdapter(AmericanCharger americanCharger) {
        this.americanCharger = americanCharger;
    }

    @Override
    public void charge5V() {
        americanCharger.supply110V();
        System.out.println("American Adapter, output 5V!");
    }
}

//ChineseAdapter(核心)
public class ChineseAdapter implements USBTarget {
    private ChineseCharger chineseCharger;

    public ChineseAdapter(ChineseCharger chineseCharger) {
        this.chineseCharger = chineseCharger;
    }

    @Override
    public void charge5V() {
        chineseCharger.supply220V();
        System.out.println("Chinese Adapter, output 5V!");
    }
}

//AdapterType
enum AdapterType {
    CHINESE, AMERICAN
}

//AdapterFactory
public class AdapterFactory {
    private AdapterFactory() {
    }//私有化实例

    public static USBTarget createChineseAdapter() {
        return new ChineseAdapter(new ChineseCharger());
    }

    public static USBTarget createAmericanAdapter() {
        return new AmericanAdapter(new AmericanCharger());
    }
}

//Phone.class
public class Phone {
    public static USBTarget withAdapter(AdapterType adapterType) {
        return switch (adapterType) {
            case CHINESE -> AdapterFactory.createChineseAdapter();
            case AMERICAN -> AdapterFactory.createAmericanAdapter();
            default -> throw new IllegalArgumentException();
        };
    }

    public void charging(USBTarget usbTarget) {
        System.out.println("Start Charging...");
        usbTarget.charge5V();
    }
}

//Main.class
public class Main {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.charging(Phone.withAdapter(AdapterType.CHINESE));
        phone.charging(Phone.withAdapter(AdapterType.AMERICAN));
    }
}

//Weapon.interface
public interface Weapon {
    int getAttack();
    String getDescription();
}

//Arrow.class
public class Arrow implements Weapon{

    @Override
    public int getAttack() {
        return 30;
    }

    @Override
    public String getDescription() {
        return "木弓";
    }
}

//Sword.class
public class Sword implements Weapon {
    @Override
    public int getAttack() {
        return 50;
    }

    @Override
    public String getDescription() {
        return "钢铁长剑";
    }
}

//WeaponEnchantment.class
public abstract class WeaponEnchantment implements Weapon {
    Weapon enchantmentWeapon;

    public WeaponEnchantment(Weapon weapon) {
        this.enchantmentWeapon = weapon;
    }
}


//FireEnchantment.class 这是核心类,主要就是这里去读取旧攻击力和新的攻击力,就等于是附魔了
//这就是装饰器模式,可以给不同的武器附魔
public class FireEnchantment extends WeaponEnchantment {
    private String enchantmentAttribute = "🔥";
    private int enchantmentAttack = 5;

    public FireEnchantment(Weapon weapon) {
        super(weapon);
    }

    @Override
    public int getAttack() {
        int originAttack = this.enchantmentWeapon.getAttack();
        int enchantment = originAttack + this.enchantmentAttack;
        return enchantment;
    }

    @Override
    public String getDescription() {
        String originDesc = this.enchantmentWeapon.getDescription();
        return originDesc + "[" + this.enchantmentAttribute + "附魔]";
    }

}

//Main.class
public class Main {
    public static void main(String[] args) {
        FireEnchantment fireEnchantmentArrow = new FireEnchantment(new Arrow());
        System.out.println(fireEnchantmentArrow.getDescription());
        System.out.println(fireEnchantmentArrow.getAttack());

        Weapon fireSword = new FireEnchantment(new Sword());
        System.out.println(fireSword.getDescription());     // 钢铁长剑附🔥
        System.out.println(fireSword.getAttack());          // 55
    }
}

//Particle.class
public interface Particle {
    void render(int x, int y, int life);
}

//Particle.type
public enum ParticleType {
    RED_SPARK,
    BLUE_SPARK
}

//SparkParticle.class
public class SparkParticle implements Particle {
    String color;
    String texture;

    public SparkParticle(String color, String texture) {
        this.color = color;
        this.texture = texture;
    }

    @Override
    public void render(int x, int y, int life) {
        System.out.println("渲染" + color + texture + "在位置(" + x + "," + y + "), 生命周期:" + life);
    }
}

//ParticleFactory.class
public class ParticleFactory {
    private final Map<ParticleType, Particle> pool = new HashMap<>();

    public Particle getParticle(ParticleType type) {
        // 如果存在则返回共享对象，否则创建并缓存
        return pool.computeIfAbsent(type, this::createParticle);
    }

    public Particle createParticle(ParticleType type) {
        return switch (type) {
            case RED_SPARK -> new SparkParticle("red", "spark");
            case BLUE_SPARK -> new SparkParticle("blue", "spark");
            default -> throw new IllegalArgumentException();
        };
    }
}

//Main.class
public class Main {
    public static void main(String[] args) {
        ParticleFactory particleFactory = new ParticleFactory();
        Particle particle = particleFactory.getParticle(ParticleType.RED_SPARK);
        particle.render(1,2,3);
        Particle particle2 = particleFactory.getParticle(ParticleType.RED_SPARK);
        particle2.render(1,2,3);
    }
}

//Order.class
public class Order {
    private String mainFood;
    private int number;
    private String address;

    Order(String address) {
        this.address = address;
    }

    public void setMainFood(String mainFood) {
        this.mainFood = mainFood;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void setNumber(int number) {
        this.number = number;
    }
}
//OrderBuilder.interface
public interface OrderBuilder {
    OrderBuilder setMainFood(String mainFood);

    OrderBuilder setNumber(int number);

    Order build();
}
//MeituanOrderBuilder.class
public class MeituanOrderBuilder implements OrderBuilder {
    private Order order;

    public MeituanOrderBuilder(String address) {
        this.order = new Order(address);
    }

    @Override
    public OrderBuilder setMainFood(String mainFood) {
        this.order.setMainFood(mainFood);
        return this;
    }

    @Override
    public OrderBuilder setNumber(int number) {
        this.order.setNumber(number);
        return this;
    }

    @Override
    public Order build() {
        return this.order;
    }
}
//Main.class
public class Main {
    public static void main(String[] args) {
        MeituanOrderBuilder builder = new MeituanOrderBuilder("123");
        Order abc = builder.setMainFood("abc")
                .setNumber(12)
                .build();
    }
}

public class Main {
    public static void main(String[] args) {
        // MeituanOrderBuilder builder = new MeituanOrderBuilder("123");
        Order abc = Order.withMeituanBuilder()
                .setMainFood("abc")
                .setNumber(12)
                .build();
    }
}

package org.example.builder;

public class Order {
    // {...}
    public static MeituanOrderBuilder withMeiTuanBuilder(String address){
        return new MeituanOrderBuilder(address);
    }
}

//Address.java
public class Address implements Cloneable{
    private String city;
    private List<String> tags = new ArrayList<>();

    public List<String> getTags() {
        return tags;
    }

    public void setTags(List<String> tags) {
        this.tags = tags;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    //拷贝构造函数
    public Address(Address other){
        this.city = other.city;
        this.tags = new ArrayList<>(other.tags);
    }

    //手动实现拷贝构造函数
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Address clone = (Address) super.clone();
        clone.tags = new ArrayList<>(this.tags);
        return clone;
    }
}

//Main.class
public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address();
        Address clone = (Address) address.clone();
        address.getTags().add("1");
        System.out.println(address); //tag :[1]
        System.out.println(clone); // tag: []
    }
}

package org.example.factory.playground;
/*
题目

场景描述：
假设你正在开发一个跨平台的UI组件库，需要支持Windows和macOS两种操作系统。UI组件包括按钮(Button)和文本框(TextBox)。

要求：

使用工厂模式创建单个UI组件
        使用抽象工厂模式创建整套UI组件
实现以下类：

抽象产品：Button, TextBox
具体产品：WindowsButton, WindowsTextBox, MacButton, MacTextBox
工厂类：ButtonFactory, TextBoxFactory（工厂模式）
抽象工厂：UIFactory（抽象工厂模式）
具体工厂：WindowsUIFactory, MacUIFactory（抽象工厂模式）
请实现上述所有类，并编写一个客户端代码演示两种模式的使用。

*/

public class FactoryMain {
    public static void main(String[] args) {
        System.out.println("=== 工厂模式演示 ===");
        // 工厂模式
        ButtonFactory buttonFactory = new ButtonFactory();
        TextBoxFactory textBoxFactory = new TextBoxFactory();
        Button button = buttonFactory.createButton("windows");
        TextBox textBox = textBoxFactory.createTextBox("windows");
        button.click();
        button.print();  // 补充print方法调用
        textBox.input(); // 补充input方法调用
        textBox.print();

        System.out.println("\n=== 抽象工厂模式演示 ===");
        // 抽象工厂模式
        UIFactory macUIFactory = new MacUIFactory();
        UIFactory windowsFactory = new WindowsUIFactory();

        Button macButton = macUIFactory.createButton();
        TextBox macTextBox = macUIFactory.createTextBox();
        macButton.click();
        macButton.print();
        macTextBox.input();
        macTextBox.print();

        Button windowsButton = windowsFactory.createButton();
        TextBox windowsTextBox = windowsFactory.createTextBox();
        windowsButton.click();
        windowsButton.print();
        windowsTextBox.input();
        windowsTextBox.print();
    }
}

package org.example.factory.playground;

abstract class Button {
    public void click() {
        System.out.println("button clicked");
    }

    abstract void print();
}

package org.example.factory.playground;

class ButtonFactory {
    public Button createButton(String type) {
        switch (type) {
            case "windows":
                return new WindowsButton();
            case "mac":
                return new MacButton();
            default:
                return new WindowsButton();
        }
    }
}

package org.example.factory.playground;

class MacButton extends Button {
    @Override
    void print() {
        System.out.println("Mac Button print!");
    }

    @Override
    public void click() {
        System.out.println("Mac button click!");
    }
}

package org.example.factory.playground;

class MacTextBox extends TextBox {
    @Override
    void print() {
        System.out.println("Mac TextBox input!");
    }
}

package org.example.factory.playground;

public class MacUIFactory  extends  UIFactory{
    @Override
    Button createButton() {
        return new MacButton();
    }

    @Override
    TextBox createTextBox() {
        return new MacTextBox();
    }
}


package org.example.factory.playground;

abstract class TextBox {
    public void input() {
        System.out.println("input activate");
    }

    abstract void print();
}

package org.example.factory.playground;

class TextBoxFactory {
    public TextBox createTextBox(String type) {
        switch (type) {
            case "windows":
                return new WindowsTextBox();
            case "mac":
                return new MacTextBox();
            default:
                return new WindowsTextBox();
        }
    }
}

package org.example.factory.playground;

public abstract class UIFactory {
    abstract Button createButton();
    abstract TextBox createTextBox();
}


package org.example.factory.playground;

class WindowsButton extends Button {
    @Override
    void print() {
        System.out.println("Windows Button print!");

    }

    @Override
    public void click() {
        System.out.println("Windows button click!");
    }
}

package org.example.factory.playground;

class WindowsTextBox extends TextBox {
    @Override
    void print() {
        System.out.println("WindowsTextBox input!");
    }
}

package org.example.factory.playground;

public class WindowsUIFactory extends UIFactory {
    @Override
    Button createButton() {
        return new WindowsButton();
    }

    @Override
    TextBox createTextBox() {
        return new WindowsTextBox();
    }
}