package org.jk.rag.utils;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 审核流程管理类
 */

public class ApprovalFlowManager {

    private List<ApprovalNode> nodes;

    public ApprovalFlowManager() {
        this.nodes = new ArrayList<>();
    }

    /**
     * 添加审核节点
     */
    public void addNode(ApprovalNode node) {
        nodes.add(node);
        // 按节点顺序排序
        Collections.sort(nodes, Comparator.comparingInt(ApprovalNode::getNodeOrder));
    }

    /**
     * 根据当前节点ID查找上一个审核人
     * @param currentNodeId 当前节点ID
     * @return 上一个节点的审核人，如果没有上一个节点返回null
     */
    public String getPreviousApprover(Long currentNodeId) {
        int currentIndex = findNodeIndexById(currentNodeId);
        if (currentIndex <= 0) {
            return null;
        }
        return nodes.get(currentIndex - 1).getApprover();
    }

    /**
     * 根据当前节点ID查找下一个审核人
     * @param currentNodeId 当前节点ID
     * @return 下一个节点的审核人，如果没有下一个节点返回null
     */
    public String getNextApprover(Long currentNodeId) {
        int currentIndex = findNodeIndexById(currentNodeId);
        if (currentIndex == -1 || currentIndex >= nodes.size() - 1) {
            return null;
        }
        return nodes.get(currentIndex + 1).getApprover();
    }

    /**
     * 获取整个审核链（所有审核人）
     */
    public List<Long> getFullApprovalChain() {
        if (nodes.isEmpty()) {
            return new ArrayList<>();
        }
        // 返回第一个节点的chain（根据表格数据，所有节点的chain相同）
        return new ArrayList<>(nodes.get(0).getChain());
    }

    /**
     * 根据节点ID查找节点索引
     */
    private int findNodeIndexById(Long nodeId) {
        for (int i = 0; i < nodes.size(); i++) {
            if (nodes.get(i).getId().equals(nodeId)) {
                return i;
            }
        }
        return -1;
    }

    /**
     * 根据当前节点ID查找下一个节点
     * @param currentNodeId 当前节点ID
     * @return 下一个节点对象，如果没有下一个节点返回null
     */
    public ApprovalNode getNextNode(Long currentNodeId) {
        int currentIndex = findNodeIndexById(currentNodeId);
        if (currentIndex == -1 || currentIndex >= nodes.size() - 1) {
            return null;
        }
        return nodes.get(currentIndex + 1);
    }

    /**
     * 根据当前节点的 order 值查找下一个节点
     * @param currentOrder 当前节点的 order 值
     * @return 下一个节点对象，如果没有下一个节点返回null
     */
    public ApprovalNode getNextNodeByOrder(int currentOrder) {
        // 首先确保节点已按order排序
        Collections.sort(nodes, Comparator.comparingInt(ApprovalNode::getNodeOrder));

        for (int i = 0; i < nodes.size(); i++) {
            if (nodes.get(i).getNodeOrder() == currentOrder) {
                // 找到当前节点，检查是否有下一个节点
                if (i < nodes.size() - 1) {
                    return nodes.get(i + 1);
                }
                break;
            }
        }
        return null;
    }

    /**
     * 根据当前节点的 order 值查找下一个审核人
     * @param currentOrder 当前节点的 order 值
     * @return 下一个节点的审核人ID，如果没有下一个节点返回null
     */
    public ApprovalNode getNextApproverByOrder(int currentOrder) {
        ApprovalNode nextNode = getNextNodeByOrder(currentOrder);
        return nextNode != null ? nextNode : null;
    }

    /**
     * 获取审核流程中的第一个节点（order值最小的节点）
     * @return 第一个节点，如果没有节点则返回null
     */
    public ApprovalNode getFirstNode() {
        if (nodes.isEmpty()) {
            return null;
        }
        // 因为节点已经按order排序，第一个元素就是order最小的
        return nodes.get(0);
    }

    /**
     * 获取审核流程中的第一个节点的审核人
     * @return 第一个节点的审核人，如果没有节点则返回null
     */
    public ApprovalNode getFirstApprover() {
        ApprovalNode firstNode = getFirstNode();
        return firstNode != null ? firstNode : null;
    }

}
