package cn.huge.module.thirdByRmtj.controller.web;

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.cases.service.CaseInfoService;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.mediate.constant.CaseInfoProcessBaseConstsEnum;
import cn.huge.module.thirdByRmtj.domain.dto.RmtjApplyPageDTO;
import cn.huge.module.thirdByRmtj.domain.dto.RmtjAuditDTO;
import cn.huge.module.thirdByRmtj.domain.dto.RmtjAuditPageDTO;
import cn.huge.module.thirdByRmtj.domain.po.ThRmtjAudit;
import cn.huge.module.thirdByRmtj.service.ThRmtjApplyService;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
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.List;
import java.util.Map;

/**
 * @title: 第三方系统对接-转人民调解系统申请表接口api-web端
 * @description: 第三方系统对接-转人民调解系统申请表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-11-15 10:56:25
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/rmtj")
public class ThRmtjWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private ThRmtjApplyService service;
    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private CaseInfoService caseInfoService;

    /**
     * web端-转入人民调解系统-申请列表
     * @url {ctx}/api/web/rmtj/pageApply
     * @param page 页码
     * @param size 每页数量
     * @param applyType 1：未申请，2：已申请
     * @param userId 当前登录用户
     * @return Object
     */
    @GetMapping("/pageApply")
    public Object pageApply(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                            @RequestParam(value = "applyType") int applyType, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            Map<String, Object> terms = Maps.newHashMap();
            // 办结时间区间
            String closeStart = request.getParameter("closeStart");
            if (StringUtils.isNotBlank(closeStart)){
                terms.put("closeStart", closeStart);
            }
            String closeEnd = request.getParameter("closeEnd");
            if (StringUtils.isNotBlank(closeEnd)){
                terms.put("closeEnd", closeEnd);
            }
            // 提审时间区间
            String applyStart = request.getParameter("applyStart");
            if (StringUtils.isNotBlank(applyStart)){
                terms.put("firstApplyStart", applyStart);
            }
            String applyEnd = request.getParameter("applyEnd");
            if (StringUtils.isNotBlank(applyEnd)){
                terms.put("firstApplyEnd", applyEnd);
            }
            // 转入时间区间
            String rmtjStart = request.getParameter("rmtjStart");
            if (StringUtils.isNotBlank(rmtjStart)){
                terms.put("rmtjStart", rmtjStart);
            }
            String rmtjEnd = request.getParameter("rmtjEnd");
            if (StringUtils.isNotBlank(rmtjEnd)){
                terms.put("rmtjEnd", rmtjEnd);
            }
            // 初审结果
            String firstAuditResult = request.getParameter("firstAuditResult");
            if (StringUtils.isNotBlank(firstAuditResult)){
                terms.put("firstAuditResult", firstAuditResult);
            }
            // 终审结果
            String endAuditResult = request.getParameter("endAuditResult");
            if (StringUtils.isNotBlank(endAuditResult)){
                terms.put("endAuditResult", endAuditResult);
            }
            // 转入结果
            String rmtjStatus = request.getParameter("rmtjStatus");
            if (StringUtils.isNotBlank(rmtjStatus)){
                terms.put("rmtjStatus", rmtjStatus);
            }
            // 转入案号
            String rmtjCaseId = request.getParameter("rmtjCaseId");
            if (StringUtils.isNotBlank(rmtjCaseId)){
                terms.put("rmtjCaseId", rmtjCaseId);
            }
            // 当事人申请人名称，多个用,隔开
            String plaintiffs = request.getParameter("plaintiffs");
            if (StringUtils.isNotBlank(plaintiffs)){
                terms.put("plaintiffs", plaintiffs);
            }
            // 当事人被申请人名称，多个用,隔开
            String defendants = request.getParameter("defendants");
            if (StringUtils.isNotBlank(defendants)){
                terms.put("defendants", defendants);
            }
            // 事项编号
            String caseRef = request.getParameter("caseRef");
            if (StringUtils.isNotBlank(caseRef)){
                terms.put("caseRef", caseRef);
            }
            // 登记方式
            String inputWay = request.getParameter("inputWay");
            if (StringUtils.isNotBlank(inputWay)){
                terms.put("inputWay", inputWay);
            }
            terms.put("applyType", applyType);
            terms.put("infoProcess", CaseInfoProcessBaseConstsEnum.CASE_INFO_PROCESS_3.getIndex());
            terms.put("mediateUnitId", loginUser.getUnitId());
            Sort sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            PageRequest pageRequest = PageRequest.of(page - 1, size, sort);
            Page<RmtjApplyPageDTO> dtoPage = service.pageApply(pageRequest, terms);
            return ReturnSucUtils.getRepInfo(dtoPage);
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.pageApply]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-申请列表统计
     * @url {ctx}/api/web/rmtj/countApply
     * @param userId 当前登录用户
     * @return Object
     */
    @GetMapping("/countApply")
    public Object countApply(@CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            Map<String, Object> terms = Maps.newHashMap();
            // 办结时间区间
            String closeStart = request.getParameter("closeStart");
            if (StringUtils.isNotBlank(closeStart)){
                terms.put("closeStart", closeStart);
            }
            String closeEnd = request.getParameter("closeEnd");
            if (StringUtils.isNotBlank(closeEnd)){
                terms.put("closeEnd", closeEnd);
            }
            // 提审时间区间
            String applyStart = request.getParameter("applyStart");
            if (StringUtils.isNotBlank(applyStart)){
                terms.put("applyStart", applyStart);
            }
            String applyEnd = request.getParameter("applyEnd");
            if (StringUtils.isNotBlank(applyEnd)){
                terms.put("applyEnd", applyEnd);
            }
            // 转入时间区间
            String rmtjStart = request.getParameter("rmtjStart");
            if (StringUtils.isNotBlank(rmtjStart)){
                terms.put("rmtjStart", rmtjStart);
            }
            String rmtjEnd = request.getParameter("rmtjEnd");
            if (StringUtils.isNotBlank(rmtjEnd)){
                terms.put("rmtjEnd", rmtjEnd);
            }
            // 初审结果
            String firstAuditResult = request.getParameter("firstAuditResult");
            if (StringUtils.isNotBlank(firstAuditResult)){
                terms.put("firstAuditResult", firstAuditResult);
            }
            // 终审结果
            String endAuditResult = request.getParameter("endAuditResult");
            if (StringUtils.isNotBlank(endAuditResult)){
                terms.put("endAuditResult", endAuditResult);
            }
            // 转入结果
            String rmtjStatus = request.getParameter("rmtjStatus");
            if (StringUtils.isNotBlank(rmtjStatus)){
                terms.put("rmtjStatus", rmtjStatus);
            }
            // 转入案号
            String rmtjCaseId = request.getParameter("rmtjCaseId");
            if (StringUtils.isNotBlank(rmtjCaseId)){
                terms.put("rmtjCaseId", rmtjCaseId);
            }
            // 当事人申请人名称，多个用,隔开
            String plaintiffs = request.getParameter("plaintiffs");
            if (StringUtils.isNotBlank(plaintiffs)){
                terms.put("plaintiffs", plaintiffs);
            }
            // 当事人被申请人名称，多个用,隔开
            String defendants = request.getParameter("defendants");
            if (StringUtils.isNotBlank(defendants)){
                terms.put("defendants", defendants);
            }
            // 事项编号
            String caseRef = request.getParameter("caseRef");
            if (StringUtils.isNotBlank(caseRef)){
                terms.put("caseRef", caseRef);
            }
            // 登记方式
            String inputWay = request.getParameter("inputWay");
            if (StringUtils.isNotBlank(inputWay)){
                terms.put("inputWay", inputWay);
            }
            terms.put("mediateUnitId", loginUser.getUnitId());
            return ReturnSucUtils.getRepInfo(service.countApply(terms));
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.countApply]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-批量转入人民调解系统申请
     * @url {ctx}/api/web/rmtj/batchSendApply
     * @param caseIdList 申请案件编号集合
     * @param userId 当前登录用户
     * @return Object
     */
    @PostMapping("/batchSendApply")
    public Object batchSendApply(@RequestBody List<String> caseIdList, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.batchSendApply(caseIdList, loginUser);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.batchSendApply]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-人民调解初审列表
     * @url {ctx}/api/web/rmtj/pageFirstAudit
     * @param page 页码
     * @param size 每页数量
     * @param auditType 1：未审核，2：已审核
     * @param userId 当前登录用户
     * @return Object
     */
    @GetMapping("/pageFirstAudit")
    public Object pageFirstAudit(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                 @RequestParam(value = "auditType") int auditType, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            Map<String, Object> terms = Maps.newHashMap();
            // 初审时间区间
            String firstAuditStart = request.getParameter("firstAuditStart");
            if (StringUtils.isNotBlank(firstAuditStart)){
                terms.put("firstAuditStart", firstAuditStart);
            }
            String firstAuditEnd = request.getParameter("firstAuditEnd");
            if (StringUtils.isNotBlank(firstAuditEnd)){
                terms.put("firstAuditEnd", firstAuditEnd);
            }
            // 提审时间区间
            String applyStart = request.getParameter("applyStart");
            if (StringUtils.isNotBlank(applyStart)){
                terms.put("applyStart", applyStart);
            }
            String applyEnd = request.getParameter("applyEnd");
            if (StringUtils.isNotBlank(applyEnd)){
                terms.put("applyEnd", applyEnd);
            }
            // 转入时间区间
            String rmtjStart = request.getParameter("rmtjStart");
            if (StringUtils.isNotBlank(rmtjStart)){
                terms.put("rmtjStart", rmtjStart);
            }
            String rmtjEnd = request.getParameter("rmtjEnd");
            if (StringUtils.isNotBlank(rmtjEnd)){
                terms.put("rmtjEnd", rmtjEnd);
            }
            // 初审结果
            String firstAuditResult = request.getParameter("firstAuditResult");
            if (StringUtils.isNotBlank(firstAuditResult)){
                terms.put("firstAuditResult", firstAuditResult);
            }
            // 终审结果
            String endAuditResult = request.getParameter("endAuditResult");
            if (StringUtils.isNotBlank(endAuditResult)){
                terms.put("endAuditResult", endAuditResult);
            }
            // 转入结果
            String rmtjStatus = request.getParameter("rmtjStatus");
            if (StringUtils.isNotBlank(rmtjStatus)){
                terms.put("rmtjStatus", rmtjStatus);
            }
            // 转入案号
            String rmtjCaseId = request.getParameter("rmtjCaseId");
            if (StringUtils.isNotBlank(rmtjCaseId)){
                terms.put("rmtjCaseId", rmtjCaseId);
            }
            // 当事人申请人名称，多个用,隔开
            String plaintiffs = request.getParameter("plaintiffs");
            if (StringUtils.isNotBlank(plaintiffs)){
                terms.put("plaintiffs", plaintiffs);
            }
            // 当事人被申请人名称，多个用,隔开
            String defendants = request.getParameter("defendants");
            if (StringUtils.isNotBlank(defendants)){
                terms.put("defendants", defendants);
            }
            // 事项编号
            String caseRef = request.getParameter("caseRef");
            if (StringUtils.isNotBlank(caseRef)){
                terms.put("caseRef", caseRef);
            }
            // 调解组织编号
            String mediateUnitId = request.getParameter("mediateUnitId");
            if (StringUtils.isNotBlank(mediateUnitId)){
                List<String> allUnitIdList = service.listAllChild(mediateUnitId);
                if (CollectionUtils.isNotEmpty(allUnitIdList)){
                    allUnitIdList.add(mediateUnitId);
                    terms.put("mediateUnitIds", allUnitIdList);
                }else {
                    terms.put("mediateUnitId", mediateUnitId);
                }
            }
            // 登记方式
            String inputWay = request.getParameter("inputWay");
            if (StringUtils.isNotBlank(inputWay)){
                terms.put("inputWay", inputWay);
            }
            terms.put("auditType", auditType);
            terms.put("firstAuditUnit", loginUser.getUnitId());
            Sort sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            PageRequest pageRequest = PageRequest.of(page - 1, size, sort);
            Page<RmtjAuditPageDTO> dtoPage = service.pageFirstAudit(pageRequest, terms);
            return ReturnSucUtils.getRepInfo(dtoPage);
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.pageFirstAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-批量申请转入初审
     * @url {ctx}/api/web/rmtj/batchFirstApplyAudit
     * @param rmtjAuditDTO 审核信息对象
     * @param userId 当前登录用户
     * @return Object
     */
    @PostMapping("/batchFirstAudit")
    public Object batchFirstAudit(@RequestBody RmtjAuditDTO rmtjAuditDTO, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.batchFirstAudit(rmtjAuditDTO, loginUser);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.batchFirstAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-审核获取申请信息
     * @url {ctx}/api/web/rmtj/getApplyInfo
     * @param applyId 申请编号
     * @return Object
     */
    @GetMapping("/getApplyInfo")
    public Object getAuditInfo(@RequestParam(value = "applyId") String applyId) {
        try {
            return ReturnSucUtils.getRepInfo(service.getApplyInfo(applyId));
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.getApplyInfo]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-批量移除申请
     * @url {ctx}/api/web/rmtj/batchDeleteApply
     * @param caseIdList 申请案件编号集合
     * @param userId 当前登录用户
     * @return Object
     */
    @PostMapping("/batchDeleteApply")
    public Object batchDeleteApply(@RequestBody List<String> caseIdList, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.batchDeleteApply(caseIdList, loginUser);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.batchDeleteApply]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-终审列表
     * @url {ctx}/api/web/rmtj/pageEndAudit
     * @param page 页码
     * @param size 每页数量
     * @param auditType 1：未审核，2：已审核
     * @param userId 当前登录用户
     * @return Object
     */
    @GetMapping("/pageEndAudit")
    public Object pageEndAudit(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                               @RequestParam(value = "auditType") int auditType, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            Map<String, Object> terms = Maps.newHashMap();
            // 初审时间区间
            String firstAuditStart = request.getParameter("firstAuditStart");
            if (StringUtils.isNotBlank(firstAuditStart)){
                terms.put("firstAuditStart", firstAuditStart);
            }
            String firstAuditEnd = request.getParameter("firstAuditEnd");
            if (StringUtils.isNotBlank(firstAuditEnd)){
                terms.put("firstAuditEnd", firstAuditEnd);
            }
            // 提审时间区间
            String applyStart = request.getParameter("applyStart");
            if (StringUtils.isNotBlank(applyStart)){
                terms.put("applyStart", applyStart);
            }
            String applyEnd = request.getParameter("applyEnd");
            if (StringUtils.isNotBlank(applyEnd)){
                terms.put("applyEnd", applyEnd);
            }
            // 转入时间区间
            String rmtjStart = request.getParameter("rmtjStart");
            if (StringUtils.isNotBlank(rmtjStart)){
                terms.put("rmtjStart", rmtjStart);
            }
            String rmtjEnd = request.getParameter("rmtjEnd");
            if (StringUtils.isNotBlank(rmtjEnd)){
                terms.put("rmtjEnd", rmtjEnd);
            }
            // 初审结果
            String firstAuditResult = request.getParameter("firstAuditResult");
            if (StringUtils.isNotBlank(firstAuditResult)){
                terms.put("firstAuditResult", firstAuditResult);
            }
            // 终审结果
            String endAuditResult = request.getParameter("endAuditResult");
            if (StringUtils.isNotBlank(endAuditResult)){
                terms.put("endAuditResult", endAuditResult);
            }
            // 转入结果
            String rmtjStatus = request.getParameter("rmtjStatus");
            if (StringUtils.isNotBlank(rmtjStatus)){
                terms.put("rmtjStatus", rmtjStatus);
            }
            // 转入案号
            String rmtjCaseId = request.getParameter("rmtjCaseId");
            if (StringUtils.isNotBlank(rmtjCaseId)){
                terms.put("rmtjCaseId", rmtjCaseId);
            }
            // 当事人申请人名称，多个用,隔开
            String plaintiffs = request.getParameter("plaintiffs");
            if (StringUtils.isNotBlank(plaintiffs)){
                terms.put("plaintiffs", plaintiffs);
            }
            // 当事人被申请人名称，多个用,隔开
            String defendants = request.getParameter("defendants");
            if (StringUtils.isNotBlank(defendants)){
                terms.put("defendants", defendants);
            }
            // 事项编号
            String caseRef = request.getParameter("caseRef");
            if (StringUtils.isNotBlank(caseRef)){
                terms.put("caseRef", caseRef);
            }
            // 调解组织编号
            String mediateUnitId = request.getParameter("mediateUnitId");
            if (StringUtils.isNotBlank(mediateUnitId)){
                List<String> allUnitIdList = service.listAllChild(mediateUnitId);
                if (CollectionUtils.isNotEmpty(allUnitIdList)){
                    terms.put("mediateUnitIds", allUnitIdList);
                }else {
                    terms.put("mediateUnitId", mediateUnitId);
                }
            }
            // 登记方式
            String inputWay = request.getParameter("inputWay");
            if (StringUtils.isNotBlank(inputWay)){
                terms.put("inputWay", inputWay);
            }
            terms.put("auditType", auditType);
            terms.put("endAuditUnit", loginUser.getUnitId());
            Sort sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            PageRequest pageRequest = PageRequest.of(page - 1, size, sort);
            Page<RmtjAuditPageDTO> dtoPage = service.pageEndAudit(pageRequest, terms);
            return ReturnSucUtils.getRepInfo(dtoPage);
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.pageEndAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-批量申请转入终审
     * @url {ctx}/api/web/rmtj/batchEndAudit
     * @param rmtjAuditDTO 审核信息对象
     * @param userId 当前登录用户
     * @return Object
     */
    @PostMapping("/batchEndAudit")
    public Object batchEndAudit(@RequestBody RmtjAuditDTO rmtjAuditDTO, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.batchEndAudit(rmtjAuditDTO, loginUser);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.batchEndAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * web端-转入人民调解系统-批量重转入人民调解系统
     * @url {ctx}/api/web/rmtj/batchReSendRmtj
     * @param applyIdList 申请编号集合
     * @param userId 当前登录用户
     * @return Object
     */
    @PostMapping("/batchReSendRmtj")
    public Object batchReSendRmtj(@RequestBody List<String> applyIdList, @CurrentUser String userId) {
        try {
            // 获取当前登录用户
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.batchReSendRmtj(applyIdList, loginUser);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[ThRmtjController.batchReSendRmtj]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo();
        }
    }

}