package cn.com.goldenwater.dcproj.controller.tacplan;

import cn.com.goldenwater.core.web.BaseController;
import cn.com.goldenwater.core.web.BaseResponse;
import cn.com.goldenwater.dcproj.constValue.StateEnum;
import cn.com.goldenwater.dcproj.dto.TacProvincePblmInfoDto;
import cn.com.goldenwater.dcproj.model.GwComFile;
import cn.com.goldenwater.dcproj.model.TacObjPblmstb;
import cn.com.goldenwater.dcproj.model.TacPawpRgstr;
import cn.com.goldenwater.dcproj.model.TacPblmInfo;
import cn.com.goldenwater.dcproj.model.TacPblmSubject;
import cn.com.goldenwater.dcproj.model.TacProvincePblmInfo;
import cn.com.goldenwater.dcproj.model.TacProvincePblmInfoReDto;
import cn.com.goldenwater.dcproj.model.TacProvincePlanExamine;
import cn.com.goldenwater.dcproj.model.TacProvincePlanProcess;
import cn.com.goldenwater.dcproj.model.TacProvincePlanTask;
import cn.com.goldenwater.dcproj.param.GwComFileParam;
import cn.com.goldenwater.dcproj.param.TacPblmInfoParam;
import cn.com.goldenwater.dcproj.param.TacPblmSubjectParam;
import cn.com.goldenwater.dcproj.param.TacProvincePblmInfoParam;
import cn.com.goldenwater.dcproj.param.TacProvincePlanExamineParam;
import cn.com.goldenwater.dcproj.param.TacProvincePlanProcessParam;
import cn.com.goldenwater.dcproj.param.TacProvincePlanTaskParam;
import cn.com.goldenwater.dcproj.service.GwComFileService;
import cn.com.goldenwater.dcproj.service.OlBisInspOrgService;
import cn.com.goldenwater.dcproj.service.TacActiveLogService;
import cn.com.goldenwater.dcproj.service.TacObjPblmstbService;
import cn.com.goldenwater.dcproj.service.TacPawpRgstrService;
import cn.com.goldenwater.dcproj.service.TacPblmInfoService;
import cn.com.goldenwater.dcproj.service.TacPblmSubjectService;
import cn.com.goldenwater.dcproj.service.TacProvincePblmInfoService;
import cn.com.goldenwater.dcproj.service.TacProvincePlanExamineService;
import cn.com.goldenwater.dcproj.service.TacProvincePlanProcessService;
import cn.com.goldenwater.dcproj.service.TacProvincePlanTaskService;
import cn.com.goldenwater.dcproj.utils.BeanUtil;
import cn.com.goldenwater.dcproj.utils.InspUtils;
import cn.com.goldenwater.id.util.UuidUtil;
import com.github.pagehelper.PageInfo;
import com.workflow.common.util.convert.ConvertBeanUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author lune
 * @date 2020-5-28
 */
@Api(value = "TAC 稽察问题审核信息表管理", tags = "TAC 稽察问题审核信息表管理")
@RestController
@RequestMapping("/tac/province/pblm/info")
public class TacProvincePblmInfoController extends BaseController {

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private TacProvincePblmInfoService tacProvincePblmInfoService;
    @Autowired
    private TacPawpRgstrService tacPawpRgstrService;
    @Autowired
    private TacProvincePlanTaskService tacProvincePlanTaskService;

    @Autowired
    private TacProvincePlanProcessService tacProvincePlanProcessService;
    @Autowired
    private TacPblmInfoService tacPblmInfoService;

    @Autowired
    private TacPblmSubjectService tacPblmSubjectService;
    @Autowired
    private OlBisInspOrgService olBisInspOrgService;
    @Autowired
    private TacActiveLogService activeLogService;
    @Autowired
    private TacProvincePlanExamineService tacProvincePlanExamineService;
    @Autowired
    private TacObjPblmstbService tacObjPblmstbService;
    @Autowired
    private GwComFileService gwComFileService;

    @ApiOperation(value = "添加/修改稽察问题审核信息表,审核阶段")
    @RequestMapping(value = "", method = RequestMethod.POST)
    public BaseResponse insert(@ApiParam(name = "tacProvincePblmInfo", value = "TacProvincePblmInfo", required = true) @RequestBody TacProvincePblmInfo tacProvincePblmInfo) {
        tacProvincePblmInfo.setProvince(olBisInspOrgService.getRlProvince(getCurrentOrgId()));
        tacProvincePblmInfo.setPersId(getCurrentPersId());
        tacProvincePblmInfo.setPblmMendPersId(getCurrentPersId());
        TacProvincePlanTaskParam tacProvincePlanTaskParam = new TacProvincePlanTaskParam();
        tacProvincePlanTaskParam.setRgstrId(tacProvincePblmInfo.getRgstrId());
        tacProvincePlanTaskParam.setNowId(tacProvincePblmInfo.getStepId());
        TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.getBy(tacProvincePlanTaskParam);
//        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(tacProvincePblmInfo.getRgstrId());
        if (tacProvincePlanTask != null) {
            tacProvincePblmInfo.setTaskId(tacProvincePlanTask.getId());
        }
        if (StringUtils.isNotBlank(tacProvincePblmInfo.getId())) {
            tacProvincePblmInfo.setUptm(new Date());
            tacProvincePblmInfo.setState("1");
            tacProvincePblmInfoService.updatePblm(tacProvincePblmInfo);
        } else {
            String key = getCurrentPersId() + "_pblm_info_province";
            synchronized (this) {
                if (!tacPawpRgstrService.suoding(key)) {
                    return buildFailResponse("操作太频繁，请等会儿再操作");
                }
            }
            if (StringUtils.isBlank(tacProvincePblmInfo.getIfCasePblm())) {
                tacProvincePblmInfo.setIfCasePblm("0");
            }
            String uuid = UuidUtil.uuid();
            tacProvincePblmInfo.setId(uuid);
            tacProvincePblmInfo.setIntm(new Date());

            tacProvincePblmInfoService.insertPblm(tacProvincePblmInfo);
        }
        return buildSuccessResponse(tacProvincePblmInfo);
    }

    @ApiOperation(value = "根据ID删除稽察问题审核信息表")
    @RequestMapping(value = "/del/{id}", method = RequestMethod.GET)
    public BaseResponse delete(@ApiParam(name = "id", value = "id", required = true) @PathVariable String id) {
        int ret = tacProvincePblmInfoService.delete(id);
        return buildSuccessResponse();
    }


    @ApiOperation(value = "问题第一次提交审核,根据专业提交问题至初始阶段")
    @RequestMapping(value = "/plan/{rgstrId}/{type}", method = RequestMethod.GET)
    public BaseResponse plan(@ApiParam(name = "rgstrId", value = "rgstrId", required = true) @PathVariable String rgstrId,
                             @ApiParam(name = "type", value = "type", required = false) @PathVariable String type) {
        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(rgstrId);
        if (tacPawpRgstr != null) {

            String state = InspUtils.getTypeState(type, tacPawpRgstr);
            if (StateEnum.SUBMIT_ZHULI.getKey().equals(state)) {
                return buildFailResponse("当前专业问题已经提交完成!!不可以重复提交!");
            }
            //提交后问题录入初始阶段，初始为开始状态
            TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
            tacProvincePlanProcessParam.setOrgId(getCurrentOrgId());
            tacProvincePlanProcessParam.setPrvId("0");//上一步id为0表示当前为起始位置
            TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
//            机构定制阶段流程
            if (tacProvincePlanProcess == null) {
                return buildFailResponse("当前机构还没有定义相关的审核流程，请先定义审核流程再提交!!");
            }
            //查询稽察对象的专业所属问题
            TacPblmInfoParam tacPblmInfoParam = new TacPblmInfoParam();
            tacPblmInfoParam.setRgstrId(rgstrId);
            tacPblmInfoParam.setListType(type);
            tacPblmInfoParam.setProvince(tacPawpRgstr.getProvince());
            List<TacPblmInfo> tacPblmInfoList = tacPblmInfoService.findList(tacPblmInfoParam);
//            if (tacPblmInfoList != null && !tacPblmInfoList.isEmpty()) {有问题能提交，没有问题不能提交
            //问题不为空，则提交问题至初始阶段
            String content = InspUtils.getSpfsnlType(type);//专业内容
            //记录提交阶段
            String taskId = tacProvincePblmInfoService.addPlan(tacPblmInfoList, tacProvincePlanProcess, rgstrId, getCurrentPersId());
            //添加记录至日志中
            activeLogService.addTacLog(tacPawpRgstr.getName(), StateEnum.SUBMIT_ZHULI.getDesc(), tacPawpRgstr.getId(), type, StateEnum.SUBMIT_ZHULI.getKey(), tacProvincePlanProcess.getNowId(),
                    content + "提交给助理【" + tacProvincePlanProcess.getNowStep() + "】", getCurrentPersId());
            //稽察对象修改提交专业状态为4（专家提交到助理）
            tacPawpRgstrService.updateSubmit(tacPawpRgstr, type, StateEnum.SUBMIT_ZHULI.getKey());
            //稽察对象加入对应的阶段值
            tacPawpRgstr.setTaskId(taskId);
            tacPawpRgstr.setUptm(new Date());
            tacPawpRgstrService.update(tacPawpRgstr);
            return buildSuccessResponse("提交审核成功");
//            }
        }
        return buildFailResponse("请确认提交参数是否正确!!");
    }

    @ApiOperation(value = "单个问题提交问题审核流程")
    @RequestMapping(value = "/planPblm/{pblmId}/{nextId}", method = RequestMethod.GET)
    public BaseResponse planPblm(@ApiParam(name = "pblmId", value = "pblmId", required = true) @PathVariable String pblmId,
                                 @ApiParam(name = "nextId", value = "nextId", required = true) @PathVariable String nextId) {
        if ("1".equals(nextId)) {
            return buildSuccessResponse("已经完成整合流程审核，无更多审核阶段!!");
        }
        TacProvincePblmInfo tacProvincePblmInfo = tacProvincePblmInfoService.get(pblmId);
        if (tacProvincePblmInfo != null && "1".equals(tacProvincePblmInfo.getState())) {
            TacProvincePlanTaskParam tacProvincePlanTaskParam = new TacProvincePlanTaskParam();
            tacProvincePlanTaskParam.setRgstrId(tacProvincePblmInfo.getRgstrId());
            tacProvincePlanTaskParam.setNowId(nextId);
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.getBy(tacProvincePlanTaskParam);
            if (tacProvincePlanTask != null) {
                TacProvincePblmInfo provincePblmInfo = new TacProvincePblmInfo();
                BeanUtil.copyObject1(tacProvincePblmInfo, provincePblmInfo);
                provincePblmInfo.setState("0");
                provincePblmInfo.setOldPblmId(tacProvincePblmInfo.getId());
                String uuid = UuidUtil.uuid();
                provincePblmInfo.setId(uuid);
                provincePblmInfo.setStepId(nextId);
                provincePblmInfo.setTaskId(tacProvincePlanTask.getId());
                tacProvincePblmInfoService.insert(provincePblmInfo);
                List<GwComFile> gwComFiles = gwComFileService.findFileByBiz(tacProvincePblmInfo.getId());
                tacProvincePblmInfoService.addComFiles(gwComFiles, uuid);
                tacProvincePblmInfo.setState("0");
                tacProvincePblmInfoService.update(tacProvincePblmInfo);
                TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(tacProvincePblmInfo.getRgstrId());
                activeLogService.addTacLog(tacPawpRgstr.getName(), StateEnum.SUBMIT_ZHULI.getDesc(), tacProvincePblmInfo.getRgstrId(), tacProvincePblmInfo.getListType()
                        , StateEnum.SUBMIT_ZHULI.getKey(), nextId,
                        "提交给单个问题【" + tacProvincePlanTask.getNowStep() + "】", getCurrentPersId());
                return buildSuccessResponse("单个问题提交成功！");
            }

        }
        return buildFailResponse("提交单个问题审核失败!!");
    }


    @ApiOperation(value = "所有问题提交问题审核流程")
    @RequestMapping(value = "/planProcess/{rgstrId}/{nextId}", method = RequestMethod.GET)
    public BaseResponse planProcess(@ApiParam(name = "rgstrId", value = "rgstrId", required = true) @PathVariable String rgstrId,
                                    @ApiParam(name = "nextId", value = "nextId", required = true) @PathVariable String nextId,
                                    @RequestParam(name = "pblmChType", value = "pblmChType", required = true) String pblmChType) {
        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(rgstrId);
//            "1", "前期与设计专业", "2", "建设管理专业","4", "资金使用与管理专业"
//            "5", "工程质量专业","6", "工程安全专业","3", "计划下达与执行专业"
//            状态都为4（专家提交到助理）时，则更改稽察对象状态为4，则可提交到初始阶段的下一阶段中
        if (tacPawpRgstr != null && "4".equals(tacPawpRgstr.getState())) {
            //下一阶段为结束阶段时，则停止阶段提交
            if ("1".equals(nextId)) {
                return buildSuccessResponse("已经完成整合流程审核，无更多审核阶段!!");
            }
            //查询下一阶段记录是否存在，若不存在则新增阶段记录，存在则不能重复提交到下一阶段
            TacProvincePlanTaskParam provincePlanTaskParam = new TacProvincePlanTaskParam();
            provincePlanTaskParam.setNowId(nextId);
            provincePlanTaskParam.setRgstrId(rgstrId);
            provincePlanTaskParam.setOrgId(getCurrentOrgId());
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.getBy(provincePlanTaskParam);
            if (tacProvincePlanTask != null) {
                return buildFailResponse("当前阶段问题已经提交，请不要重复提交!!");
            }
            //根据稽察对象的当前阶段记录，查询阶段记录表中该阶段记录。
            tacProvincePlanTask = tacProvincePlanTaskService.get(tacPawpRgstr.getTaskId());
            //查询机构所属阶段，查询提交的下一阶段，
            TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
            tacProvincePlanProcessParam.setOrgId(getCurrentOrgId());
            tacProvincePlanProcessParam.setNowId(nextId);//上一步id为0表示当前为起始位置，下一步id为1时表示为结束位置
            TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
            if (tacProvincePlanProcess == null) {
                return buildFailResponse("当前机构还没有定义相关的审核流程，请先定义审核流程再提交!!");
            }
            //机构所属阶段中提交的下一阶段与稽察对象的当前阶段是否一致，若不一致则有问题，一致则没有问题。判断稽察对象的当前阶段，是否与机构阶段中的当前阶段一致
            if (!tacProvincePlanProcess.getPrvId().equals(tacProvincePlanTask.getNowId())) {
                return buildFailResponse("审核阶段提交存在问题，请检查当前提交参数是否正常!!");
            }
            //阶段提交至下一阶段
            // state为1时，为提交问题至下一阶段，state为0时，为驳回为题至上一阶段
            if (addProcessPlan(rgstrId, tacPawpRgstr.getTaskId(), tacProvincePlanProcess, "1")) {
                activeLogService.addTacLog(tacPawpRgstr.getName(), tacProvincePlanProcess.getNextStep(), tacPawpRgstr.getId(),
                        pblmChType, "", nextId, tacProvincePlanProcess.getNowStep() + "提交到" + tacProvincePlanProcess.getNextStep(),
                        getCurrentPersId());
                return buildSuccessResponse("提交审核成功!!");
            }
        }
        // 判断 哪个阶段 的问题没有提交到 交换意见阶段
        String errorMsg = getErrorMsg(tacPawpRgstr);
        return buildFailResponse("请确认" + errorMsg + "!!");
    }

    private String getErrorMsg(TacPawpRgstr tacPawpRgstr) {
        if (null == tacPawpRgstr) {
            return "提交参数登记表标识是否正确";
        }
        String msg = "";
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getPdbstStat())) {
            msg += "前期与设计";
        }
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getBstocmTsopbfpStat())) {
            msg += "、建设管理";
        }
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getRaiobisStat())) {
            msg += "、计划下达与执行";
        }
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getBstocmCmsStat())) {
            msg += "、资金使用与管理";
        }
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getBitopqPeqaaStat())) {
            msg += "、工程质量";
        }
        if (!StateEnum.SUBMIT_ZHULI.getKey().equals(tacPawpRgstr.getBioesRwunitStat())) {
            msg += "、工程安全";
        }
        msg += " 专业是否提交";
        if (msg.startsWith("、")) {
            msg = msg.substring(1, msg.length() - 1);
        }
        return msg;
    }

    private boolean addProcessPlan(String rgstrId, String taskId, TacProvincePlanProcess tacProvincePlanProcess, String state) {
        //查询当前阶段问题清单
        TacProvincePblmInfoParam tacPblmInfoParam = new TacProvincePblmInfoParam();
        tacPblmInfoParam.setRgstrId(rgstrId);
        tacPblmInfoParam.setTaskId(taskId);//稽察对象对应的阶段记录taskId
        tacPblmInfoParam.setProvince(tacProvincePlanProcess.getAdCode());
        List<TacProvincePblmInfo> tacPblmInfoList = tacProvincePblmInfoService.findList(tacPblmInfoParam);

        if (tacPblmInfoList != null && !tacPblmInfoList.isEmpty()) {
            //提交至下一阶段
            tacProvincePblmInfoService.addProcessPlan(tacPblmInfoList, tacProvincePlanProcess, rgstrId, getCurrentPersId(), state);
            return true;
        }

        return false;
    }

    private boolean rollbackProcessPlan(String rgstrId, String taskId, TacProvincePlanProcess tacProvincePlanProcess, String state, String note) {
//        查询上一个阶段记录
        TacProvincePlanTaskParam tacProvincePlanTaskParam = new TacProvincePlanTaskParam();
        tacProvincePlanTaskParam.setOrgId(tacProvincePlanProcess.getOrgId());
        tacProvincePlanTaskParam.setNowId(tacProvincePlanProcess.getNowId());
        tacProvincePlanTaskParam.setRgstrId(rgstrId);
        TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.getBy(tacProvincePlanTaskParam);

        //查询当前阶段问题清单
        TacProvincePblmInfoParam tacPblmInfoParam = new TacProvincePblmInfoParam();
        tacPblmInfoParam.setRgstrId(rgstrId);
        tacPblmInfoParam.setTaskId(taskId);//驳回，上一阶段问题数据删除，当前阶段问题回退到上一个阶段
        tacPblmInfoParam.setProvince(tacProvincePlanProcess.getAdCode());
        List<TacProvincePblmInfo> tacPblmInfoList = tacProvincePblmInfoService.findList(tacPblmInfoParam);

        if (tacPblmInfoList != null && !tacPblmInfoList.isEmpty()) {
            //驳回至上一阶段
            tacProvincePlanTaskService.delete(taskId);
            //查询上一阶段问题清单删除
            TacProvincePblmInfoParam tacPblmInfoParamdel = new TacProvincePblmInfoParam();
            tacPblmInfoParamdel.setRgstrId(rgstrId);
            tacPblmInfoParamdel.setTaskId(tacProvincePlanTask.getId());//驳回，上一阶段问题数据删除，当前阶段问题回退到上一个阶段
            tacPblmInfoParamdel.setProvince(tacProvincePlanProcess.getAdCode());
            //阶段问题驳回到稽察填报时，稽察阶段多个问题对应多个单位主体性质删除
            List<TacProvincePblmInfo> ProvincePblmInfolists = tacProvincePblmInfoService.findList(tacPblmInfoParamdel);
            for (TacProvincePblmInfo tacProvincePblmInfodel : ProvincePblmInfolists) {
                TacPblmSubjectParam tacPblmSubjectParam = new TacPblmSubjectParam();
                tacPblmSubjectParam.setPblmId(tacProvincePblmInfodel.getId());
                tacPblmSubjectService.deleteBy(tacPblmSubjectParam);
            }
            tacProvincePblmInfoService.deleteBy(tacPblmInfoParamdel);
            tacProvincePblmInfoService.rollbackProcess(tacPblmInfoList, tacProvincePlanProcess, tacProvincePlanTask, getCurrentPersId(), rgstrId);
            return true;
        }
        return false;
    }

    @ApiOperation(value = "所有工程,驳回问题到提交流程")
    @RequestMapping(value = "/rollback/{rgstrId}/{prvId}/{type}", method = RequestMethod.GET)
    public BaseResponse rollback(@ApiParam(name = "rgstrId", value = "rgstrId", required = true) @PathVariable String rgstrId,
                                 @ApiParam(name = "prvId", value = "prvId", required = true) @PathVariable String prvId,
                                 @ApiParam(name = "type", value = "type", required = false) @PathVariable String type,
                                 @RequestParam(name = "note", value = "note", required = false, defaultValue = "") String note,
                                 @RequestParam(name = "pblmChType", value = "pblmChType", required = true) String pblmChType) {
        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(rgstrId);
        if (tacPawpRgstr != null) {
            //初始为开始状态
            if ("0".equals(prvId) && StringUtils.isNotBlank(type)) {
                TacProvincePblmInfoParam tacPblmInfoParam = new TacProvincePblmInfoParam();
                tacPblmInfoParam.setRgstrId(rgstrId);
                tacPblmInfoParam.setListType(type);
                tacPblmInfoParam.setTaskId(tacPawpRgstr.getTaskId());
                //阶段问题驳回到稽察填报时，稽察阶段多个问题对应多个单位主体性质删除
                List<TacProvincePblmInfo> lists = tacProvincePblmInfoService.findList(tacPblmInfoParam);
                for (TacProvincePblmInfo tacProvincePblmInfodel : lists) {
                    TacPblmSubjectParam tacPblmSubjectParam = new TacPblmSubjectParam();
                    tacPblmSubjectParam.setPblmId(tacProvincePblmInfodel.getId());
                    tacPblmSubjectService.deleteBy(tacPblmSubjectParam);
                }
                tacProvincePblmInfoService.deleteBy(tacPblmInfoParam);
                tacPawpRgstrService.updateSubmit(tacPawpRgstr, type, StateEnum.COMASTSTATE.getKey());
                //全专业问题驳回到专家填报阶段后，删除记录表，改变工程登记表taskId
                if (StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getPdbstStat())
                        && StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getBstocmTsopbfpStat())
                        && StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getRaiobisStat()) &&
                        StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getBstocmCmsStat()) &&
                        StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getBitopqPeqaaStat()) &&
                        StateEnum.COMASTSTATE.getKey().equals(tacPawpRgstr.getBioesRwunitStat())) {
                    //所有专业所属问题回退后清除阶段记录表
                    tacProvincePlanTaskService.delete(tacPawpRgstr.getTaskId());
                    tacPawpRgstr.setTaskId("0");//专业问题全都已经驳回
                }

                tacPawpRgstr.setState(StateEnum.COMASTSTATE.getKey());
                tacPawpRgstr.setUptm(new Date());
                tacPawpRgstrService.update(tacPawpRgstr);
                return buildSuccessResponse("已退回到问题最初状态!!");
            }
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.get(tacPawpRgstr.getTaskId());
            if (tacProvincePlanTask == null) {
                return buildFailResponse("当前阶段问题已经退回!!");
            }

            TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
            tacProvincePlanProcessParam.setOrgId(getCurrentOrgId());
            tacProvincePlanProcessParam.setNowId(prvId);//上一步id为0表示当前为起始位置
            TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
            if (tacProvincePlanProcess == null) {
                return buildFailResponse("当前机构还没有定义相关的审核流程，请先定义审核流程再提交!!");
            }
            if (!tacProvincePlanTask.getNowId().equals(tacProvincePlanProcess.getNextId())) {
                return buildFailResponse("驳回流程存在问题，请检查上一步是否正确!!");
            }
            if (StringUtils.isNotBlank(note)) {
                note = "-[驳回说明:" + note + "]";
            }
            //数据全部驳回
            //state为1时，为提交问题至下一阶段，state为0时，为驳回为题至上一阶段
            if (rollbackProcessPlan(rgstrId, tacPawpRgstr.getTaskId(), tacProvincePlanProcess, "0", note)) {
                activeLogService.addTacLog(tacPawpRgstr.getName(), tacProvincePlanProcess.getNextStep(), tacPawpRgstr.getId(),
                        pblmChType, "", prvId, tacProvincePlanProcess.getNextStep() + "驳回到" + tacProvincePlanProcess.getNowStep() + note, getCurrentPersId());

                return buildSuccessResponse("驳回数据成功!!");
            }
        }
        return buildFailResponse("请确认提交参数是否正确!!");
    }


    @ApiOperation(value = "所有工程,非第一个阶段成果驳回问题到提交流程")
    @RequestMapping(value = "/rollback/allType/{rgstrId}/{prvId}", method = RequestMethod.GET)
    public BaseResponse rollbackNoFirstAllType(@ApiParam(name = "rgstrId", value = "rgstrId", required = true) @PathVariable String rgstrId,
                                               @ApiParam(name = "prvId", value = "prvId", required = true) @PathVariable String prvId,
                                               @RequestParam(name = "note", value = "note", required = false, defaultValue = "") String note,
                                               @RequestParam(name = "pblmChType", value = "pblmChType", required = false) String pblmChType) {
        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(rgstrId);
        if (tacPawpRgstr != null) {
            //初始为开始状态
            if ("0".equals(prvId)) {
                return buildFailResponse("请确认提交参数-阶段标识-是否正确!!");
            }
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.get(tacPawpRgstr.getTaskId());
            if (tacProvincePlanTask == null) {
                return buildFailResponse("当前阶段问题已经退回!!");
            }

            TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
            tacProvincePlanProcessParam.setOrgId(getCurrentOrgId());
            tacProvincePlanProcessParam.setNowId(prvId);//上一步id为0表示当前为起始位置
            TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
            if (tacProvincePlanProcess == null) {
                return buildFailResponse("当前机构还没有定义相关的审核流程，请先定义审核流程再提交!!");
            }
            if (!tacProvincePlanTask.getNowId().equals(tacProvincePlanProcess.getNextId())) {
                return buildFailResponse("驳回流程存在问题，请检查上一步是否正确!!");
            }
            if (StringUtils.isNotBlank(note)) {
                note = "-[驳回说明:" + note + "]";
            }
            //数据全部驳回
            //state为1时，为提交问题至下一阶段，state为0时，为驳回为题至上一阶段
            if (rollbackProcessPlan(rgstrId, tacPawpRgstr.getTaskId(), tacProvincePlanProcess, "0", note)) {
                activeLogService.addTacLog(tacPawpRgstr.getName(), tacProvincePlanProcess.getNextStep(), tacPawpRgstr.getId(),
                        pblmChType, "", prvId, tacProvincePlanProcess.getNextStep() + "驳回到" + tacProvincePlanProcess.getNowStep() + note, getCurrentPersId());

                return buildSuccessResponse("驳回数据成功!!");
            }
        }
        return buildFailResponse("请确认提交参数是否正确!!");
    }


    @ApiOperation(value = "所有工程,驳回单个问题审核流程")
    @RequestMapping(value = "/rollback/{pblmId}/{prvId}", method = RequestMethod.GET)
    public BaseResponse rollbackPblm(@ApiParam(name = "pblmId", value = "pblmId", required = true) @PathVariable String pblmId,
                                     @ApiParam(name = "prvId", value = "prvId", required = true) @PathVariable String prvId) {
        TacProvincePblmInfo tacProvincePblmInfo = tacProvincePblmInfoService.get(pblmId);
        if (tacProvincePblmInfo != null) {
            if ("0".equals(prvId)) {
                return buildFailResponse("已经退回到初始节点!!");
            }
            TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
            tacProvincePlanProcessParam.setOrgId(getCurrentOrgId());
            tacProvincePlanProcessParam.setNowId(prvId);//上一步id为0表示当前为起始位置
            TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
            if (tacProvincePlanProcess == null) {
                return buildFailResponse("当前机构还没有定义相关的审核流程，请先定义审核流程再提交!!");
            }
            TacProvincePlanTaskParam provincePlanTaskParam = new TacProvincePlanTaskParam();
            provincePlanTaskParam.setRgstrId(tacProvincePblmInfo.getRgstrId());
            provincePlanTaskParam.setNowId(prvId);
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.getBy(provincePlanTaskParam);
            if (tacProvincePlanTask == null) {
                return buildFailResponse("上一步无法进行回退，请仔细核查数据!!");
            }
            TacProvincePblmInfo tacProvincePblmInfoBak = new TacProvincePblmInfo();
            BeanUtil.copyObject1(tacProvincePblmInfo, tacProvincePblmInfoBak);
            tacProvincePblmInfoBak.setState("1");
            tacProvincePblmInfoBak.setStepId(prvId);
            tacProvincePblmInfoBak.setTaskId(tacProvincePlanTask.getId());
            tacProvincePblmInfoBak.setId(tacProvincePblmInfo.getOldPblmId());
            GwComFileParam gwComFileParam = new GwComFileParam();
            tacProvincePblmInfoService.update(tacProvincePblmInfoBak);
            gwComFileParam.setBizId(tacProvincePblmInfo.getOldPblmId());
            gwComFileService.deleteBy(gwComFileParam);//删除历史附件
            List<GwComFile> gwComFiles = gwComFileService.findFileByBiz(pblmId);
            tacProvincePblmInfoService.addComFiles(gwComFiles, tacProvincePblmInfo.getOldPblmId());//将当前附件添加到驳回问题信息中
            tacProvincePblmInfoService.delete(pblmId);//删除当前阶段的问题
            gwComFileParam.setBizId(pblmId);
            gwComFileService.deleteBy(gwComFileParam);//删除当前附件
            TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(tacProvincePblmInfo.getRgstrId());
            activeLogService.addTacLog(tacPawpRgstr.getName(), StateEnum.SUBMIT_ZHULI.getDesc(), tacProvincePblmInfo.getRgstrId(),
                    tacProvincePblmInfo.getListType(), StateEnum.SUBMIT_ZHULI.getKey(), tacProvincePlanProcess.getNowId(),
                    "驳回单个问题到【" + tacProvincePlanTask.getNowStep() + "】", getCurrentPersId());
            return buildSuccessResponse("问题驳回完成!!");
        }
        return buildFailResponse("请确认提交参数是否正确!!");
    }

    @ApiOperation(value = "根据ID获取稽察问题审核信息表（单表）")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public BaseResponse<TacProvincePblmInfo> get(@ApiParam(name = "id", value = "id", required = true) @PathVariable String id) {
        TacProvincePblmInfo tacProvincePblmInfo = tacProvincePblmInfoService.get(id);
        if (tacProvincePblmInfo == null) {
            TacPblmInfo tacPblmInfo = tacPblmInfoService.get(id);
            tacProvincePblmInfo = new TacProvincePblmInfo();
            ConvertBeanUtils.copyPropertiesBySource(tacPblmInfo, tacProvincePblmInfo);
        }
        if (tacProvincePblmInfo != null) {
            List<TacPblmSubject> pblmSubjectList = tacPblmInfoService.findSubjectList(id, tacProvincePblmInfo.getSubjectNames(), tacProvincePblmInfo.getSubjectIds());
            tacProvincePblmInfo.setPblmSubjectList(pblmSubjectList);
            if (StringUtils.isNotBlank(tacProvincePblmInfo.getPblmstdId())) {
                TacObjPblmstb objPblmstb = tacObjPblmstbService.getOne(tacProvincePblmInfo.getPblmstdId());
                if (null != objPblmstb) {
                    // lxf 2023/01/28 回显 专家编辑之后的 法律条款 法规内容
                    if (StringUtils.isNotBlank(tacProvincePblmInfo.getRelativeLaw())) {
                        objPblmstb.setRelativeLaw(tacProvincePblmInfo.getRelativeLaw());
                    }
                    if (StringUtils.isNotBlank(tacProvincePblmInfo.getLawContent())) {
                        objPblmstb.setLawContent(tacProvincePblmInfo.getLawContent());
                    }
                }
                tacProvincePblmInfo.setTacObjPblmstb(objPblmstb);
            }
            if (StringUtils.isNotBlank(tacProvincePblmInfo.getPblmRevisionProof())) {
                tacProvincePblmInfo.setRevisionFileList(gwComFileService.findFileByBiz(tacProvincePblmInfo.getPblmRevisionProof()));
            }
            tacProvincePblmInfo.setGwComFileList(gwComFileService.findFileByBiz(id));
        }
        return buildSuccessResponse(tacProvincePblmInfo);
    }


    @ApiOperation(value = "分页查询稽察问题清单-成果")
    @RequestMapping(value = "/pagecg", method = RequestMethod.POST)
    public BaseResponse<PageInfo<TacProvincePblmInfo>> pageCg(@RequestBody TacProvincePblmInfoParam tacProvincePblmInfoParam) {
        tacProvincePblmInfoParam.setProvince(olBisInspOrgService.getRlProvince(getCurrentOrgId()));
        return buildSuccessResponse(tacProvincePblmInfoService.findPageJieduanInfo(tacProvincePblmInfoParam));
    }

    @ApiOperation(value = "分页查询稽察问题清单-最终成果")
    @RequestMapping(value = "/finalResults", method = RequestMethod.POST)
    public BaseResponse<PageInfo<TacProvincePblmInfoReDto>> finalResults(@RequestBody TacProvincePblmInfoParam tacProvincePblmInfoParam) {
        tacProvincePblmInfoParam.setOrgId(getCurrentOrgId());
        tacProvincePblmInfoParam.setProvince(olBisInspOrgService.getRlProvince(getCurrentOrgId()));

        return buildSuccessResponse(tacProvincePblmInfoService.finalResults(tacProvincePblmInfoParam));
    }


    @ApiOperation(value = "批量修改问题")
    @RequestMapping(value = "/updatePblmInfoList", method = RequestMethod.POST)
    public BaseResponse updatePblmInfoList(@RequestBody TacProvincePblmInfoDto dto) {
        int a = tacProvincePblmInfoService.updatePblmInfoList(dto);
        return buildSuccessResponse();
    }

    @ApiOperation(value = "查询项目处于阶段")
    @RequestMapping(value = "/taskProcess/{rgstrId}/{planProcessId}", method = RequestMethod.GET)
    public BaseResponse taskProcess(@ApiParam(name = "rgstrId", value = "rgstrId", required = true) @PathVariable String rgstrId, @ApiParam(name = "planProcessId", value = "planProcessId", required = true) @PathVariable String planProcessId) {
        Map<String, String> response = new HashMap<>();
        TacPawpRgstr tacPawpRgstr = tacPawpRgstrService.get(rgstrId);
        if (StringUtils.isNotBlank(tacPawpRgstr.getTaskId())) {
            TacProvincePlanTask tacProvincePlanTask = tacProvincePlanTaskService.get(tacPawpRgstr.getTaskId());
            if (tacProvincePlanTask != null) {
                //当前工程所在阶段
                response.put("nowId", tacProvincePlanTask.getNowId());
                TacProvincePlanProcessParam tacProvincePlanProcessParam = new TacProvincePlanProcessParam();
                tacProvincePlanProcessParam.setNowId(planProcessId);
                TacProvincePlanProcess tacProvincePlanProcess = tacProvincePlanProcessService.getBy(tacProvincePlanProcessParam);
                if (tacProvincePlanProcess != null) {
                    //工程所在阶段是否需要审定
                    response.put("isExamine", tacProvincePlanProcess.getIsExamine());
                    TacProvincePlanExamineParam tacProvincePlanExamineParam = new TacProvincePlanExamineParam();
                    tacProvincePlanExamineParam.setRgstrId(rgstrId);
                    tacProvincePlanExamineParam.setPlanProcessId(planProcessId);
                    TacProvincePlanExamine tacProvincePlanExamine = tacProvincePlanExamineService.getBy(tacProvincePlanExamineParam);
                    if (tacProvincePlanExamine != null) {
                        String stageStatus = tacProvincePlanExamine.getStageStatus();
                        //工程所在阶段审定结果
                        response.put("stageStatus", stageStatus);
                    }
                }
                return buildSuccessResponse(response);
            } else {
                return buildFailResponse("阶段记录数据为空");
            }
        }
        return buildFailResponse("阶段记录数据为空");
    }
}