// 命令接口
public interface Command {
    void execute();
    void undo();
}

// 接收者
public class Light {
    public void on() {
        System.out.println("灯打开了");
    }
    
    public void off() {
        System.out.println("灯关闭了");
    }
}

// 具体命令：开灯
public class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.on();
    }
    
    @Override
    public void undo() {
        light.off();
    }
}

// 调用者
public class RemoteControl {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
    }
    
    public void pressUndo() {
        command.undo();
    }
}

// 使用
RemoteControl remote = new RemoteControl();
Light light = new Light();

remote.setCommand(new LightOnCommand(light));
remote.pressButton();  // 开灯
remote.pressUndo();    // 撤销（关灯）

// 处理者接口
public abstract class Handler {
    protected Handler nextHandler;
    
    public void setNext(Handler handler) {
        this.nextHandler = handler;
    }
    
    public final void handle(Request request) {
        if (canHandle(request)) {
            process(request);
        } else if (nextHandler != null) {
            nextHandler.handle(request);
        } else {
            System.out.println("无法处理请求");
        }
    }
    
    protected abstract boolean canHandle(Request request);
    protected abstract void process(Request request);
}

// 具体处理者：经理
public class Manager extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getAmount() <= 1000;
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("经理审批了 " + request.getAmount() + " 元的申请");
    }
}

// 具体处理者：总监
public class Director extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getAmount() <= 5000;
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("总监审批了 " + request.getAmount() + " 元的申请");
    }
}

// 使用
Handler manager = new Manager();
Handler director = new Director();
manager.setNext(director);

manager.handle(new Request("报销", 500));   // 经理处理
manager.handle(new Request("报销", 3000));  // 总监处理

// 抽象类：定义模板
public abstract class DataImporter {
    
    // 模板方法（final 防止重写）
    public final void importData(String filePath) {
        validateFile(filePath);
        List<Data> dataList = parseFile(filePath);
        validateData(dataList);
        saveData(dataList);
        if (shouldNotify()) {
            sendNotification(dataList.size());
        }
    }
    
    private void validateFile(String filePath) {
        System.out.println("验证文件: " + filePath);
    }
    
    // 抽象方法：子类必须实现
    protected abstract List<Data> parseFile(String filePath);
    protected abstract void saveData(List<Data> dataList);
    
    // 钩子方法：子类可选择重写
    protected boolean shouldNotify() {
        return true;
    }
}

// 具体实现：CSV 导入
public class CsvImporter extends DataImporter {
    @Override
    protected List<Data> parseFile(String filePath) {
        System.out.println("解析 CSV 文件");
        return Arrays.asList(new Data("1"), new Data("2"));
    }
    
    @Override
    protected void saveData(List<Data> dataList) {
        System.out.println("保存 CSV 数据到数据库");
    }
}

// 具体实现：Excel 导入
public class ExcelImporter extends DataImporter {
    @Override
    protected List<Data> parseFile(String filePath) {
        System.out.println("解析 Excel 文件");
        return Arrays.asList(new Data("A"), new Data("B"));
    }
    
    @Override
    protected void saveData(List<Data> dataList) {
        System.out.println("保存 Excel 数据到数据库");
    }
    
    @Override
    protected boolean shouldNotify() {
        return false; // Excel 导入不发送通知
    }
}

// 使用
DataImporter csvImporter = new CsvImporter();
csvImporter.importData("data.csv");

// 观察者接口
public interface Observer {
    void update(String event, Object data);
}

// 被观察者接口
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers(String event, Object data);
}

// 具体被观察者
public class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers(String event, Object data) {
        for (Observer observer : observers) {
            observer.update(event, data);
        }
    }
    
    // 业务方法
    public void publishNews(String news) {
        System.out.println("发布新闻: " + news);
        notifyObservers("NEWS_PUBLISHED", news);
    }
}

// 具体观察者：邮件通知
public class EmailSubscriber implements Observer {
    private String email;
    
    public EmailSubscriber(String email) {
        this.email = email;
    }
    
    @Override
    public void update(String event, Object data) {
        if ("NEWS_PUBLISHED".equals(event)) {
            System.out.println("发送邮件到 " + email + ": 新新闻 " + data);
        }
    }
}

// 具体观察者：短信通知
public class SmsSubscriber implements Observer {
    private String phone;
    
    public SmsSubscriber(String phone) {
        this.phone = phone;
    }
    
    @Override
    public void update(String event, Object data) {
        if ("NEWS_PUBLISHED".equals(event)) {
            System.out.println("发送短信到 " + phone + ": 新新闻");
        }
    }
}

// 使用
NewsPublisher publisher = new NewsPublisher();
publisher.attach(new EmailSubscriber("user@example.com"));
publisher.attach(new SmsSubscriber("13800138000"));

publisher.publishNews("Java 21 发布了！");

// 策略接口
public interface PaymentStrategy {
    void pay(BigDecimal amount);
    String getName();
}

// 具体策略：支付宝
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("支付宝支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "支付宝";
    }
}

// 具体策略：微信支付
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("微信支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "微信支付";
    }
}

// 具体策略：银行卡
public class CardPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("银行卡支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "银行卡";
    }
}

// 上下文
public class PaymentContext {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(BigDecimal amount) {
        strategy.pay(amount);
    }
}

// 使用
PaymentContext context = new PaymentContext();

// 选择支付宝
context.setStrategy(new AlipayStrategy());
context.executePayment(new BigDecimal("100"));

// 切换到微信支付
context.setStrategy(new WechatPayStrategy());
context.executePayment(new BigDecimal("200"));

// 策略接口
public interface DiscountStrategy {
    BigDecimal calculateDiscount(BigDecimal originalPrice);
    String getType();
}

// 具体策略
@Component
public class NormalDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price; // 无折扣
    }
    
    @Override
    public String getType() {
        return "NORMAL";
    }
}

@Component
public class VipDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price.multiply(new BigDecimal("0.8")); // VIP 8折
    }
    
    @Override
    public String getType() {
        return "VIP";
    }
}

@Component
public class SuperVipDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price.multiply(new BigDecimal("0.5")); // 超级VIP 5折
    }
    
    @Override
    public String getType() {
        return "SUPER_VIP";
    }
}

// 策略工厂
@Component
public class DiscountStrategyFactory {
    private final Map<String, DiscountStrategy> strategies = new HashMap<>();
    
    public DiscountStrategyFactory(List<DiscountStrategy> strategyList) {
        for (DiscountStrategy strategy : strategyList) {
            strategies.put(strategy.getType(), strategy);
        }
    }
    
    public DiscountStrategy getStrategy(String type) {
        DiscountStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("未知的折扣类型: " + type);
        }
        return strategy;
    }
}

// 使用
@Service
public class OrderService {
    @Autowired
    private DiscountStrategyFactory strategyFactory;
    
    public BigDecimal calculatePrice(String userType, BigDecimal originalPrice) {
        DiscountStrategy strategy = strategyFactory.getStrategy(userType);
        return strategy.calculateDiscount(originalPrice);
    }
}

// 排序策略接口
public interface SortStrategy {
    <T extends Comparable<T>> void sort(List<T> list);
    String getName();
}

// 快速排序
@Component
public class QuickSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        quickSort(list, 0, list.size() - 1);
    }
    
    private <T extends Comparable<T>> void quickSort(List<T> list, int low, int high) {
        if (low < high) {
            int pi = partition(list, low, high);
            quickSort(list, low, pi - 1);
            quickSort(list, pi + 1, high);
        }
    }
    
    private <T extends Comparable<T>> int partition(List<T> list, int low, int high) {
        T pivot = list.get(high);
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (list.get(j).compareTo(pivot) <= 0) {
                i++;
                Collections.swap(list, i, j);
            }
        }
        Collections.swap(list, i + 1, high);
        return i + 1;
    }
    
    @Override
    public String getName() {
        return "QUICK_SORT";
    }
}

// 归并排序
@Component
public class MergeSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        if (list.size() > 1) {
            mergeSort(list, 0, list.size() - 1);
        }
    }
    
    // 实现归并排序...
    
    @Override
    public String getName() {
        return "MERGE_SORT";
    }
}

// 排序服务
@Service
public class SortService {
    @Autowired
    private Map<String, SortStrategy> strategies;
    
    public <T extends Comparable<T>> List<T> sort(List<T> list, String algorithm) {
        SortStrategy strategy = strategies.get(algorithm);
        if (strategy == null) {
            throw new IllegalArgumentException("未知的排序算法");
        }
        
        List<T> copy = new ArrayList<>(list);
        strategy.sort(copy);
        return copy;
    }
}

// 库存服务
@Service
public class InventoryService {
    public boolean checkStock(String productId, int quantity) {
        System.out.println("检查库存: " + productId);
        return true;
    }
    
    public void reduceStock(String productId, int quantity) {
        System.out.println("扣减库存: " + productId);
    }
}

// 支付服务
@Service
public class PaymentService {
    public boolean processPayment(String orderId, BigDecimal amount) {
        System.out.println("处理支付: " + orderId);
        return true;
    }
}

// 物流服务
@Service
public class ShippingService {
    public void createShipment(String orderId) {
        System.out.println("创建物流: " + orderId);
    }
}

// 通知服务
@Service
public class NotificationService {
    public void sendOrderConfirmation(String userId, String orderId) {
        System.out.println("发送订单确认: " + orderId);
    }
}

// 订单外观
@Service
public class OrderFacade {
    @Autowired
    private InventoryService inventoryService;
    @Autowired
    private PaymentService paymentService;
    @Autowired
    private ShippingService shippingService;
    @Autowired
    private NotificationService notificationService;
    
    public OrderResult placeOrder(OrderRequest request) {
        // 1. 检查库存
        if (!inventoryService.checkStock(request.getProductId(), 
                                          request.getQuantity())) {
            return OrderResult.fail("库存不足");
        }
        
        // 2. 创建订单
        String orderId = createOrder(request);
        
        // 3. 处理支付
        if (!paymentService.processPayment(orderId, request.getAmount())) {
            return OrderResult.fail("支付失败");
        }
        
        // 4. 扣减库存
        inventoryService.reduceStock(request.getProductId(), 
                                      request.getQuantity());
        
        // 5. 创建物流
        shippingService.createShipment(orderId);
        
        // 6. 发送通知
        notificationService.sendOrderConfirmation(request.getUserId(), orderId);
        
        return OrderResult.success(orderId);
    }
    
    private String createOrder(OrderRequest request) {
        return "ORDER_" + System.currentTimeMillis();
    }
}

// Controller 使用
@RestController
public class OrderController {
    @Autowired
    private OrderFacade orderFacade;
    
    @PostMapping("/orders")
    public OrderResult createOrder(@RequestBody OrderRequest request) {
        // 客户端只需调用外观方法，无需了解复杂流程
        return orderFacade.placeOrder(request);
    }
}