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

import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.web.controller.BaseController;
import com.ruoyi.framework.web.page.PageDomain;
import com.ruoyi.framework.web.page.TableDataInfo;
import com.ruoyi.framework.web.page.TableSupport;
import com.ruoyi.project.mobile.service.ApiHiddenDangerCheckService;
import com.ruoyi.project.system.dept.domain.Dept;
import com.ruoyi.project.system.dept.service.IDeptService;
import com.ruoyi.project.system.role.service.IRoleService;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.tr.article.domain.Article;
import com.ruoyi.project.tr.article.service.IArticleService;
import com.ruoyi.project.tr.articleRegulation.domain.ArticleRegulation;
import com.ruoyi.project.tr.articleRegulation.service.IArticleRegulationService;
import com.ruoyi.project.tr.dataStatistics.domain.DataStatistics;
import com.ruoyi.project.tr.dataStatistics.service.DataStatisticsService;
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 org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * app端，数据统计功能
 */
@Controller
@RequestMapping("/tr/dataStatisticsByApp")
public class DataStatisticsByAppController extends BaseController {
    @Autowired
    private DataStatisticsService dataStatisticsService;
    @Autowired
    private IRoleService roleService;
    @Autowired
    private IUserService userService;
    @Autowired
    private IDeptService deptService;

    @Autowired
    private IHiddenDangerCheckPointService hiddenDangerCheckPointService;
    @Autowired
    private IHiddenDangerCheckService hiddenDangerCheckService;
    @Autowired
    private IRiskCheckPointService riskCheckPointService;

    @Autowired
    private IArticleService articleService;


    @Autowired
    private IArticleRegulationService articleRegulationService;


    @Autowired
    private IRegionService regionService;

    private String prefix = "tr/dataStatisticsByApp";

    /**
     * 获取数据统计页面
     *
     * @param
     * @return
     */
    @GetMapping("/dataStatisticsByApp/{userId}")
    public String dataStatisticsByApp(@PathVariable("userId") Long userId, ModelMap mmap) {
        mmap.put("userId", userId);
        return prefix + "/dataStatisticsByApp";
    }


    /**
     * 获取数据统计数据
     *
     * @param
     * @return
     */
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(DataStatistics dataStatistics, Long userId) {

        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();
        Integer pageSize = pageDomain.getPageSize();

        User user = userService.selectUserById(userId);
        Set<String> stringSet = roleService.selectRoleKeys(user.getUserId());
        if (stringSet.contains("regionUser")) {
            dataStatistics.setCompanyRegion(user.getUserName());
        } else {
            return new TableDataInfo(new ArrayList<DataStatistics>(), 0);
        }
        List<DataStatistics> list = dataStatisticsService.selectCompanyDataStatistics(dataStatistics);
        Integer total = list.size();
        Integer startIndex = (pageNum - 1) * pageSize;
        Integer endIndex = (pageNum - 1) * pageSize + pageSize;
        if (total >= endIndex) {
            list = list.subList(startIndex, endIndex);
        } else if (total > startIndex) {
            list = list.subList(startIndex, total);
        }
        TableDataInfo rspData = new TableDataInfo(list, total);
        rspData.setCode(0);
        return rspData;
    }


    /**
     * 获取隐患台账页面
     */
    @GetMapping("/dangerLedgerListByCompanyId/{companyId}")
    public String dangerLedgerListByCompanyId(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        List<Dept> deptList = deptService.selectDeptListByCompanyId(companyId);
        mmap.put("deptList", deptList);
        getDangerDataStatistics(companyId.toString(), mmap);
        return prefix + "/dangerLedgerListByCompanyId";
    }


    /**
     * thisMonthHighDanger隐患台账  列表页面（根据companyId）
     */
    @GetMapping("/dangerLedgerListByCompanyId/{companyId}/thisMonthHighDanger")
    public String dangerLedgerListByCompanyIdByThisMonthHighDanger(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        List<Dept> deptList = deptService.selectDeptListByCompanyId(companyId);
        mmap.put("deptList", deptList);
        mmap.put("companyId", companyId);
        return prefix + "/dangerLedgerListByCompanyIdByThisMonthHighDanger";
    }

    /**
     * thisMonthNormalDanger隐患台账  列表页面（根据companyId）
     */
    @GetMapping("/dangerLedgerListByCompanyId/{companyId}/thisMonthNormalDanger")
    public String dangerLedgerListByCompanyIdByThisMonthNormalDanger(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        List<Dept> deptList = deptService.selectDeptListByCompanyId(companyId);
        mmap.put("deptList", deptList);
        mmap.put("companyId", companyId);
        return prefix + "/dangerLedgerListByCompanyIdByThisMonthNormalDanger";
    }

    /**
     * unRectifyDanger隐患台账   列表页面（根据companyId）
     */
    @GetMapping("/dangerLedgerListByCompanyId/{companyId}/unRectifyDanger")
    public String dangerLedgerListByCompanyIdByUnRectifyDanger(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        List<Dept> deptList = deptService.selectDeptListByCompanyId(companyId);
        mmap.put("deptList", deptList);
        mmap.put("companyId", companyId);
        return prefix + "/dangerLedgerListByCompanyIdByUnRectifyDanger";
    }


    //companyId下总的数据统计
    public void getDangerDataStatistics(String companyId, ModelMap mmap) {
        HiddenDangerCheckPoint hdcpQuery = new HiddenDangerCheckPoint();
        HiddenDangerCheckPoint hdcpQueryAll = new HiddenDangerCheckPoint();
        HiddenDangerCheckPoint queryByTime = new HiddenDangerCheckPoint();
        hdcpQuery.setRectifyUserIdIsNotNull("1");//隐患整改人ID  不为空
        hdcpQueryAll.setRectifyUserIdIsNotNull("1");//隐患整改人ID  不为空
        queryByTime.setRectifyUserIdIsNotNull("1");//隐患整改人ID  不为空

        hdcpQuery.setCompanyId(Long.valueOf(companyId));
        hdcpQueryAll.setCompanyId(Long.valueOf(companyId));
        queryByTime.setCompanyId(Long.valueOf(companyId));

//        User userQuery = new User();
//        userQuery.setCompanyId(Long.valueOf(companyId));
//        List<User> userList = userService.selectUserList(userQuery);
//        List<Long> userIdList = new ArrayList<>();
//        for (User user : userList) {
//            userIdList.add(user.getUserId());
//        }

        int totalDangerNum = 0;//隐患数
        int rectifyNum = 0;//已整改数目
        int notRectifyNum = 0;//未整改数目
        int totalRectifyNum = 0;//整改总条数（已整改数目+未整改数目）
        String rectifyRate = "暂无";//整改率

        int onTimeRectifyNum = 0;//按期整改数
        String onTimeRectifyRate = "暂无";//按期率
        int overdueRectifyNum = 0;//超期整改数
        String overdueRectifyRate = "暂无";//超期率

        String monthOnMonthRate = "";//环比-------（上个月 - 上上个月）/上上个月
        String yearOnYearRate = "";//同比-------（上个月 - 去年上个月）/去年上个月

//        if (userIdList.size() > 0) {
//            hdcpQueryAll.setLedgerUserIdList(userIdList);//隐患整改人ID 为登陆账号companyId下的userId的
//            queryByTime.setLedgerUserIdList(userIdList);//隐患整改人ID 为登陆账号companyId下的userId的


        //companyId下总的数据统计
        List<HiddenDangerCheckPoint> resultListAll = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(hdcpQueryAll);//根据companyId 查询出的列表

        for (HiddenDangerCheckPoint hdcp : resultListAll) {
            if (!StringUtils.isEmpty(hdcp.getStage())) {
                if ("3".equals(hdcp.getStage())) {
                    if (!StringUtil.isEmpty(hdcp.getExamineStatus())) {
                        if ("0".equals(hdcp.getExamineStatus())) {
                            notRectifyNum++;
                        }
                    }
                } else if ("4".equals(hdcp.getStage())) {
                    if (!StringUtil.isEmpty(hdcp.getRectifyStatus())) {
                        if ("0".equals(hdcp.getRectifyStatus())) {
                            notRectifyNum++;
                        }
                    }
                } else if ("5".equals(hdcp.getStage())) {
                    if (!StringUtil.isEmpty(hdcp.getAcceptStatus())) {
                        rectifyNum++;
                        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
                        try {
                            if (f.parse(f.format(hdcp.getRectifyDeadlineTime())).before(f.parse(f.format(hdcp.getRectifyCompleteTime())))) {
                                overdueRectifyNum++;
                            } else {
                                onTimeRectifyNum++;
                            }
                        } catch (ParseException e) {
                        }
                    }
                }
            }
        }
        totalDangerNum = resultListAll.size();
        totalRectifyNum = rectifyNum + notRectifyNum;
        if (totalDangerNum > 0) {
            //计算整改率
            BigDecimal a = ApiHiddenDangerCheckService.divide(rectifyNum, totalDangerNum, 4);
            //下面将结果转化成百分比
            NumberFormat percent1 = NumberFormat.getPercentInstance();
            percent1.setMaximumFractionDigits(2);
            rectifyRate = percent1.format(a.doubleValue());

            //计算按期率
            BigDecimal b = ApiHiddenDangerCheckService.divide(onTimeRectifyNum, totalDangerNum, 4);
            //下面将结果转化成百分比
            NumberFormat percent2 = NumberFormat.getPercentInstance();
            percent2.setMaximumFractionDigits(2);
            onTimeRectifyRate = percent2.format(b.doubleValue());


            //计算超期率
            BigDecimal c = ApiHiddenDangerCheckService.divide(overdueRectifyNum, totalDangerNum, 4);
            //下面将结果转化成百分比
            NumberFormat percent3 = NumberFormat.getPercentInstance();
            percent3.setMaximumFractionDigits(2);
            overdueRectifyRate = percent3.format(c.doubleValue());
        }


        Map map1 = ApiHiddenDangerCheckService.getLastMonthTime(0, -1);//上个月

        Map map2 = ApiHiddenDangerCheckService.getLastMonthTime(0, -2);//上上个月

        Map map3 = ApiHiddenDangerCheckService.getLastMonthTime(-1, -1);//去年上个月


        queryByTime.setParams(map1);
        List<HiddenDangerCheckPoint> list1 = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(queryByTime);//上个月
        queryByTime.setParams(map2);
        List<HiddenDangerCheckPoint> list2 = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(queryByTime);//上上个月
        queryByTime.setParams(map3);
        List<HiddenDangerCheckPoint> list3 = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(queryByTime);//去年上个月


        //计算环比
        if (list2.size() > 0) {
            BigDecimal d = ApiHiddenDangerCheckService.divide((list1.size() - list2.size()), list2.size(), 4);
            //下面将结果转化成百分比
            NumberFormat percent4 = NumberFormat.getPercentInstance();
            percent4.setMaximumFractionDigits(2);
            monthOnMonthRate = percent4.format(d.doubleValue());
        } else {
            monthOnMonthRate = "暂无";
        }


        //计算同比
        if (list3.size() > 0) {
            BigDecimal e = ApiHiddenDangerCheckService.divide((list1.size() - list3.size()), list3.size(), 4);
            //下面将结果转化成百分比
            NumberFormat percent5 = NumberFormat.getPercentInstance();
            percent5.setMaximumFractionDigits(2);
            yearOnYearRate = percent5.format(e.doubleValue());
        } else {
            yearOnYearRate = "暂无";
        }
//    }


        mmap.put("totalDangerNum", totalDangerNum);
        mmap.put("rectifyNum", rectifyNum);
        mmap.put("notRectifyNum", notRectifyNum);
        mmap.put("rectifyRate", rectifyRate);
        mmap.put("onTimeRectifyNum", onTimeRectifyNum);
        mmap.put("onTimeRectifyRate", onTimeRectifyRate);
        mmap.put("overdueRectifyNum", overdueRectifyNum);
        mmap.put("overdueRectifyRate", overdueRectifyRate);

        mmap.put("monthOnMonthRate", monthOnMonthRate);
        mmap.put("yearOnYearRate", yearOnYearRate);
    }


    /**
     * 查询隐患台账列表（根据companyId）
     */
    @PostMapping("/dangerLedgerListByCompanyId")
    @ResponseBody
    public TableDataInfo dangerLedgerListByCompanyId(String companyId, HiddenDangerCheckPoint hiddenDangerCheckPoint, String dateRangeLedger, String rectifyStatusLedger, String rectifyDeptIdLedger) {
//        User userQuery = new User();
//        userQuery.setCompanyId(Long.valueOf(companyId));
//        List<User> userList = userService.selectUserList(userQuery);
//        List<Long> userIdList = new ArrayList<>();
//        for (User user : userList) {
//            userIdList.add(user.getUserId());
//        }
//
//        if (userIdList.size() == 0) {
//            return getDataTable(new ArrayList<HiddenDangerCheckPoint>());
//        }
//
//        hiddenDangerCheckPoint.setLedgerUserIdList(userIdList);//隐患整改人ID 为登陆账号companyId下的userId的

        hiddenDangerCheckPoint.setRectifyUserIdIsNotNull("1");//隐患整改人ID  不为空
        hiddenDangerCheckPoint.setCompanyId(Long.valueOf(companyId));
        //日期区间
        if (!StringUtils.isEmpty(dateRangeLedger)) {
            if (("近一周").equals(dateRangeLedger)) {
                hiddenDangerCheckPoint.setParams(ApiHiddenDangerCheckService.getDaySevenRange());
            } else if (("近一月").equals(dateRangeLedger)) {
                hiddenDangerCheckPoint.setParams(ApiHiddenDangerCheckService.getMonthRange());
            } else if (("近一年").equals(dateRangeLedger)) {
                hiddenDangerCheckPoint.setParams(ApiHiddenDangerCheckService.getYearRange());
            } else if (("当月").equals(dateRangeLedger)) {
                hiddenDangerCheckPoint.setParams(ApiHiddenDangerCheckService.getLastMonthTime(0, 0));
            }
        }
        //整改状态
        if (!StringUtils.isEmpty(rectifyStatusLedger)) {
            if (("未整改").equals(rectifyStatusLedger)) {
                hiddenDangerCheckPoint.setStage("4");
                hiddenDangerCheckPoint.setRectifyStatus("0");
            } else if (("未验收").equals(rectifyStatusLedger)) {
                hiddenDangerCheckPoint.setStage("5");
                hiddenDangerCheckPoint.setAcceptStatus("0");
            } else if (("已验收").equals(rectifyStatusLedger)) {
                hiddenDangerCheckPoint.setStage("5");
                hiddenDangerCheckPoint.setAcceptStatus("1");
            } else if (("超期改").equals(rectifyStatusLedger)) {
                hiddenDangerCheckPoint.setStage("5");
                hiddenDangerCheckPoint.setOverdueRectify("1");
            }
        }
        //整改部门
        if (!StringUtils.isEmpty(rectifyDeptIdLedger)) {
            hiddenDangerCheckPoint.setRectifyDeptId(Long.valueOf(rectifyDeptIdLedger));
        }

        startPage();
        List<HiddenDangerCheckPoint> list = hiddenDangerCheckPointService.selectHiddenDangerCheckPointList(hiddenDangerCheckPoint);
        return getDataTable(list);
    }


    /**
     * 获取排查计划页面
     */
    @GetMapping("/dangerPlanExecuteByCompanyId/{companyId}")
    public String dangerPlanExecuteListByCompanyId(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        mmap.put("companyId", companyId);
        return prefix + "/dangerPlanExecuteByCompanyId";
    }


    /**
     * 获取排查计划列表
     */
    @PostMapping("/dangerPlanExecuteByCompanyId")
    @ResponseBody
    public TableDataInfo dangerPlanExecuteListByCompanyId(String companyId, HiddenDangerCheck hiddenDangerCheck) {

        User userQuery = new User();
        userQuery.setCompanyId(Long.valueOf(companyId));
        List<User> userList = userService.selectUserList(userQuery);
        List<Long> userIdList = new ArrayList<>();
        for (User user : userList) {
            userIdList.add(user.getUserId());
        }
        if (userIdList.size() == 0) {
            return getDataTable(new ArrayList<HiddenDangerCheck>());
        }
        hiddenDangerCheck.setCheckUserIdList(userIdList);//排查人ID 为登陆账号companyId下的userId的
        hiddenDangerCheck.setPlanFormulateStatusExclude(TrHiddenDangerCheckConstants.PLAN_FORMULATE_STATUS_NOT_STARTED);//排除---------隐患排查计划制定(未开始)的
        startPage();
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 获取定时隐患排查页面
     */
    @GetMapping("/dangerScheduleByCompanyId/{companyId}")
    public String dangerScheduleByCompanyId(@PathVariable("companyId") Long companyId, ModelMap mmap) {
        mmap.put("companyId", companyId);
        return prefix + "/dangerScheduleByCompanyId";
    }


    /**
     * 查询定时隐患排查列表
     */
    @PostMapping("/dangerScheduleByCompanyId")
    @ResponseBody
    public TableDataInfo dangerScheduleByCompanyId(String companyId, HiddenDangerCheck hiddenDangerCheck) {

        User userQuery = new User();
        userQuery.setCompanyId(Long.valueOf(companyId));
        List<User> userList = userService.selectUserList(userQuery);
        List<Long> userIdList = new ArrayList<>();
        for (User user : userList) {
            userIdList.add(user.getUserId());
        }
        if (userIdList.size() == 0) {
            return getDataTable(new ArrayList<HiddenDangerCheck>());
        }
        //排查人为 为登陆账号companyId下的userId的
        hiddenDangerCheck.setScheduleCheckUserIdList(userIdList);
        startPage();
        List<HiddenDangerCheck> list = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
        return getDataTable(list);
    }


    /**
     * 根据指定公司id,跳转至该公司台账页面
     *
     * @param modelMap
     * @param companyId
     * @return
     */
    @GetMapping("/riskCheckPoint/ledger/{companyId}")
    public String ledgerByCompanyId(ModelMap modelMap,
                                    @PathVariable("companyId") String companyId) {
        //查询该公司所有区域
        List<Region> regionList = regionService.selectRegionListByCompanyId(Long.valueOf(companyId));
        modelMap.put("regionList", regionList);
        modelMap.put("companyId", companyId);
        return prefix + "/ledger";
    }


    /**
     * 查询检查点及评价列表
     */
    @PostMapping("/riskCheckPoint/ledger")
    @ResponseBody
    public TableDataInfo ledgerList(RiskCheckPoint riskCheckPoint) {
        startPage();
        List<RiskCheckPoint> list = riskCheckPointService.selectRiskCheckPointList(riskCheckPoint);
        return getDataTable(list);
    }


    /**
     * 用于记录风险清单台账
     *
     * @return
     */
    @GetMapping("/riskCheckPoint/ledger/{companyId}/{level}")
    public String ledgerByCompanyIdAndRiskLevel(ModelMap modelMap,
                                                @PathVariable("companyId") Long companyId, @PathVariable("level") String level) {

        //查询该公司所有区域
        List<Region> regionList = regionService.selectRegionListByCompanyId(companyId);
        modelMap.put("regionList", regionList);

        modelMap.put("companyId", companyId);
        if ("major".equals(level)) {
            //重大风险
            modelMap.put("level", "重大");
        } else if ("larger".equals(level)) {
            //较大风险
            modelMap.put("level", "较大");
        } else if ("general".equals(level)) {
            //一般风险
            modelMap.put("level", "一般");
        } else if ("low".equals(level)) {
            modelMap.put("level", "低");
        }

        return prefix + "/ledgerByCompanyIdAndRiskLevel";
    }


    /**
     * 获取公司信息(文章)页面
     */
    @GetMapping("/articleByCompanyId/{companyId}")
    public String articleByCompanyId(@PathVariable("companyId") Long companyId, ModelMap map) {
        map.put("companyId", companyId);
        return prefix + "/articleByCompanyId";
    }

    /**
     * 查询公司信息(文章)列表
     */
    @PostMapping("/articleByCompanyId")
    @ResponseBody
    public TableDataInfo articleByCompanyId(Article article, String companyId) {
        startPage();
        //用户查询文章列表，应根据所属公司查询
        article.setCompanyId(Long.valueOf(companyId));
        List<Article> list = articleService.selectArticleList(article);
        return getDataTable(list);
    }


    /**
     * 预览公司信息(文章)
     */
    @GetMapping("/previewArticle/{articleId}")
    public String previewArticle(@PathVariable("articleId") Long articleId, ModelMap mmap) {
        Article article = articleService.selectArticleById(articleId);
        mmap.put("article", article);
        return prefix + "/previewArticle";
    }


    /**
     * 获取法律法规政策页面
     */
    @GetMapping("/articleRegulationByCompanyId/{companyId}")
    public String articleRegulationByCompanyId(@PathVariable("companyId") String companyId, ModelMap map) {
        map.put("companyId", companyId);
        return prefix + "/articleRegulationByCompanyId";
    }

    /**
     * 查询法律法规政策文章列表
     */
    @PostMapping("/articleRegulationByCompanyId")
    @ResponseBody
    public TableDataInfo articleRegulationByCompanyId(ArticleRegulation articleRegulation, String companyId) {
        startPage();
        articleRegulation.setCompanyId(Long.valueOf(companyId));
        List<ArticleRegulation> list = articleRegulationService.selectArticleRegulationList(articleRegulation);
        return getDataTable(list);
    }


    /**
     * 预览法律法规政策文章
     */
    @GetMapping("/previewArticleRegulation/{articleRegulationId}")
    public String previewArticleRegulation(@PathVariable("articleRegulationId") Long articleRegulationId, ModelMap mmap) {
        ArticleRegulation articleRegulation = articleRegulationService.selectArticleRegulationById(articleRegulationId);
        mmap.put("articleRegulation", articleRegulation);
        return prefix + "/previewArticleRegulation";
    }

}