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.baseInfo.manager.AuditedUnitManager;
import com.hotent.baseInfo.manager.CostDistrictManager;
import com.hotent.baseInfo.model.AuditedUnit;
import com.hotent.baseInfo.model.CostDistrict;
import com.hotent.constant.NodeConstant;
import com.hotent.constant.TaskStatusConstant;
import com.hotent.enterpriseDeclare.req.CostAuditTaskPageReq;
import com.hotent.enterpriseDeclare.req.CostTaskPageReq;
import com.hotent.project.manager.CostProjectApprovalManager;
import com.hotent.project.manager.CostProjectTaskManager;
import com.hotent.project.manager.CostProjectTaskNodeManager;
import com.hotent.project.manager.CostProjectTaskProccessManager;
import com.hotent.project.model.CostProjectApproval;
import com.hotent.project.model.CostProjectTask;
import com.hotent.project.model.CostProjectTaskNode;
import com.hotent.project.model.CostProjectTaskProccess;
import com.hotent.project.resp.CostProjectApprovalDetailResp;
import com.hotent.uc.api.model.IUser;
import com.hotent.uc.manager.OrgManager;
import com.hotent.uc.util.ContextUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@Api(tags = "成本监审任务填报")
@RestController
@RequestMapping("/api/enterprise/castTask")
@ApiGroup(group = {ApiGroupConsts.GROUP_COST})
public class CostAuditTaskController {

    @Autowired
    private AuditedUnitManager auditedUnitManager;

    @Autowired
    private CostProjectApprovalManager costProjectApprovalManager;

    @Autowired
    private CostProjectTaskManager costProjectTaskManager;

    @Autowired
    private CostProjectTaskProccessManager costProjectTaskProccessManager;

    @Autowired
    private CostDistrictManager costDistrictManager;

    @Autowired
    private OrgManager orgManager;

    /**
     * 分页查询当前用户企业需要填写的监审任务
     * @param req 分页查询请求参数
     * @return 已发布的任务分页列表
     */
    @PostMapping(value = "/pageList")
    @ApiOperation(value = "分页查询当前用户企业需要填写的监审任务", httpMethod = "POST", notes = "分页查询当前用户企业需要填写的监审任务")
    public CommonResult<IPage<CostProjectApproval>> pageList(@RequestBody CostAuditTaskPageReq req) {
        IPage<CostProjectApproval> pageResult = pageListForAuditTask(req);
        return CommonResult.<IPage<CostProjectApproval>>ok().value(pageResult);
    }

    /**
     * 企业端分页查询已发布任务的具体实现
     * @param req 分页查询请求参数
     * @return 分页结果
     */
    private IPage<CostProjectApproval> pageListForAuditTask(CostAuditTaskPageReq req) {
        // 获取当前用户
        IUser currentUser = ContextUtil.getCurrentUser();
        AuditedUnit unit = auditedUnitManager.getOne(
                new LambdaQueryWrapper<AuditedUnit>()
                        .eq(AuditedUnit::getUserId, currentUser.getUserId())
                        .eq(AuditedUnit::getIsDeleted, "0")
        );

        // 构建查询条件
        LambdaQueryWrapper<CostProjectApproval> queryWrapper = new LambdaQueryWrapper<>();

        // 查询已发布状态的任务
        queryWrapper.eq(CostProjectApproval::getStatus, "2");

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

        // 查询包含当前用户企业ID的记录
        queryWrapper.like(CostProjectApproval::getAuditedUnitId, unit.getUnitId());

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

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

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

        IPage<CostProjectApproval> result = costProjectApprovalManager.page(page, queryWrapper);

        // 填充orgName和areaName
        List<CostProjectApproval> records = result.getRecords();
        for (CostProjectApproval record : records) {
            // 设置监审主体
            if (StringUtil.isNotEmpty(record.getOrgId())) {
                String[] orgIds = record.getOrgId().split(",");
                StringBuilder orgNames = new StringBuilder();
                for (int i = 0; i < orgIds.length; i++) {
                    String orgId = orgIds[i].trim();
                    if (StringUtil.isNotEmpty(orgId)) {
                        if (i > 0) {
                            orgNames.append(",");
                        }
                        orgNames.append(orgManager.get(orgId).getName());
                    }
                }
                record.setOrgName(orgNames.toString());
            }

            // 设置立项地区
            if (StringUtil.isNotEmpty(record.getAreaCode())) {
                CostDistrict district = costDistrictManager.getOne(
                        new LambdaQueryWrapper<CostDistrict>()
                                .eq(CostDistrict::getCode, record.getAreaCode())
                );
                record.setAreaName(district != null ? district.getName() : "山西省");
            }

            // 查询当前用户对应的子任务
            CostProjectTask userTask = costProjectTaskManager.getOne(
                    new LambdaQueryWrapper<CostProjectTask>()
                            .eq(CostProjectTask::getProjectId, record.getProjectId())
                            .ne(CostProjectTask::getPid,0)
                            .eq(CostProjectTask::getAuditedUnitId, unit.getUnitId())
                            .eq(CostProjectTask::getIsDeleted, 0)
            );
            CostProjectTaskProccess taskProccess = costProjectTaskProccessManager.getOne(
                    new LambdaQueryWrapper<CostProjectTaskProccess>()
                            .eq(CostProjectTaskProccess::getTaskId, userTask.getId())
            );


            // 设置子任务对象
            record.setUserTask(userTask);
            // 设置主状态为子任务状态
            record.setStatus(userTask.getStatus());
            record.setStatusName(TaskStatusConstant.getStatusNameByCode(userTask.getStatus()));
            record.setCurrentNode(taskProccess.getCurrentNode());
            record.setCurrentNodeName(NodeConstant.getNodeValueByKey(taskProccess.getCurrentNode())+ "-"+ TaskStatusConstant.getStatusNameByCode(userTask.getStatus()));

        }

        return result;
    }



    @GetMapping(value="/getDetail")
    @ApiOperation(value="任务立项详情",httpMethod = "GET",notes = "任务立项详情")
    public CommonResult<CostProjectApprovalDetailResp> getDetail(@ApiParam(name="id",value="业务对象主键", required = true)@RequestParam(required=true) String id) throws Exception{
        return CommonResult.<CostProjectApprovalDetailResp>ok().value(costProjectApprovalManager.getDetail(id));
    }


    @PostMapping(value="/save")
    @ApiOperation(value="提交任务填报",httpMethod = "POST",notes = "提交任务填报")
    public CommonResult<String> save(@RequestBody CostTaskPageReq costTaskPageReq) throws Exception{
        return CommonResult.<String>ok().value(costProjectTaskManager.saveTask(costTaskPageReq));
    }
}