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

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.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.cust.constant.RoleBaseEnum;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.judic.domain.dto.*;
import cn.huge.module.judic.service.JudicInfoService;
import cn.huge.module.mediate.constant.*;
import cn.huge.module.meet.domain.dto.WindowInMeetInfo;
import cn.huge.module.notice.domain.po.NoticeMode;
import cn.huge.module.sys.constant.FlowNodeBaseEnum;
import cn.huge.module.sys.dto.FileTypeInfoBaseDTO;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
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.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @title: 司法确认信息表接口api
 * @description: 司法确认信息表接口api
 * @company: hugeinfo
 * @author: liyj
 * @time: 2022-04-18 10:40:03
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/judicInfo")
public class JudicInfoWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private JudicInfoService service;
    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private SysClientImpl sysClient;


    /**
     * 获取请求URL参数
     * @return Map<String, Object>
     */
    private Map<String, Object> getCaseParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 案号
        String caseNo = request.getParameter("caseNo");
        if (StringUtils.isNotBlank(caseNo)){
            terms.put("caseNo", caseNo);
        }

        String judicNo = request.getParameter("judicNo");
        if (StringUtils.isNotBlank(judicNo)){
            terms.put("judicNo", judicNo);
        }

        String caseRef = request.getParameter("caseRef");
        if (StringUtils.isNotBlank(caseRef)){
            terms.put("caseRef", caseRef);
        }

        String caseType = request.getParameter("caseType");
        if (StringUtils.isNotBlank(caseType)){
            terms.put("caseType", caseType);
        }
        // 案号
        String judicApply = request.getParameter("judicApply");
        if (StringUtils.isNotBlank(judicApply)){
            terms.put("judicApply", judicApply);
        }

        String judicAudit = request.getParameter("judicAudit");
        if (StringUtils.isNotBlank(judicAudit)){
            terms.put("judicAudit", judicAudit);
        }
        // 纠纷发生地详细地址
        String addr = request.getParameter("addr");
        if (StringUtils.isNotBlank(addr)){
            terms.put("addr", addr);
        }
        // 实际调解组织编号
        String mediateUnitId = request.getParameter("mediateUnitId");
        if (StringUtils.isNotBlank(mediateUnitId)){
            terms.put("mediateUnitId", mediateUnitId);
        }
        // 当事人申请人名称，多个用,隔开
        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 mediateUserName = request.getParameter("mediateUserName");
        if (StringUtils.isNotBlank(mediateUserName)){
            terms.put("mediateUserName", mediateUserName);
        }
        // 调解员
        String status = request.getParameter("status");
        if (StringUtils.isNotBlank(status)){
            terms.put("status", status);
        }

        String judicResult = request.getParameter("judicResult");
        if (StringUtils.isNotBlank(judicResult)){
            terms.put("judicResult", judicResult);
        }
        // 调解结束时间区间
        String mediEndStart = request.getParameter("mediEndStart");
        String mediEndEnd = request.getParameter("mediEndEnd");
        if(StringUtils.isNotBlank(mediEndStart) && StringUtils.isNotBlank(mediEndEnd)) {
            terms.put("mediEndStart", mediEndStart);
            terms.put("mediEndEnd", mediEndEnd);
        }

        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 fileStart = request.getParameter("fileStart");
        String fileEnd = request.getParameter("fileEnd");
        if (StringUtils.isNotBlank(fileStart) && StringUtils.isNotBlank(fileEnd)) {
            terms.put("createStart", fileStart);
            terms.put("createEnd", fileEnd);
        }

        // 申请时间
        String applyStart = request.getParameter("applyStart");
        String applyEnd = request.getParameter("applyEnd");
        if(StringUtils.isNotBlank(applyStart) && StringUtils.isNotBlank(applyEnd)) {
            terms.put("applyStart", applyStart);
            terms.put("applyEnd", applyEnd);
        }

        // 审核时间
        String auditStart = request.getParameter("auditStart");
        String auditEnd = request.getParameter("auditEnd");
        if(StringUtils.isNotBlank(auditStart) && StringUtils.isNotBlank(auditEnd)) {
            terms.put("auditStart", auditStart);
            terms.put("auditEnd", auditEnd);
        }

        String judicEndStart = request.getParameter("judicEndStart");
        String judicEndEnd = request.getParameter("judicEndEnd");
        if (StringUtils.isNotBlank(judicEndStart) && StringUtils.isNotBlank(judicEndEnd)) {
            terms.put("judicEndStart", judicEndStart);
            terms.put("judicEndEnd", judicEndEnd);
        }
        return terms;
    }

    /**
     * pc端司法确认-调解组织申请-查询平台内调解成功案件
     * @url {ctx}/api/web/judicInfo/pageSuccessCase
     * @param page 页码
     * @param size 每页数量
     * @return Object
     */
    @GetMapping("/pageSuccessCase")
    public Object pageSuccessCase(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                  @CurrentUser String userId) {
        try {
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            Map<String, Object> terms = getCaseParameter();
            terms.put("belongUnitId", loginUser.getUnitId());
            terms.put("mediResult", MediResultBaseConstsEnum.MEDI_RESULT_1.getIndex());
            Sort sort = null;
            String sortName = null;
            String sortColmnStr = request.getParameter("sortColmn");
            String sortTypeStr = request.getParameter("sortType");
            int sortColmn = 1;
            int sortType = 1;
            if (StringUtils.isNotBlank(sortColmnStr)) {
                sortColmn = Integer.valueOf(sortColmnStr);
            }
            if (StringUtils.isNotBlank(sortTypeStr)) {
                sortType = Integer.valueOf(sortTypeStr);
            }
            switch (sortColmn) {
                case 1:
                    sortName = "j.apply_time";
                    break;
                case 2:
                    sortName = "b.close_time";
                    break;
            }
            switch (sortType) {
                case 1:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
            }
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            return ReturnSucUtils.getRepInfo(service.pageSuccessCase(pageRequest, terms));
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.pageUnitApply]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-调解组织申请-平台内调解成功案件申请材料
     * @url {ctx}/api/web/judicInfo/getCaseApplyFile
     * @param caseId 纠纷编号
     * @return Object
     */
    @GetMapping("/getCaseApplyFile")
    public Object getCaseApplyFile(@RequestParam(value = "caseId") String caseId) {
        try {
            List<FileTypeInfoBaseDTO> fileTypeInfoBaseDTOList = service.listApplyFIle(caseId);
            return ReturnSucUtils.getRepInfo(fileTypeInfoBaseDTOList);
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.getCaseApplyFile]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-调解组织申请-提交/退回修改司法确认申请
     * @url {ctx}/api/web/judicInfo/unitApplyJudic
     * @param unitApplySaveDTO 司法确认申请对象
     * @return Object
     */
    @PostMapping("/unitApplyJudic")
    public Object unitApplyJudic(@CurrentUser String userId, @RequestBody UnitApplySaveDTO unitApplySaveDTO) {
        try {
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.unitApplyJudic(loginUser, unitApplySaveDTO);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.getCaseApplyFile]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-法院审查-司法确认申请审查列表
     * @url {ctx}/api/web/judicInfo/pageCourtAudit
     * @param page 页码
     * @param size 每页数量
     * @return Object
     *
     */
    @GetMapping("/pageCourtAudit")
    public Object pageCourtAudit(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                 @CurrentUser String userId) {
        try {
            Map<String, Object> terms = getCaseParameter();

            Sort sort = null;
            String sortName = null;
            String sortColmnStr = request.getParameter("sortColmn");
            String sortTypeStr = request.getParameter("sortType");
            int sortColmn = 1;
            int sortType = 1;
            if (StringUtils.isNotBlank(sortColmnStr)) {
                sortColmn = Integer.valueOf(sortColmnStr);
            }
            if (StringUtils.isNotBlank(sortTypeStr)) {
                sortType = Integer.valueOf(sortTypeStr);
            }
            switch (sortColmn) {
                case 1:
                    sortName = "t1.apply_time";
                    break;
                case 2:
                    sortName = "t1.audit_time";
                    break;
            }
            switch (sortType) {
                case 1:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
            }
            if (ObjectUtils.isEmpty(sort)) {
                sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            }

            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            return ReturnSucUtils.getRepInfo(service.pageCourtAudit(pageRequest, terms, userId));
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.pageCourtAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-查询申请信息详情
     * @url {ctx}/api/web/judicInfo/getJudicInfo
     * @param judicId 司法确认编号
     * @return Object
     */
    @GetMapping("/getJudicInfo")
    public Object getJudicInfo(@RequestParam(value = "judicId") String judicId) {
        try {
            JudicInfoDTO judicInfoDTO = service.getJudicInfo(judicId);
            return ReturnSucUtils.getRepInfo(judicInfoDTO);
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.getJudicInfo]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-查询申请信息详情
     * @url {ctx}/api/web/judicInfo/getJudicCaseInfo
     * @param caseId 司法确认编号
     * @return Object
     */
    @GetMapping("/getJudicCaseInfo")
    public Object getJudicCaseInfo(@RequestParam(value = "caseId") String caseId) {
        try {
            JudicInfoDTO judicInfoDTO = service.getJudicCaseInfo(caseId);
            return ReturnSucUtils.getRepInfo(judicInfoDTO);
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.getJudicCaseInfo]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }


    /**
     * pc端司法确认-法院审核
     * @url {ctx}/api/web/judicInfo/courtAudit
     * @param courtAuditDTO 司法确认审核对象
     * @return Object
     */
    @PostMapping("/courtAudit")
    public Object courtAudit(@CurrentUser String userId, @RequestBody CourtAuditDTO courtAuditDTO) {
        try {
            CtUserDTO loginUser = custClient.clientGetUserAll(userId);
            service.courtAudit(loginUser, courtAuditDTO);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.courtAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }


    /**
     * pc端司法确认-法院确认列表
     * @url {ctx}/api/web/judicInfo/pageCourtConfirm
     * @param page 页码
     * @param size 每页数量
     * @return Object
     */
    @GetMapping("/pageCourtConfirm")
    public Object pageCourtConfirm(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size,
                                 @CurrentUser String userId) {
        try {
            Map<String, Object> terms = getCaseParameter();
            String status = request.getParameter("status");
            if("0".equals(status)){
                List<String> processList = new ArrayList<>();
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_1.getIndex());
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_2.getIndex());
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_3.getIndex());
                terms.put("processList", processList);
                terms.remove("status");
            }else if("1".equals(status)){
                List<String> processList = new ArrayList<>();
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_4.getIndex());
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_5.getIndex());
                processList.add(JudicBaseConstsEnum.JUDIC_PROCESS_6.getIndex());
                terms.put("processList", processList);
                terms.remove("status");
            }
            Sort sort = null;
            String sortName = null;
            String sortColmnStr = request.getParameter("sortColmn");
            String sortTypeStr = request.getParameter("sortType");
            int sortColmn = 1;
            int sortType = 1;
            if (StringUtils.isNotBlank(sortColmnStr)) {
                sortColmn = Integer.valueOf(sortColmnStr);
            }
            if (StringUtils.isNotBlank(sortTypeStr)) {
                sortType = Integer.valueOf(sortTypeStr);
            }
            switch (sortColmn) {
                case 1:
                    sortName = "t1.apply_time";
                    break;
                case 2:
                    sortName = "t1.judic_end_time";
                    break;
                case 3:
                    sortName = "wait_hours";
                    break;
            }
            switch (sortType) {
                case 1:
                    sort = Sort.by(Sort.Direction.ASC, sortName);
                    break;
                case 2:
                    sort = Sort.by(Sort.Direction.DESC, sortName);
                    break;
            }
            if (ObjectUtils.isEmpty(sort)) {
                sort = Sort.by(Sort.Direction.DESC, "t1.create_time");
            }
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            return ReturnSucUtils.getRepInfo(service.pageCourtConfirm(pageRequest, terms, userId));
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.pageCourtConfirm]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-办结提交
     * @url {ctx}/api/web/judicInfo/judicConfirm
     * @param courtAuditDTO 司法确认审核对象
     * @return Object
     */
    @PostMapping("/judicConfirm")
    public Object judicConfirm(@CurrentUser String userId, @RequestBody CourtAuditDTO courtAuditDTO) {
        try {
            service.judicConfirm(courtAuditDTO);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.courtAudit]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

    /**
     * pc端司法确认-重新申请复制原来的申请单
     * @url {ctx}/api/web/judicInfo/copyJudic
     * @param caseId 司法确认编号
     * @return Object
     */
    @GetMapping("/copyJudic")
    public Object copyJudic(@RequestParam(value = "caseId") String caseId) {
        try {
            JudicInfoDTO judicInfoDTO = service.copyJudic(caseId);
            return ReturnSucUtils.getRepInfo(judicInfoDTO);
        } catch (Exception e) {
            log.error("Controller接口[JudicInfoController.copyJudic]请求异常："+e, e);
            return ReturnFailUtils.getRepInfo(e.getMessage(), null);
        }
    }

}