package com.hotent.enterpriseDeclare.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hotent.base.annotation.ApiGroup;
import com.hotent.base.constants.ApiGroupConsts;
import com.hotent.base.model.CommonResult;
import com.hotent.base.util.StringUtil;
import com.hotent.constant.NodeConstant;
import com.hotent.constant.TaskStatusConstant;
import com.hotent.enterpriseDeclare.req.CostTaskPageReq;
import com.hotent.enterpriseDeclare.req.CostTaskReviewPageReq;
import com.hotent.project.manager.CostProjectApprovalManager;
import com.hotent.project.manager.CostProjectTaskManager;
import com.hotent.project.manager.CostProjectTaskNodeManager;
import com.hotent.project.model.CostProjectApproval;
import com.hotent.project.model.CostProjectTask;
import com.hotent.project.model.CostProjectTaskNode;
import com.hotent.sys.persistence.manager.DataDictManager;
import com.hotent.sys.persistence.model.DataDict;
import com.hotent.uc.api.model.IUser;
import com.hotent.uc.util.ContextUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;

@Api(tags = "成本监审任务审核")
@RestController
@RequestMapping("/api/enterprise/reviewTask")
@ApiGroup(group = {ApiGroupConsts.GROUP_COST})
public class CostAuditReviewController {

    @Autowired
    private CostProjectTaskManager costProjectTaskManager;

    @Autowired
    private CostProjectApprovalManager costProjectApprovalManager;

    @Autowired
    private CostProjectTaskNodeManager costProjectTaskNodeManager;

    @Resource
    DataDictManager dataDictManager;

    /**
     * 分页查询待审核任务列表
     * @param req 分页查询请求参数
     * @return 待审核任务分页列表
     */
    @PostMapping(value = "/pageList")
    @ApiOperation(value = "分页查询待审核任务列表", httpMethod = "POST", notes = "分页查询待审核任务列表")
    public CommonResult<IPage<CostProjectTask>> pageList(@RequestBody CostTaskReviewPageReq req) {
        IPage<CostProjectTask> pageResult = pageListForReviewTask(req);
        return CommonResult.<IPage<CostProjectTask>>ok().value(pageResult);
    }

    /**
     * 审核任务分页查询的具体实现
     * @param req 分页查询请求参数
     * @return 分页结果
     */
    private IPage<CostProjectTask> pageListForReviewTask(CostTaskReviewPageReq req) {
        // 获取当前用户
        IUser currentUser = ContextUtil.getCurrentUser();
        String currentUserId = currentUser.getUserId();

        // 1. 先查询当前用户有权限的立项（负责人或项目组成员）
        LambdaQueryWrapper<CostProjectApproval> approvalQueryWrapper = new LambdaQueryWrapper<>();
        approvalQueryWrapper.eq(CostProjectApproval::getIsDeleted, "0");
        approvalQueryWrapper.and(wrapper -> wrapper
                .eq(CostProjectApproval::getLeaderId, currentUserId)
                .or(projectMembersWrapper -> {
                    projectMembersWrapper.like(CostProjectApproval::getProjectMembers, currentUserId);
                })
        );

        List<CostProjectApproval> accessibleApprovals = costProjectApprovalManager.list(approvalQueryWrapper);

        // 如果没有权限的立项，返回空结果
        if (accessibleApprovals.isEmpty()) {
            Page<CostProjectTask> emptyPage = new Page<>(req.getPageNum(), req.getPageSize());
            return emptyPage;
        }

        // 提取有权限的立项ID列表
        List<String> accessibleProjectIds = accessibleApprovals.stream()
                .map(CostProjectApproval::getProjectId)
                .distinct()
                .collect(java.util.stream.Collectors.toList());

        // 2. 构建任务查询条件
        LambdaQueryWrapper<CostProjectTask> queryWrapper = new LambdaQueryWrapper<>();

        // 查询未删除的记录
        queryWrapper.eq(CostProjectTask::getIsDeleted, "0");

        // 查询根任务（pid为0）
        queryWrapper.eq(CostProjectTask::getPid, "0");

        // 只查询当前用户有权限的立项对应的任务
        queryWrapper.in(CostProjectTask::getProjectId, accessibleProjectIds);

        // 根据请求参数添加查询条件
        if (StringUtil.isNotEmpty(req.getProjectName())) {
            queryWrapper.like(CostProjectTask::getProjectName, req.getProjectName());
        }
        if (StringUtil.isNotEmpty(req.getStatus())) {
            queryWrapper.eq(CostProjectTask::getStatus, req.getStatus());
        }
        if (StringUtil.isNotEmpty(req.getCurrentNode())) {
            queryWrapper.eq(CostProjectTask::getCurrentNode, req.getCurrentNode());
        }

        // 按创建时间倒序排列
        queryWrapper.orderByDesc(CostProjectTask::getCreateTime);

        // 创建分页对象并执行查询
        Page<CostProjectTask> page = new Page<>(req.getPageNum(), req.getPageSize());
        IPage<CostProjectTask> result = costProjectTaskManager.page(page, queryWrapper);

        // 填充根任务的子任务列表和流程信息
        for (CostProjectTask rootTask : result.getRecords()) {
            // 查询子任务列表
            LambdaQueryWrapper<CostProjectTask> childQueryWrapper = new LambdaQueryWrapper<>();
            childQueryWrapper.eq(CostProjectTask::getPid, rootTask.getId())
                            .eq(CostProjectTask::getIsDeleted, "0")
                            .orderByAsc(CostProjectTask::getOrderNum);

            List<CostProjectTask> childTasks = costProjectTaskManager.list(childQueryWrapper);
            for (CostProjectTask childTask : childTasks) {
                childTask.setStatus(TaskStatusConstant.getStatusNameByCode(childTask.getStatus()));
            }
            rootTask.setChildTasks(childTasks);
            rootTask.setCurrentNodeName(NodeConstant.getNodeValueByKey(rootTask.getCurrentNode()));
        }

        return result;
    }



    @PostMapping(value = "/getProcessBtn")
    @ApiOperation(value = "获取流程按钮", httpMethod = "POST", notes = "获取流程按钮")
    public CommonResult<List<java.util.Map<String, Object>>> getProcessBtn(@RequestBody CostTaskPageReq req) {
        CostProjectTaskNode one = costProjectTaskNodeManager.getOne(
                new LambdaQueryWrapper<CostProjectTaskNode>()
                        .eq(CostProjectTaskNode::getTaskId, req.getTaskId())
        );

        if (one == null || StringUtil.isEmpty(one.getStatus())) {
            return CommonResult.<List<java.util.Map<String, Object>>>ok().value(new java.util.ArrayList<>());
        }

        String status = one.getStatus();
        String[] split = status.split(",");
        List<java.util.Map<String, Object>> buttonList = new java.util.ArrayList<>();

        for (String s : split) {
            if (StringUtil.isNotEmpty(s.trim())) {
                String key = s.trim();
                DataDict byDictKey = dataDictManager.getByDictKey("1977549156280991744", key);

                java.util.Map<String, Object> buttonMap = new java.util.HashMap<>();
                buttonMap.put("key", key);

                if (byDictKey != null && StringUtil.isNotEmpty(byDictKey.getName())) {
                    buttonMap.put("value", byDictKey.getName());
                } else {
                    buttonMap.put("value", key);
                }

                buttonList.add(buttonMap);
            }
        }

        return CommonResult.<List<java.util.Map<String, Object>>>ok().value(buttonList);
    }
}