/**
 * Copyright (c) 2020 ucsmy.com, All rights reserved.
 */
package com.ruoyi.project.mobile.service;

import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.project.enumerate.TrEvaluationStatusEnum;
import com.ruoyi.project.enumerate.TrReviewStatusEnum;
import com.ruoyi.project.enumerate.TrRiskTypeEnum;
import com.ruoyi.project.mobile.domain.ApiRequestHeader;
import com.ruoyi.project.mobile.domain.ApiResult;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.tool.TimeTool;
import com.ruoyi.project.tr.baseCheckPoint.domain.BaseCheckPoint;
import com.ruoyi.project.tr.baseCheckPoint.service.IBaseCheckPointService;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import com.ruoyi.project.tr.report.domain.RiskDomain;
import com.ruoyi.project.tr.report.mapper.ReportMapper;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;

/**
 * @Description:用于风险评估的前端方法,
 * @Author: Administrator
 * @Created Date: 2020年05月15日
 * @LastModifyDate:
 * @LastModifyBy:
 * @Version:
 */
@Service
public class ApiRiskService extends BaseApiService {

    @Autowired
    private IUserService userService;

    @Autowired
    private IRiskEvaluationPlanService riskEvaluationPlanService;

    @Autowired
    private IRiskCheckPointService riskCheckPointService;

    @Autowired
    private IBaseCheckPointService baseCheckPointService;

    @Autowired
    private IRiskListService riskListService;

    @Autowired
    private ReportMapper reportMapper;


    @Autowired
    IHiddenDangerCheckPointService hdcpService;//隐患检查点Service


    /**
     * 根据用户信息,获取该用户需要审核的信息
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult getReviewList(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }

        try {
            RiskCheckPoint checkPoint = new RiskCheckPoint();

            JSONObject parseObject = JSONObject.parseObject(str);
            Long userId = parseObject.getLong("userId");
            if(userId !=null){
                User user = userService.selectUserById(userId);
                if(user==null){
                    return ApiResult.error("未找到该用户!");
                }
                checkPoint.setReviewUserId(userId);
            }else{
                return ApiResult.error("userId不能为空!");
            }

            Integer reviewStatus = parseObject.getInteger("reviewStatus");
            if(reviewStatus !=null){
                checkPoint.setReviewStatus(reviewStatus);
            }



            checkPoint.setEvaluationStatus(TrEvaluationStatusEnum.EVALUATION.getCode());
            List<RiskCheckPoint> riskCheckPointList = riskCheckPointService.selectRiskCheckPointList(checkPoint);

            return ApiResult.success("查询成功",riskCheckPointList);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }

    /**
     * 根据检查点,id,审核某个检查点
     *
     * @param str
     * @param header
     * @returnw
     */
    public ApiResult reviewCheckPointById(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }

        try {
            JSONObject parseObject = JSONObject.parseObject(str);
            //判断用户信息
            Long userId = parseObject.getLong("userId");
            if(userId !=null){
                User user = userService.selectUserById(userId);
                if(user==null){
                    return ApiResult.error("未找到该用户!");
                }
            }else{
                return ApiResult.error("userId不能为空!");
            }

            RiskCheckPoint checkPoint = new RiskCheckPoint();

            Long checkPointId = parseObject.getLong("checkPointId");
            if(checkPointId ==null){
                return ApiResult.error("审核检查点id,不能为空!");
            }
            checkPoint.setCheckPointId(checkPointId);

            Integer reviewStatus = parseObject.getInteger("reviewStatus");
            if(reviewStatus ==null){
                return ApiResult.error("审核状态不能为空!");
            }
            checkPoint.setReviewStatus(reviewStatus);

            String reviewOpinion = parseObject.getString("reviewOpinion");
            if(StringUtils.isEmpty(reviewOpinion)){
                return ApiResult.error("审核意见不能为空!");
            }
            checkPoint.setReviewOpinion(reviewOpinion);
            String reviewTime = parseObject.getString("reviewTime");
            if(userId ==null){
                return ApiResult.error("审核时间不能为空!");
            }
            checkPoint.setReviewTime(TimeTool.strLongToDate(reviewTime));


            int num = riskCheckPointService.updateRiskCheckPoint(checkPoint);

            if(num>0){

                hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送

                return ApiResult.success("审核成功!");
            }else{
                return ApiResult.error("更新失败!");
            }

        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }


    /**
     * 查询风险排查台账信息
     * @param str
     * @param header
     * @return
     */
    public ApiResult getRiskLedger(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }

        try {
            RiskCheckPoint checkPoint = new RiskCheckPoint();

            JSONObject parseObject = JSONObject.parseObject(str);
            Long userId = parseObject.getLong("userId");
            if(userId !=null){
                User user = userService.selectUserById(userId);
                checkPoint.setCompanyId(user.getCompanyId());
                if(user==null){
                    return ApiResult.error("未找到该用户!");
                }
            }else{
                return ApiResult.error("userId不能为空!");
            }

            Integer evaluationType = parseObject.getInteger("evaluationType");
            if (evaluationType==null){
                return ApiResult.error("evaluationType不能为空!");
            }
            RiskEvaluationPlan plan = new RiskEvaluationPlan();
            plan.setEvaluationType(evaluationType);

            //如果传输风险单元，则按风险单元名称查询 start
            String planRiskRiskListName = parseObject.getString("plan.risk.riskListName");
            if (!StringUtils.isEmpty(planRiskRiskListName)){
                RiskList risk = new RiskList();
                risk.setRiskListName(planRiskRiskListName);
                plan.setRisk(risk);
            }
            //剩余风险评价风险色
            String evaluationAfterFengxianse = parseObject.getString("evaluationAfterFengxianse");
            if (!StringUtils.isEmpty(evaluationAfterFengxianse)){
                checkPoint.setEvaluationAfterFengxianse(evaluationAfterFengxianse);
            }

            //如果传输风险单元，则按风险单元名称查询 end
            checkPoint.setPlan(plan);
            checkPoint.setReviewStatus(TrReviewStatusEnum.REVIEW_PASS.getCode());
            List<RiskCheckPoint> riskCheckPointList = riskCheckPointService.selectRiskCheckPointList(checkPoint);
            return ApiResult.success("查询成功",riskCheckPointList);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }



    /**
     * 查询风险排查台账信息
     * @param str
     * @param header
     * @return
     */
    public ApiResult getRiskLedgerDataStatistics(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }

        try {
            JSONObject parseObject = JSONObject.parseObject(str);
            Long companyId = parseObject.getLong("companyId");
            if(companyId !=null){
                Map<String, Object> resultMap = new HashMap<>();//返回结果
                if(companyId!=null) {
                    //获取风险数据
                    List<RiskDomain> riskDomains = reportMapper.selectPublicityRisk(companyId);
                    AtomicReference<Integer> lowRiskCount = new AtomicReference<>(0);
                    AtomicReference<Integer> normalRiskCount = new AtomicReference<>(0);
                    AtomicReference<Integer> middleRiskCount = new AtomicReference<>(0);
                    AtomicReference<Integer> seriesRiskCount = new AtomicReference<>(0);
                    ArrayList<RiskDomain> seriesRisks = new ArrayList<>();
                    riskDomains.forEach(riskDomain -> {
                        if (StringUtils.isNotEmpty(riskDomain.getRiskColor())) {
                            switch (riskDomain.getRiskColor()) {
                                case "蓝色":
                                    lowRiskCount.getAndSet(lowRiskCount.get() + 1);
                                    break;
                                case "黄色":
                                    normalRiskCount.getAndSet(normalRiskCount.get() + 1);
                                    break;
                                case "橙色":
                                    middleRiskCount.getAndSet(middleRiskCount.get() + 1);
                                    break;
                                case "红色":
                                    seriesRiskCount.getAndSet(seriesRiskCount.get() + 1);
                                    seriesRisks.add(riskDomain);
                                    break;
                            }
                        }
                    });
                    //低风险数量
                    resultMap.put("lowRiskCount", lowRiskCount);
                    //一般风险数量
                    resultMap.put("normalRiskCount", normalRiskCount);
                    //较大风险数量
                    resultMap.put("middleRiskCount", middleRiskCount);
                    //重大风险数量
                    resultMap.put("seriesRiskCount", seriesRiskCount);
                }
                return ApiResult.success("查询成功",resultMap);
            }else{
                return ApiResult.error("companyId不能为空!");
            }
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }






    /**
     * 查询该公司的下的,风险排查计划
     * @param str
     * @param header
     * @return
     */
    public ApiResult getRiskPlan(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            RiskEvaluationPlan plan = new RiskEvaluationPlan();

            JSONObject parseObject = JSONObject.parseObject(str);

            Long userId = parseObject.getLong("userId");

            if(userId !=null){
                User user = userService.selectUserById(userId);
                plan.setCompanyId(user.getCompanyId());
                if(user==null){
                    return ApiResult.error("未找到该用户!");
                }
            }else{
                return ApiResult.error("userId不能为空!");
            }

            List<RiskEvaluationPlan> planList = riskEvaluationPlanService.selectRiskEvaluationPlanList(plan);

            return ApiResult.success("查询成功",planList);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }

    /**
     * 根据计划id,查询属于该计划的检查点
     * @param str
     * @param header
     * @return
     */
    public ApiResult getCheckPointByPlanId(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            RiskCheckPoint checkPoint = new RiskCheckPoint();

            JSONObject parseObject = JSONObject.parseObject(str);

            Long planId = parseObject.getLong("planId");
            if(planId ==null){
                return ApiResult.error("planId不能为空!");
            }

            checkPoint.setPlanId(planId);

            List<RiskCheckPoint> checkPointList = riskCheckPointService.selectRiskCheckPointList(checkPoint);

            return ApiResult.success("查询成功",checkPointList);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }


    /**
     * 查询基础清单(即基础清单类风险单元)
     * @param str
     * @param header
     * @return
     */
    public ApiResult getBaseRiskList(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            RiskList risk = new RiskList();

            JSONObject parseObject = JSONObject.parseObject(str);

            String riskName = parseObject.getString("riskName");
            if(StringUtils.isNotEmpty(riskName)){
                risk.setRiskListName(riskName);
            }





            risk.setRiskType(TrRiskTypeEnum.BASE.getCode());

            List<RiskList> riskLists = riskListService.selectRiskListList(risk);

            return ApiResult.success("查询成功",riskLists);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }




    //

    /**
     * 根据基础清单id, 查询基础清单下的检查点
     * @param str
     * @param header
     * @return
     */
    public ApiResult getBaseCheckPointByRiskId(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            BaseCheckPoint checkPoint = new BaseCheckPoint();

            JSONObject parseObject = JSONObject.parseObject(str);

            Long riksId = parseObject.getLong("riskId");
            if(riksId ==null){
                return ApiResult.error("基础清单id,不能为空!");
            }

            checkPoint.setRiskId(riksId);

            List<BaseCheckPoint> checkPointList = baseCheckPointService.selectBaseCheckPointList(checkPoint);

            return ApiResult.success("查询成功",checkPointList);
        } catch (Exception ex) {
            ApiResult.error("异常");
        }
        return ApiResult.error("异常");
    }

}