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

public class ApprovalChain {
    private List<Approver> approvers = new ArrayList<>();
    private Logger logger;
    
    public ApprovalChain(Logger logger) {
        this.logger = logger;
    }
    
    public void addApprover(Approver approver) {
        approvers.add(approver);
        logger.info("添加审批者: " + approver.getApproverName() + " (级别: " + approver.getRequiredLevel() + ")");
    }
    
    public boolean processApproval(Order order, ApprovalContext context) {
        if (order == null) {
            logger.error("尝试处理空订单");
            return false;
        }
        
        logger.info("开始审批订单: " + order.getOrderId() + "，金额: " + order.getAmount());
        context.setCurrentStatus(ApprovalStatus.IN_PROGRESS);
        
        // 根据订单金额确定需要的审批级别
        ApprovalLevel requiredLevel = determineRequiredLevel(order.getAmount());
        context.setCurrentRequiredLevel(requiredLevel);
        logger.info("订单需要的审批级别: " + requiredLevel);
        
        // 按照级别顺序执行审批
        boolean approvalPassed = false;
        
        for (Approver approver : approvers) {
            // 只有当前审批者的级别不高于所需级别时才执行审批
            if (approver.getRequiredLevel().ordinal() <= requiredLevel.ordinal()) {
                logger.info("转交审批给: " + approver.getApproverName() + " (级别: " + approver.getRequiredLevel() + ")");
                
                if (!approver.canApprove(order)) {
                    logger.warn("审批者 " + approver.getApproverName() + " 无权审批此订单，跳过");
                    continue;
                }
                
                if (!approver.approve(order, context)) {
                    logger.error("订单在 " + approver.getApproverName() + " 级别被拒绝");
                    context.setCurrentStatus(ApprovalStatus.REJECTED);
                    return false;
                }
                
                approvalPassed = true;
            }
        }
        
        // 如果所有必要的审批都通过了
        if (approvalPassed) {
            // 检查是否所有必要级别的审批都已完成
            boolean allRequiredLevelsPassed = checkAllRequiredLevels(order.getAmount(), context);
            
            if (allRequiredLevelsPassed) {
                context.setCurrentStatus(ApprovalStatus.APPROVED);
                logger.info("订单 " + order.getOrderId() + " 审批流程完成，状态: 已批准");
                return true;
            } else {
                logger.error("缺少必要级别的审批");
                context.setCurrentStatus(ApprovalStatus.REJECTED);
                context.setRejectionReason("审批流程不完整，缺少必要级别的审批");
                return false;
            }
        }
        
        return false;
    }
    
    private ApprovalLevel determineRequiredLevel(double amount) {
        if (amount <= 5000.0) {
            return ApprovalLevel.MANAGER;
        } else if (amount <= 10000.0) {
            return ApprovalLevel.DIRECTOR;
        } else if (amount <= 50000.0) {
            return ApprovalLevel.VP;
        } else {
            return ApprovalLevel.CEO;
        }
    }
    
    private boolean checkAllRequiredLevels(double amount, ApprovalContext context) {
        List<ApprovalLevel> requiredLevels = new ArrayList<>();
        
        // 根据金额确定所有必需的审批级别
        if (amount > 0) {
            requiredLevels.add(ApprovalLevel.MANAGER);
            
            if (amount > 5000.0) {
                requiredLevels.add(ApprovalLevel.DIRECTOR);
                
                if (amount > 10000.0) {
                    requiredLevels.add(ApprovalLevel.VP);
                    
                    if (amount > 50000.0) {
                        requiredLevels.add(ApprovalLevel.CEO);
                    }
                }
            }
        }
        
        // 检查是否所有必需级别的审批都已完成
        List<String> approvedNames = context.getApprovalHistory().stream()
            .filter(record -> record.approved)
            .map(record -> record.approverName)
            .toList();
        
        // 简化检查：只要每个级别都有至少一个审批者批准即可
        int managerApproved = 0, directorApproved = 0, vpApproved = 0, ceoApproved = 0;
        
        for (Approver approver : approvers) {
            if (approvedNames.contains(approver.getApproverName())) {
                switch (approver.getRequiredLevel()) {
                    case MANAGER -> managerApproved++;
                    case DIRECTOR -> directorApproved++;
                    case VP -> vpApproved++;
                    case CEO -> ceoApproved++;
                }
            }
        }
        
        // 验证每个必需级别的审批是否都已完成
        if (requiredLevels.contains(ApprovalLevel.MANAGER) && managerApproved == 0) return false;
        if (requiredLevels.contains(ApprovalLevel.DIRECTOR) && directorApproved == 0) return false;
        if (requiredLevels.contains(ApprovalLevel.VP) && vpApproved == 0) return false;
        if (requiredLevels.contains(ApprovalLevel.CEO) && ceoApproved == 0) return false;
        
        return true;
    }
}