package com.example;

import java.util.ArrayList;
import java.util.List;

/**
 * @author 
 */
public class TestChain {
    public static void main(String[] args) {
        // 创建 FilterChain 实例
        FilterChain<OrderData> filterChain = new FilterChain<>();

        // 添加具体的过滤器到链中
        filterChain.addFilter(new ValidationFilter<>());
        filterChain.addFilter(new CalculationFilter<>());
        filterChain.addFilter(new LoggingFilter<>());
        filterChain.addFilter(new EmailFilter<>());

        // 创建订单数据实例并初始化
        OrderData orderData = new OrderData();
        orderData.setOrderId("Order123");
        orderData.setAmount(100.0); // 假设设置订单金额为100

        // 定义成功和失败的回调
        SuccessCallback<OrderData> successCallback = (d) -> System.out.println("Data processed successfully: " + d);
        FailureCallback<OrderData> failureCallback = (d, e) -> System.out.println("Data processing failed: " + e.getMessage());

        // 执行过滤器链
        filterChain.executeFilterChain(orderData, successCallback, failureCallback);
    }
}

// 定义 SuccessCallback 接口
interface SuccessCallback<T> {
    void onSuccess(T data);
}

// 定义 FailureCallback 接口
interface FailureCallback<T> {
    void onFailure(T data, Exception e);
}

/**
 * 数据对象
 */
class OrderData {
    private String orderId;
    private double amount;

    // 其他订单属性// 构造函数、getter 和 setter 省略
    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    @Override
    public String toString() {
        return "OrderData{" + "orderId='" + orderId + '\\'' + ", amount=" + amount + '}';
    }
}

interface IDataHandlerFilter<T> {
    void filter(T data);
}

/**
 * 实现四个具体的过滤器，分别对应订单处理的不同阶段。
 */
class ValidationFilter<T> implements IDataHandlerFilter<T> {
    @Override
    public void filter(T data) {
        if (!(data instanceof OrderData)) {
            throw new IllegalArgumentException("Unsupported data type for ValidationFilter");
        }
        OrderData order = (OrderData) data;
        if (!isValid(order)) {
            throw new IllegalArgumentException("Order validation failed");
        }
    }

    private boolean isValid(OrderData order) {
        // 订单验证逻辑
        return order.getAmount() > 0;
    }
}

class CalculationFilter<T> implements IDataHandlerFilter<T> {
    @Override
    public void filter(T data) {
        if (!(data instanceof OrderData)) {
            throw new IllegalArgumentException("Unsupported data type for CalculationFilter");
        }
        OrderData order = (OrderData) data;
        // 计算订单费用逻辑
        order.setAmount(order.getAmount() * 1.1);
    }
}

class LoggingFilter<T> implements IDataHandlerFilter<T> {
    @Override
    public void filter(T data) {
        if (!(data instanceof OrderData)) {
            throw new IllegalArgumentException("Unsupported data type for LoggingFilter");
        }
        // 记录订单日志逻辑
        System.out.println("Order logged: " + data);
    }
}

class EmailFilter<T> implements IDataHandlerFilter<T> {
    @Override
    public void filter(T data) {
        if (!(data instanceof OrderData)) {
            throw new IllegalArgumentException("Unsupported data type for EmailFilter");
        }
        // 发送订单确认邮件逻辑
        System.out.println("Order confirmation email sent for order: " + data);
    }
}

/**
 * filterChain 责任链
 */
class FilterChain<T> {
    private final List<IDataHandlerFilter<T>> filters = new ArrayList<>();

    public void addFilter(IDataHandlerFilter<T> filter) {
        filters.add(filter);
    }

    public void executeFilterChain(T data, SuccessCallback<T> successCallback, FailureCallback<T> failureCallback) {
        try {
            for (IDataHandlerFilter<T> filter : filters) {
                // 执行每个过滤器
                filter.filter(data);
            }
            // 所有过滤器都成功执行后，调用成功回调
            successCallback.onSuccess(data);
        } catch (Exception e) {
            // 如果任何一个过滤器抛出异常，调用失败回调
            failureCallback.onFailure(data, e);
        }
    }
}