package com.ruoyi.project.tr.hiddenDangerCheck.controller;

import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.web.controller.BaseController;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.framework.web.page.TableDataInfo;
import com.ruoyi.project.enumerate.TrRiskTypeEnum;
import com.ruoyi.project.system.company.domain.Company;
import com.ruoyi.project.system.company.service.ICompanyService;
import com.ruoyi.project.system.dept.domain.Dept;
import com.ruoyi.project.system.dept.service.IDeptService;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint;
import com.ruoyi.project.tr.baseCheckPoint.service.IBaseCheckPointService;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import com.ruoyi.project.tr.region.domain.Region;
import com.ruoyi.project.tr.region.service.IRegionService;
import com.ruoyi.project.tr.riskCheckPoint.domain.RiskCheckPoint;
import com.ruoyi.project.tr.riskCheckPoint.service.IRiskCheckPointService;
import com.ruoyi.project.tr.riskEvaluationPlan.domain.RiskEvaluationPlan;
import com.ruoyi.project.tr.riskEvaluationPlan.service.IRiskEvaluationPlanService;
import com.ruoyi.project.tr.riskList.domain.RiskList;
import com.ruoyi.project.tr.riskList.service.IRiskListService;
import com.ruoyi.project.tr.troubleshootType.domain.TroubleshootType;
import com.ruoyi.project.tr.troubleshootType.service.ITroubleshootTypeService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

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

/**
 * 隐患排查计划制定Controller
 *
 * @date 2020-05-08
 */
@Controller
@RequestMapping("/tr/hiddenDangerCheck/dangerPlanFormulate")
public class DangerPlanFormulateController extends BaseController {
    private String prefix = "tr/hiddenDangerCheck/dangerPlanFormulate";

    @Autowired
    private IHiddenDangerCheckService hiddenDangerCheckService;
    @Autowired
    private ITroubleshootTypeService troubleshootTypeService;


    @Autowired
    private IRiskCheckPointService riskCheckPointSewrvice;
    @Autowired
    private IHiddenDangerCheckPointService hiddenDangerCheckPointService;

    @Autowired
    private IRiskEvaluationPlanService riskEvaluationPlanService;

    @Autowired
    private IRiskCheckPointService riskCheckPointService;

    @Autowired
    private IBaseCheckPointService baseCheckPointService;

    @Autowired
    private IUserService userService;

    @Autowired
    private IRiskListService riskListService;

    @Autowired
    private IRegionService regionService;
    @Autowired
    private IDeptService deptService;

    @Autowired
    private ICompanyService companyService;

    @GetMapping()
    public String hiddenDangerCheck() {
        return prefix + "/dangerPlanFormulate";
    }

    /**
     * 查询隐患排查计划制定列表
     */
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(HiddenDangerCheck hiddenDangerCheck) {
        startPage();
        hiddenDangerCheck.setPlanCreateUserId(getSysUser().getUserId());//计划创建者为本登录帐号的
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }

    /**
     * 新增隐患排查计划制定
     */
    @GetMapping("/addDangerPlanFormulate")
    public String addDangerPlanFormulate(ModelMap mmap) {
        //获取排查类型
        User sysUser = getSysUser();
        TroubleshootType troubleshootType = new TroubleshootType();
//        troubleshootType.setCompanyId(sysUser.getCompanyId());
        List<TroubleshootType> troubleshootTypeList = troubleshootTypeService.selectTroubleshootTypeList(troubleshootType);
        mmap.put("troubleshootTypeList", troubleshootTypeList);

        //获取所在公司人员信息
        if (sysUser != null && sysUser.getCompanyId() != null) {
            Long companyId = ShiroUtils.getSysUser().getCompanyId();
            Company company = companyService.selectCompanyById(companyId);
            List<Long> companyIdList = new ArrayList<>();
            if (companyId != null && companyId != 0L && companyId != -1L && company != null) {
                if (company.getParentId() == 0L) {
                    companyIdList.add(company.getCompanyId());
                    //查询是否存在子公司
                    Company sonQuery = new Company();
                    sonQuery.setParentId(companyId);
                    List<Company> sonList = companyService.selectCompanyList(sonQuery);
                    if (sonList.size() == 0) {

                    } else {
                        for (Company son : sonList) {
                            companyIdList.add(son.getCompanyId());
                        }
                    }
                } else {
                    Company companyParent = companyService.selectCompanyById(company.getParentId());
                    companyIdList.add(companyParent.getCompanyId());
                    //查询是否存在子公司
                    Company sonQuery = new Company();
                    sonQuery.setParentId(companyParent.getCompanyId());
                    List<Company> sonList = companyService.selectCompanyList(sonQuery);
                    for (Company son : sonList) {
                        companyIdList.add(son.getCompanyId());
                    }
                }
            }
            User userTemp = new User();
            userTemp.setCompanyIdList(companyIdList);
            List<User> userList = userService.selectUserList(userTemp);
            mmap.put("userList", userList);
        }


        //获取隐患排查基础清单
        RiskList riskList = new RiskList();
        riskList.setRiskType(TrRiskTypeEnum.BASE.getCode());
        riskList.setCompanyId(sysUser.getCompanyId());
        List<RiskList> basicRiskList = riskListService.selectRiskListList(riskList);
        mmap.put("basicRiskList", basicRiskList);

        return prefix + "/addDangerPlanFormulate";
    }

    /**
     * 新增保存隐患排查计划制定
     */
    @Log(title = "新增保存隐患排查计划制定", businessType = BusinessType.INSERT)
    @PostMapping("/addDangerPlanFormulate")
    @ResponseBody
    public AjaxResult addDangerPlanFormulateSave(HiddenDangerCheck hiddenDangerCheckBase, Long[] checkUserIds, String[] checkUserNames) {
        hiddenDangerCheckBase.setPlanCreateUserId(getSysUser().getUserId());
        hiddenDangerCheckBase.setCreateBy(ShiroUtils.getLoginName());//获取创建时间
        hiddenDangerCheckBase.setCreateTime(DateUtils.getNowDate());//获取创建时间
        hiddenDangerCheckBase.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//隐患排查计划制定(未开始)
//        hiddenDangerCheck.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_FORMULATE);//隐患排查阶段(数据进入到隐患排查计划制定阶段)


        if (StringUtils.isNotNull(checkUserIds))
            for (int m = 0; m < checkUserIds.length; m++) {
                Long checkUserId = checkUserIds[m];
                String checkUserName = checkUserNames[m];
                HiddenDangerCheck hiddenDangerCheck = new HiddenDangerCheck();
                BeanUtils.copyProperties(hiddenDangerCheckBase, hiddenDangerCheck);
                hiddenDangerCheck.setCheckUserId(checkUserId);
                hiddenDangerCheck.setCheckUserName(checkUserName);
                //设置基础清单  部门/区域  均为 公司级
                if ("1".equals(hiddenDangerCheck.getCheckType())) {
                    hiddenDangerCheck.setRiskType(TrRiskTypeEnum.BASE.getCode().toString());

                    //获取公司级区域
                    Region region = new Region();
                    region.setParentId(0L);
                    //todo 通过用户信息获取所属公司信息 然后根据公司获取第一个region的id和name作为隐患地点
                    region.setCompanyId(getSysUser().getCompanyId());
                    List<Region> regionList = regionService.selectRegionList(region);
                    if (regionList.size() > 0) {
                        Region r = regionList.get(0);
                        hiddenDangerCheck.setDangerPlaceId(r.getRegionId().toString());
                        hiddenDangerCheck.setDangerPlaceName(r.getRegionName());
                    }

                    //获取公司级部门
                    Dept dept = new Dept();
                    dept.setParentId(0L);
                    dept.setCompanyId(getSysUser().getCompanyId());
                    List<Dept> deptList = deptService.selectDeptList(dept);
                    //todo 然后通过公司id获取隐患责任部门信息
                    if (deptList.size() > 0) {
                        Dept d = deptList.get(0);
                        hiddenDangerCheck.setDangerDeptId(d.getDeptId().toString());
                        hiddenDangerCheck.setDangerDeptName(d.getDeptName());
                    }
                    hiddenDangerCheckService.insertHiddenDangerCheck(hiddenDangerCheck);// 插入数据库当中
                } else if ("2".equals(hiddenDangerCheck.getCheckType())) {
                    //选择多风险单元
                    String[] riskIdArray = hiddenDangerCheck.getRiskIdLabel().split(",");
                    String[] riskNameArray = hiddenDangerCheck.getRiskName().split(",");
                    String[] riskPlaceIdArray = hiddenDangerCheck.getDangerPlaceId().split(",");
                    String[] riskPlaceNameArray = hiddenDangerCheck.getDangerPlaceName().split(",");
                    String[] riskDeptIdArray = hiddenDangerCheck.getDangerDeptId().split(",");
                    String[] riskDeptNameArray = hiddenDangerCheck.getDangerDeptName().split(",");
                    String[] riskTypeArray = hiddenDangerCheck.getRiskType().split(",");

                    for (int i = 0; i < riskIdArray.length; ++i) {
                        hiddenDangerCheck.setRiskId(riskIdArray[i] != null ? Long.valueOf(riskIdArray[i]) : -1);//风险单元ID
                        hiddenDangerCheck.setRiskName(riskNameArray.length - 1 >= i ? riskNameArray[i] : "");//风险单元名称
                        hiddenDangerCheck.setDangerPlaceId(riskPlaceIdArray.length - 1 >= i ? riskPlaceIdArray[i] : "");//风险单元地点ID
                        hiddenDangerCheck.setDangerPlaceName(riskPlaceNameArray.length - 1 >= i ? riskPlaceNameArray[i] : "");//风险单元地点名称
                        hiddenDangerCheck.setDangerDeptId(riskDeptIdArray.length - 1 >= i ? riskDeptIdArray[i] : "");//隐患责任部门ID
                        hiddenDangerCheck.setDangerDeptName(riskDeptNameArray.length - 1 >= i ? riskDeptNameArray[i] : "");//隐患责任部门名称
                        hiddenDangerCheck.setRiskType(riskTypeArray.length - 1 >= i ? riskTypeArray[i] : "");//风险单元类型
                        hiddenDangerCheck.setCheckId(null);
                        hiddenDangerCheckService.insertHiddenDangerCheck(hiddenDangerCheck);// 插入数据库当中
                    }
                }
            }
        return AjaxResult.success();
    }

    /**
     * 修改隐患排查计划制定
     */
    @GetMapping("/editDangerPlanFormulate/{checkId}")
    public String editDangerPlanFormulate(@PathVariable("checkId") Long checkId, ModelMap mmap) {
        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(checkId);
        mmap.put("hiddenDangerCheck", hiddenDangerCheck);

        //获取排查类型
        List<TroubleshootType> troubleshootTypeList = troubleshootTypeService.selectTroubleshootTypeList(new TroubleshootType());
        mmap.put("troubleshootTypeList", troubleshootTypeList);

        //获取所在公司人员信息
        User sysUser = getSysUser();
        if (sysUser != null && sysUser.getCompanyId() != null) {
            Long companyId = ShiroUtils.getSysUser().getCompanyId();
            Company company = companyService.selectCompanyById(companyId);
            List<Long> companyIdList = new ArrayList<>();
            if (companyId != null && companyId != 0L && companyId != -1L && company != null) {
                if (company.getParentId() == 0L) {
                    companyIdList.add(company.getCompanyId());
                    //查询是否存在子公司
                    Company sonQuery = new Company();
                    sonQuery.setParentId(companyId);
                    List<Company> sonList = companyService.selectCompanyList(sonQuery);
                    if (sonList.size() == 0) {

                    } else {
                        for (Company son : sonList) {
                            companyIdList.add(son.getCompanyId());
                        }
                    }
                } else {
                    Company companyParent = companyService.selectCompanyById(company.getParentId());
                    companyIdList.add(companyParent.getCompanyId());
                    //查询是否存在子公司
                    Company sonQuery = new Company();
                    sonQuery.setParentId(companyParent.getCompanyId());
                    List<Company> sonList = companyService.selectCompanyList(sonQuery);
                    for (Company son : sonList) {
                        companyIdList.add(son.getCompanyId());
                    }
                }
            }
            User userTemp = new User();
            userTemp.setCompanyIdList(companyIdList);
            List<User> userList = userService.selectUserList(userTemp);
            mmap.put("userList", userList);
        }


        //获取隐患排查基础清单
        RiskList riskList = new RiskList();
        riskList.setRiskType(TrRiskTypeEnum.BASE.getCode());
        riskList.setCompanyId(sysUser.getCompanyId());
        List<RiskList> basicRiskList = riskListService.selectRiskListList(riskList);
        mmap.put("basicRiskList", basicRiskList);


        return prefix + "/editDangerPlanFormulate";
    }

    /**
     * 修改保存隐患排查计划制定
     */
    @Log(title = "修改保存隐患排查计划制定", businessType = BusinessType.UPDATE)
    @PostMapping("/editDangerPlanFormulate")
    @ResponseBody
    public AjaxResult editDangerPlanFormulateSave(HiddenDangerCheck hiddenDangerCheck) {
        return toAjax(hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck));
    }

    /**
     * 删除隐患排查计划制定
     */
    @Log(title = "删除隐患排查计划制定", businessType = BusinessType.DELETE)
    @PostMapping("/removeDangerPlanFormulate")
    @ResponseBody
    public AjaxResult removeDangerPlanFormulate(String ids) {
        return toAjax(hiddenDangerCheckService.deleteHiddenDangerCheckByIds(ids));
    }


    /**
     * 隐患排查计划制定--派发
     */
    @Log(title = "隐患排查计划制定--派发")
    @PostMapping("/distributeDangerPlanFormulate")
    @ResponseBody
    public AjaxResult distributeDangerPlanFormulate(String id) {
        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(Long.valueOf(id));
        //风险单元类型为基础清单
        if (TrRiskTypeEnum.BASE.getCode().toString().equals(hiddenDangerCheck.getRiskType())) {
            BaseCheckPoint bcpQuery = new BaseCheckPoint();
            bcpQuery.setRiskId(hiddenDangerCheck.getRiskId());
            List<BaseCheckPoint> baseCheckPointList = baseCheckPointService.selectBaseCheckPointList(bcpQuery);
            baseCheckPointList.forEach(bcp -> {
                if (bcp != null) {
                    HiddenDangerCheckPoint hdcp = new HiddenDangerCheckPoint();
                    hdcp.setCreateBy(ShiroUtils.getLoginName());//创建者
                    hdcp.setCreateTime(DateUtils.getNowDate());//获取创建时间
                    hdcp.setCheckPointId(bcp.getCheckPointId());
                    hdcp.setCheckId(hiddenDangerCheck.getCheckId());

                    hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXECUTE);//隐患排查阶段(数据进入到隐患排查计划执行阶段)
                    hdcp.setId(null);
                    hdcp.setCompanyId(getSysUser().getCompanyId());
                    hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hdcp);
                }
            });

        } else {
            //查询该风险单元最近的评价计划
            RiskEvaluationPlan plan = riskEvaluationPlanService.getRiskEvaluationPlanByRecent(hiddenDangerCheck.getRiskId());

            RiskCheckPoint rcpQuery = new RiskCheckPoint();
            rcpQuery.setPlanId(plan.getPlanId());
            List<RiskCheckPoint> riskCheckPointList = riskCheckPointService.selectRiskCheckPointList(rcpQuery);

            riskCheckPointList.forEach(rcp -> {
                if (rcp != null) {
                    HiddenDangerCheckPoint hdcp = new HiddenDangerCheckPoint();
                    hdcp.setCreateBy(ShiroUtils.getLoginName());//创建者
                    hdcp.setCreateTime(DateUtils.getNowDate());//获取创建时间
                    hdcp.setCheckPointId(rcp.getCheckPointId());
                    hdcp.setCheckId(hiddenDangerCheck.getCheckId());
//                hdcp.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_DISTRIBUTE);//隐患排查计划制定(已派发)
//                hdcp.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_NOT_STARTED);//隐患排查计划执行(未开始)
                    hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXECUTE);//隐患排查阶段(数据进入到隐患排查计划执行阶段)
                    hdcp.setId(null);
                    hdcp.setCompanyId(getSysUser().getCompanyId());
                    hiddenDangerCheckPointService.insertHiddenDangerCheckPoint(hdcp);
                }
            });
        }
        hiddenDangerCheck.setPlanFormulateStatus(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_ALREADY_DISTRIBUTE);//隐患排查计划制定(已派发)
        hiddenDangerCheck.setPlanExecuteStatus(TrHiddenDangerCheckConstants.PLAN_EXECUTE_STATUS_NOT_STARTED);//隐患排查计划执行(未开始)
//        hiddenDangerCheck.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXECUTE);//隐患排查阶段(数据进入到隐患排查计划执行阶段)
        hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck);


        hiddenDangerCheckPointService.getTaskCountTotal(getSysUser().getUserId());//查询未执行任务总数量并推送

        return AjaxResult.success("派发完成！");
    }


    /**
     * 隐患排查计划制定--查看
     */
    @GetMapping("/detailDangerPlanFormulate/{checkId}")
    public String detailDangerPlanFormulate(@PathVariable("checkId") Long checkId, ModelMap mmap) {
        //隐患排查实体
        HiddenDangerCheck hiddenDangerCheck = hiddenDangerCheckService.selectHiddenDangerCheckById(checkId);
        mmap.put("hiddenDangerCheck", hiddenDangerCheck);
        return prefix + "/detailDangerPlanFormulate";
    }


}