package cn.huge.module.analysis.controller;

import cn.huge.base.common.bo.ReturnBO;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.analysis.domain.dto.*;
import cn.huge.module.analysis.domain.vo.CountRepeateVo;
import cn.huge.module.analysis.service.AnalysisService;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.cust.dto.CtUnitDTO;
import cn.huge.module.cust.dto.CtUserDTO;
import com.google.common.collect.Maps;
import dm.jdbc.util.StringUtil;
import org.apache.commons.lang3.StringUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @title: 纠纷信息主表接口api-web端
 * @description: 纠纷信息主表接口api-web端
 * @company: hugeinfo
 * @author: wangwh
 * @time: 2024-08-27 10:00:57
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/analysis")
public class AnalysisWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private AnalysisService service;
    @Autowired
    private CustClientImpl custClient;

    /**
     * 获取请求URL参数
     * @return Map<String, Object>
     */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 组织地址社区
        String queVillage = request.getParameter("queVillage");
        if (StringUtils.isNotBlank(queVillage)){
            terms.put("village", queVillage);
        }
        // 组织地址街道
        String queRoad = request.getParameter("queRoad");
        if (StringUtils.isNotBlank(queRoad)){
            terms.put("road", queRoad);
        }
        // 组织地址区
        String queArea = request.getParameter("queArea");
        if (StringUtils.isNotBlank(queArea)){
            terms.put("area", queArea);
        }
        // 组织地址市
        String queCity = request.getParameter("queCity");
        if (StringUtils.isNotBlank(queCity)){
            terms.put("city", queCity);
        }
        // 组织地址省
        String queProv = request.getParameter("queProv");
        if (StringUtils.isNotBlank(queProv)){
            terms.put("prov", queProv);
        }
        // 纠纷类型
        String caseType = request.getParameter("caseType");
        if (StringUtils.isNotBlank(caseType)){
            terms.put("caseType", caseType);
        }
        // 纠纷类型
        String caseTypeFirst = request.getParameter("caseTypeFirst");
        if (StringUtils.isNotBlank(caseTypeFirst)){
            terms.put("caseTypeFirst", caseTypeFirst);
        }
        // 登记开始时间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 办结时间
        String closeStart = request.getParameter("closeStart");
        String closeEnd = request.getParameter("closeEnd");
        if(StringUtils.isNotBlank(closeStart) && StringUtils.isNotBlank(closeEnd)) {
            terms.put("closeStart", closeStart);
            terms.put("closeEnd", closeEnd);
        }
        // 事项等级
        String caseGrade = request.getParameter("caseGrade");
        if (org.apache.commons.lang3.StringUtils.isNotBlank(caseGrade)){
            terms.put("caseGrade", caseGrade);
        }
        // 事项来源
        String caseSource = request.getParameter("caseSource");
        if (org.apache.commons.lang3.StringUtils.isNotBlank(caseSource)){
            terms.put("caseSource", caseSource);
        }
        // 承办部门
        String mediateUnitId = request.getParameter("mediateUnitId");
        if (StringUtils.isNotBlank(mediateUnitId)){
            terms.put("mediateUnitId", mediateUnitId);
        }
        // 配合部门
        String assistUnitId = request.getParameter("assistUnitId");
        if (StringUtils.isNotBlank(assistUnitId)){
            terms.put("assistUnitId", assistUnitId);
        }
        return terms;
    }

    /**
     * 获取请求URL参数(获取区域地址后放入map的名称不一样)
     * @return Map<String, Object>
     */
    private Map<String, Object> getParameter1(){
        Map<String, Object> terms = Maps.newHashMap();
        // 组织地址街道
        String queRoad = request.getParameter("queRoad");
        if (StringUtils.isNotBlank(queRoad)){
            terms.put("queRoad", queRoad);
        }else{
            // 组织地址区
            String queArea = request.getParameter("queArea");
            if (StringUtils.isNotBlank(queArea)){
                terms.put("queArea", queArea);
            }else{
                // 组织地址市
                String queCity = request.getParameter("queCity");
                if (StringUtils.isNotBlank(queCity)){
                    terms.put("queCity", queCity);
                }else{
                    // 组织地址省
                    String queProv = request.getParameter("queProv");
                    if (StringUtils.isNotBlank(queProv)){
                        terms.put("queProv", queProv);
                    }
                }
            }
        }
        // 纠纷类型
        String caseType = request.getParameter("caseType");
        if (StringUtils.isNotBlank(caseType)){
            terms.put("caseType", caseType);
        }
        // 纠纷类型
        String caseTypeFirst = request.getParameter("caseTypeFirst");
        if (StringUtils.isNotBlank(caseTypeFirst)){
            terms.put("caseTypeFirst", caseTypeFirst);
        }
        // 登记开始时间
        String createStart = request.getParameter("createStart");
        String createEnd = request.getParameter("createEnd");
        if(StringUtils.isNotBlank(createStart) && StringUtils.isNotBlank(createEnd)) {
            terms.put("createStart", createStart);
            terms.put("createEnd", createEnd);
        }
        // 办结时间
        String closeStart = request.getParameter("closeStart");
        String closeEnd = request.getParameter("closeEnd");
        if(StringUtils.isNotBlank(closeStart) && StringUtils.isNotBlank(closeEnd)) {
            terms.put("closeStart", closeStart);
            terms.put("closeEnd", closeEnd);
        }
        // 事项等级
        String caseGrade = request.getParameter("caseGrade");
        if (org.apache.commons.lang3.StringUtils.isNotBlank(caseGrade)){
            terms.put("caseGrade", caseGrade);
        }
        // 事项来源
        String caseSource = request.getParameter("caseSource");
        if (org.apache.commons.lang3.StringUtils.isNotBlank(caseSource)){
            terms.put("caseSource", caseSource);
        }
        // 事项来源
        String canal = request.getParameter("canal");
        if (org.apache.commons.lang3.StringUtils.isNotBlank(canal)){
            terms.put("canal", canal);
        }
        // 承办部门
        String mediateUnitId = request.getParameter("mediateUnitId");
        if (StringUtils.isNotBlank(mediateUnitId)){
            terms.put("mediateUnitId", mediateUnitId);
        }
        // 配合部门
        String assistUnitId = request.getParameter("assistUnitId");
        if (StringUtils.isNotBlank(assistUnitId)){
            terms.put("assistUnitId", assistUnitId);
        }
        //任务是否完成
        String taskStatus = request.getParameter("taskStatus");
        if (StringUtils.isNotBlank(taskStatus)){
            terms.put("taskStatus", taskStatus);
        }
        return terms;
    }
    /**
     * 统计重复来访案件数量-根据案件类型分组
     * 此接口用于分析和统计在同一案件类型下重复来访的案件数量
     * @url {ctx}/api/web/analysis/countRepeatedCasesByCaseType
     * @param countRepeateVo 包含查询条件的请求体，用于指定统计范围
     * @return ReturnBO
     */
    @PostMapping("/countRepeatedCasesByCaseType")
    public ReturnBO countRepeatedCasesByCaseType(@RequestBody CountRepeateVo countRepeateVo) {
        try{
            // 设置按案件类型分组的标志为true
            countRepeateVo.setGroupByCaseType("true");

            // 调用服务层方法统计重复来访案件数量
            List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCases(countRepeateVo);

            // 使用ReturnSucUtils工具类返回成功信息和统计结果
            return ReturnSucUtils.getRepInfo("请求成功",countRepeateDtoList);
        }catch (Exception e){
            // 捕获异常，并记录错误日志
            log.error("统计重复来访案件数量异常",e);

            // 使用ReturnFailUtils工具类返回错误信息
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * 统计重复来访案件数量-根据地区分组
     * @url {ctx}/api/web/analysis/countRepeatedCasesByArea
     * @param countRepeateVo 包含查询条件的请求体，用于指定统计范围
     * @return ReturnBO 包含统计结果的返回对象
     */
    @PostMapping("/countRepeatedCasesByArea")
    public ReturnBO countRepeatedCasesByArea(@RequestBody CountRepeateVo countRepeateVo) {
        try{
            // 创建一个映射，用于存储不同状态下重复来访案件的统计结果
            Map<String, List<CountRepeateDto>> collect = new HashMap<>();

            // 判断是否提供了结案时间，如果没有，则查询未办结的重复来访案件
            if(StringUtil.isEmpty(countRepeateVo.getCloseStart()) && StringUtil.isEmpty(countRepeateVo.getCloseEnd())){
                countRepeateVo.setIsFinish("false");
                List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCasesByArea(countRepeateVo);
                collect.put("未办结重复来访",countRepeateDtoList);
            }else {
                // 如果提供了关闭时间范围，则初始化未办结案件列表为空
                collect.put("未办结重复来访",new ArrayList<>());
            }

            // 统计已办结的重复来访案件
            countRepeateVo.setIsFinish("true");
            List<CountRepeateDto> countRepeateDtoListIsFinish = service.countRepeatedCasesByArea(countRepeateVo);
            collect.put("已办结重复来访",countRepeateDtoListIsFinish);

            // 返回统计结果
            return ReturnSucUtils.getRepInfo("请求成功",collect);
        }catch (Exception e){
            // 记录异常信息并返回错误响应
            log.error("统计重复来访案件数量异常",e);
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * 统计重复来访案件数量-根据时间分组
     * @url {ctx}/api/web/analysis/countRepeatedCasesByCaseType
     * @param countRepeateVo 包含查询条件的请求体
     * @return ReturnBO 包含统计结果的返回对象
     */
    @PostMapping("/countRepeatedCasesByTime")
    public ReturnBO countRepeatedCasesByTime(@RequestBody CountRepeateVo countRepeateVo) {
        try{
            // 创建一个映射，用于存储不同状态下重复来访案件的统计结果
            Map<String, List<CountRepeateDto>> collect = new HashMap<>();

            // 判断是否提供了结案时间，如果没有，则查询未办结的重复来访案件
            if((StringUtil.isEmpty(countRepeateVo.getCloseStart())) && (StringUtil.isEmpty(countRepeateVo.getCloseEnd()))){
                countRepeateVo.setIsFinish("false");
                List<CountRepeateDto> countRepeateDtoList = service.countRepeatedCasesByTime(countRepeateVo);
                collect.put("未办结重复来访",countRepeateDtoList);
            }else {
                // 如果提供了结案时间，则初始化未办结重复来访案件列表为空
                collect.put("未办结重复来访",new ArrayList<>());
            }

            // 查询已办结的重复来访案件
            countRepeateVo.setIsFinish("true");
            List<CountRepeateDto> countRepeateDtoListIsFinish = service.countRepeatedCasesByTime(countRepeateVo);
            collect.put("已办结重复来访",countRepeateDtoListIsFinish);

            // 返回统计结果
            return ReturnSucUtils.getRepInfo("请求成功",collect);
        }catch (Exception e){
            // 异常处理，记录日志并返回错误信息
            log.error("统计重复来访案件数量异常",e);
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * 条件查询多个
     * @url {ctx}/api/web/analysis/statistics
     * @return Object
     */
    @GetMapping("/statistics")
    public Object statistics(@CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
            Map<String, Object> terms = getParameter1();
            //拷贝条件，避免影响原参数
            AvgDurationDTO avgDurationDTO = service.AvgDuration(terms, loginUser, ctUnitDTO);

            return ReturnSucUtils.getRepInfo(avgDurationDTO);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 超时任务数量查询
     * @url {ctx}/api/web/analysis/timeoutTask
     * @return Object
     */
    @GetMapping("/timeoutTask")
    public Object timeoutTask(@CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
            Map<String, Object> terms = getParameter1();
            StatisticsGroupDTO statisticsGroupDTO = new StatisticsGroupDTO();

            statisticsGroupDTO = service.TimeoutTask(terms, ctUnitDTO);
            return ReturnSucUtils.getRepInfo(statisticsGroupDTO);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 超时任务数量查询
     * @url {ctx}/api/web/analysis/listTimeOutTaskGroup
     * @return Object
     */
    @GetMapping("/listTimeOutTaskGroup")
    public Object listTimeOutTaskGroup(@CurrentUser String userId, @RequestParam(value = "queryType") int queryType) {
        try {
            // 获取当前登录用户
            CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
            Map<String, Object> terms = getParameter1();
            List<TimeOutTaskGroupDTO> timeOutTaskGroupDTOList = new ArrayList<>();

            timeOutTaskGroupDTOList = service.listTimeOutTaskGroup(terms, ctUnitDTO, queryType);
            return ReturnSucUtils.getRepInfo(timeOutTaskGroupDTOList);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 效能分析-平均时长-分组列表
     * @url {ctx}/api/web/analysis/AvgDurationGroup
     * @return Object
     */
    @GetMapping("/AvgDurationGroup")
    public Object AvgDurationGroup(@CurrentUser String userId) {
        try {
            Map<String, Object> terms = getParameter1();
            // 排序字段
            String sortColmn1 = request.getParameter("sortColmn");
            int sortColmn = 0;
            if (StringUtils.isNotBlank(sortColmn1)){
                sortColmn = Integer.parseInt(sortColmn1);
            }
            // 排序方式
            String sortType1 = request.getParameter("sortType");
            int sortType = 0;
            if (StringUtils.isNotBlank(sortType1)){
                sortType = Integer.parseInt(sortType1);
            }

            return ReturnSucUtils.getRepInfo(service.AvgDurationGroup(terms, sortType, sortColmn));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 效能分析-平均时长-统计图
     * @url {ctx}/api/web/analysis/AvgDurationChartsGroup
     * @return Object
     */
    @GetMapping("/AvgDurationChartsGroup")
    public Object AvgDurationChartsGroup(@CurrentUser String userId) {
        try {
            Map<String, Object> terms = getParameter1();
            return ReturnSucUtils.getRepInfo(service.AvgDurationChartsGroup(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 分页查询受理超时案件
     * @url {ctx}/api/web/analysis/pageQuantity
     * @param page 页码
     * @param size 每页数量
     * @param queryType 查询类型（1：分派；2、签收；3、受理；4、督办）
     * @return
     */
    @GetMapping("/pageQuantity")
    public Object pageQuantity(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                 @RequestParam(value = "queryType") int queryType, @CurrentUser String userId) {
        try {
            Map<String, Object> terms = getParameter1();
            // 排序字段
            String sortColmn1 = request.getParameter("sortColmn");
            int sortColmn = 1;
            if (StringUtils.isNotBlank(sortColmn1)){
                sortColmn = Integer.parseInt(sortColmn1);
            }
            // 排序方式
            String sortType1 = request.getParameter("sortType");
            int sortType = 1;
            if (StringUtils.isNotBlank(sortType1)){
                sortType = Integer.parseInt(sortType1);
            }
            Sort sort = null;
            String sortName = null;
            switch (sortColmn){
                case 1:
                    sortName = "turnaroundTime";
                    break;
                case 2:
                    sortName = "timeLimit";
                    break;
                case 3:
                    sortName = "caseGrade";
                    break;
                case 4:
                    sortName = "superviseCount";
                    break;
                default:
                    sortName = "turnaroundTime";
                    break;
            }
            switch (sortType){
                case 1:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
                default:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
            }
            if(ObjectUtils.isEmpty(sort)){
                sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            }
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<TimeoutTaskInfoDTO> timeoutTaskInfoDTOPage = null;

            CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
            if(1 == queryType){
                timeoutTaskInfoDTOPage = service.pageFPQuantity(pageRequest, terms);
            }else if(2 == queryType){
                timeoutTaskInfoDTOPage = service.pageSLQuantity(pageRequest, terms);
            }else if(3 == queryType){
                timeoutTaskInfoDTOPage = service.pageDBQuantity(pageRequest, terms);
            }else if(4 == queryType){
                timeoutTaskInfoDTOPage = service.pageAllQuantity(pageRequest, terms);
            }
            return ReturnSucUtils.getRepInfo(timeoutTaskInfoDTOPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 分组任务流转统计
     * @url {ctx}/api/web/analysis/statisticsCirculation
     * @return
     */
    @GetMapping("/statisticsCirculation")
    public Object statisticsCirculation() {
        try {
            Map<String, Object> terms = getParameter1();
            // 排序字段
            String sortColmn1 = request.getParameter("sortColmn");
            int sortColmn = 0;
            if (StringUtils.isNotBlank(sortColmn1)){
                sortColmn = Integer.parseInt(sortColmn1);
            }
            // 排序方式
            String sortType1 = request.getParameter("sortType");
            int sortType = 0;
            if (StringUtils.isNotBlank(sortType1)){
                sortType = Integer.parseInt(sortType1);
            }
            return ReturnSucUtils.getRepInfo(service.statisticsCirculation(terms, sortType, sortColmn));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 效能分析-分组任务-统计图
     * @url {ctx}/api/web/analysis/statisticsCirculationCharts
     * @return
     */
    @GetMapping("/statisticsCirculationCharts")
    public Object statisticsCirculationCharts(@CurrentUser String userId) {
        try {
            Map<String, Object> terms = getParameter1();
            return ReturnSucUtils.getRepInfo(service.statisticsCirculationCharts(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 解纷态势-分组查询扬言极端数量
     * @url {ctx}/api/web/analysis/statisticsYYJDQuantity
     * @return Object
     */
    @GetMapping("/statisticsYYJDQuantity")

    public Object statisticsYYJDQuantity(@CurrentUser String userId) {
        try {
            Map<String, Object> terms = getParameter();
            // 组织地址社区
            String sortType = request.getParameter("sortType");
            if (StringUtils.isNotBlank(sortType)){
                terms.put("sortType", sortType);
            }
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            CtUnitDTO ctUnitDTO = custClient.getUnitByUserId(userId);
            return ReturnSucUtils.getRepInfo(service.statisticsYYJDQuantity(terms, ctUnitDTO));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 查询流转情况列表
     * @url {ctx}/api/web/analysis/listStatisticsCirculation
     * @return
     */
    @GetMapping("/listStatisticsCirculation")
    public Object listStatisticsCirculation(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                            @RequestParam(value = "caseStatus") String caseStatus,
                                            @RequestParam(value = "regionCode") String regionCode, @RequestParam(value = "regionName") String regionName) {
        try {
            Map<String, Object> terms = getParameter1();
            if(StringUtils.isNotBlank(caseStatus)){
                terms.put("caseStatus", caseStatus);
            }
            if(StringUtils.isNotBlank(regionCode) && StringUtils.isNotBlank(regionName)){
                if(regionName.matches(".*市")){
                    terms.put("queCity", regionCode);
                }else if(regionName.matches(".*区")){
                    terms.put("queArea", regionCode);
                }else if(regionName.contains("街道") || regionName.matches(".*街") || regionName.matches(".*镇")){
                    terms.put("queRoad", regionCode);
                }
            }
            Sort sort = Sort.by(Sort.Direction.DESC, "t3.create_time");
            PageRequest pageRequest = PageRequest.of(page - 1, size, sort);
            return ReturnSucUtils.getRepInfo(service.listStatisticsCirculation(terms, pageRequest));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }
}