// 插件接口
public interface Plugin {
    String getName();
    void initialize(Context context);
    void execute(Input input);
    void shutdown();
}

// 插件工厂
public interface PluginFactory {
    Plugin createPlugin(String type);
    List<String> getSupportedTypes();
}

// 具体插件工厂
public class DefaultPluginFactory implements PluginFactory {
    private Map<String, Supplier<Plugin>> pluginRegistry = new HashMap<>();
    
    public DefaultPluginFactory() {
        registerPlugin("logger", LoggerPlugin::new);
        registerPlugin("validator", ValidatorPlugin::new);
        registerPlugin("transformer", TransformerPlugin::new);
    }
    
    private void registerPlugin(String type, Supplier<Plugin> supplier) {
        pluginRegistry.put(type, supplier);
    }
    
    @Override
    public Plugin createPlugin(String type) {
        Supplier<Plugin> supplier = pluginRegistry.get(type.toLowerCase());
        if (supplier == null) {
            throw new IllegalArgumentException("Unknown plugin type: " + type);
        }
        return supplier.get();
    }
    
    @Override
    public List<String> getSupportedTypes() {
        return new ArrayList<>(pluginRegistry.keySet());
    }
}

// 插件管理器（单例 + 观察者）
public class PluginManager {
    private static PluginManager instance;
    private Map<String, Plugin> plugins = new HashMap<>();
    private List<PluginEventListener> listeners = new ArrayList<>();
    private PluginFactory factory;
    
    private PluginManager(PluginFactory factory) {
        this.factory = factory;
    }
    
    public static synchronized PluginManager getInstance(PluginFactory factory) {
        if (instance == null) {
            instance = new PluginManager(factory);
        }
        return instance;
    }
    
    public void addEventListener(PluginEventListener listener) {
        listeners.add(listener);
    }
    
    public void removeEventListener(PluginEventListener listener) {
        listeners.remove(listener);
    }
    
    private void notifyListeners(PluginEvent event) {
        for (PluginEventListener listener : listeners) {
            listener.onEvent(event);
        }
    }
    
    public void loadPlugin(String type) {
        Plugin plugin = factory.createPlugin(type);
        plugin.initialize(new Context());
        plugins.put(type, plugin);
        notifyListeners(new PluginEvent("LOADED", type));
    }
    
    public void unloadPlugin(String type) {
        Plugin plugin = plugins.remove(type);
        if (plugin != null) {
            plugin.shutdown();
            notifyListeners(new PluginEvent("UNLOADED", type));
        }
    }
    
    public void executePlugin(String type, Input input) {
        Plugin plugin = plugins.get(type);
        if (plugin != null) {
            plugin.execute(input);
            notifyListeners(new PluginEvent("EXECUTED", type));
        }
    }
}

// 事件监听器（观察者）
public interface PluginEventListener {
    void onEvent(PluginEvent event);
}

public class PluginEvent {
    private String eventType;
    private String pluginType;
    
    public PluginEvent(String eventType, String pluginType) {
        this.eventType = eventType;
        this.pluginType = pluginType;
    }
    
    public String getEventType() { return eventType; }
    public String getPluginType() { return pluginType; }
}

// 日志插件
public class LoggerPlugin implements Plugin {
    @Override
    public String getName() {
        return "Logger";
    }
    
    @Override
    public void initialize(Context context) {
        System.out.println("Logger plugin initialized");
    }
    
    @Override
    public void execute(Input input) {
        System.out.println("Logging: " + input.getData());
    }
    
    @Override
    public void shutdown() {
        System.out.println("Logger plugin shutdown");
    }
}

// 验证插件
public class ValidatorPlugin implements Plugin {
    @Override
    public String getName() {
        return "Validator";
    }
    
    @Override
    public void initialize(Context context) {
        System.out.println("Validator plugin initialized");
    }
    
    @Override
    public void execute(Input input) {
        if (input.getData() == null || input.getData().isEmpty()) {
            throw new IllegalArgumentException("Input data cannot be empty");
        }
        System.out.println("Validation passed");
    }
    
    @Override
    public void shutdown() {
        System.out.println("Validator plugin shutdown");
    }
}

// 转换插件
public class TransformerPlugin implements Plugin {
    @Override
    public String getName() {
        return "Transformer";
    }
    
    @Override
    public void initialize(Context context) {
        System.out.println("Transformer plugin initialized");
    }
    
    @Override
    public void execute(Input input) {
        String transformed = input.getData().toUpperCase();
        System.out.println("Transformed: " + transformed);
    }
    
    @Override
    public void shutdown() {
        System.out.println("Transformer plugin shutdown");
    }
}

// 辅助类
class Context {
    // 插件上下文信息
}

class Input {
    private String data;
    
    public Input(String data) {
        this.data = data;
    }
    
    public String getData() {
        return data;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        PluginFactory factory = new DefaultPluginFactory();
        PluginManager manager = PluginManager.getInstance(factory);
        
        // 添加事件监听器
        manager.addEventListener(event -> 
            System.out.println("Event: " + event.getEventType() + " - " + event.getPluginType())
        );
        
        // 加载插件
        manager.loadPlugin("logger");
        manager.loadPlugin("validator");
        
        // 执行插件
        manager.executePlugin("validator", new Input("test data"));
        manager.executePlugin("logger", new Input("Hello World"));
        
        // 卸载插件
        manager.unloadPlugin("logger");
    }
}

public class ReportGenerator {
    public void generateReport(String type, Data data) {
        if ("pdf".equals(type)) {
            // 生成PDF的代码
            System.out.println("Generating PDF report...");
            // 复杂的PDF生成逻辑
        } else if ("excel".equals(type)) {
            // 生成Excel的代码
            System.out.println("Generating Excel report...");
            // 复杂的Excel生成逻辑
        } else if ("html".equals(type)) {
            // 生成HTML的代码
            System.out.println("Generating HTML report...");
            // 复杂的HTML生成逻辑
        }
        
        // 发送邮件
        System.out.println("Sending email...");
        // 邮件发送逻辑
        
        // 保存到数据库
        System.out.println("Saving to database...");
        // 数据库保存逻辑
    }
}

// 策略模式：报告生成策略
public interface ReportStrategy {
    void generate(Data data);
}

public class PdfReportStrategy implements ReportStrategy {
    @Override
    public void generate(Data data) {
        System.out.println("Generating PDF report...");
    }
}

public class ExcelReportStrategy implements ReportStrategy {
    @Override
    public void generate(Data data) {
        System.out.println("Generating Excel report...");
    }
}

public class HtmlReportStrategy implements ReportStrategy {
    @Override
    public void generate(Data data) {
        System.out.println("Generating HTML report...");
    }
}

// 命令模式：后续操作
public interface PostGenerationCommand {
    void execute(Data data);
}

public class EmailCommand implements PostGenerationCommand {
    @Override
    public void execute(Data data) {
        System.out.println("Sending email...");
    }
}

public class DatabaseCommand implements PostGenerationCommand {
    @Override
    public void execute(Data data) {
        System.out.println("Saving to database...");
    }
}

// 重构后的主类
public class ReportGenerator {
    private Map<String, ReportStrategy> strategies = new HashMap<>();
    private List<PostGenerationCommand> postCommands = new ArrayList<>();
    
    public ReportGenerator() {
        strategies.put("pdf", new PdfReportStrategy());
        strategies.put("excel", new ExcelReportStrategy());
        strategies.put("html", new HtmlReportStrategy());
        
        postCommands.add(new EmailCommand());
        postCommands.add(new DatabaseCommand());
    }
    
    public void generateReport(String type, Data data) {
        ReportStrategy strategy = strategies.get(type.toLowerCase());
        if (strategy == null) {
            throw new IllegalArgumentException("Unknown report type: " + type);
        }
        
        strategy.generate(data);
        
        for (PostGenerationCommand command : postCommands) {
            command.execute(data);
        }
    }
}

// React中的模式应用示例

// 1. 组合模式：组件树
const App = () => (
  <div>
    <Header />
    <MainContent>
      <Sidebar />
      <ArticleList />
    </MainContent>
    <Footer />
  </div>
);

// 2. 装饰器模式：高阶组件
function withLogging<T extends object>(WrappedComponent: React.ComponentType<T>) {
  return function WithLogging(props: T) {
    console.log(`Rendering ${WrappedComponent.name}`);
    return <WrappedComponent {...props} />;
  };
}

const LoggedButton = withLogging(Button);

// 3. 观察者模式：useState/useEffect
function Counter() {
  const [count, setCount] = useState(0);
  
  useEffect(() => {
    // 观察者：当count变化时执行
    console.log(`Count changed to ${count}`);
  }, [count]);
  
  return <button onClick={() => setCount(count + 1)}>{count}</button>;
}

// 4. 策略模式：自定义Hook
function useDataFetcher(strategy: FetchStrategy) {
  const [data, setData] = useState(null);
  
  useEffect(() => {
    strategy.fetch().then(setData);
  }, [strategy]);
  
  return data;
}

// 5. 工厂模式：React.createElement
const element = React.createElement('div', { className: 'container' }, 
  React.createElement('h1', null, 'Hello World')
);