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

import cn.huge.base.common.utils.ReturnFailUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.base.config.CurrentCust;
import cn.huge.base.config.CurrentUser;
import cn.huge.module.cases.domain.po.CaseInfoUnfold;
import cn.huge.module.cases.service.CaseInfoUnfoldService;
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.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: 纠纷信息扩展表接口api-web端
 * @description: 纠纷信息扩展表接口api-web端
 * @company: hugeinfo
 * @author: liyj
 * @time: 2024-09-09 19:58:25
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/caseInfoUnfold")
public class CaseInfoUnfoldWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private CaseInfoUnfoldService service;

    /**
    * 获取请求URL参数
    * @return Map<String, Object>
    */
    private Map<String, Object> getParameter(){
        Map<String, Object> terms = Maps.newHashMap();
        // 纠纷编号
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)){
            terms.put("id", id);
        }
        // 受理时间
        String acceptTime = request.getParameter("acceptTime");
        if (StringUtils.isNotBlank(acceptTime)){
            terms.put("acceptTime", acceptTime);
        }
        // 实际调解组织编号
        String mediateUnitId = request.getParameter("mediateUnitId");
        if (StringUtils.isNotBlank(mediateUnitId)){
            terms.put("mediateUnitId", mediateUnitId);
        }
        // 实际调解组织名称
        String mediateUnitName = request.getParameter("mediateUnitName");
        if (StringUtils.isNotBlank(mediateUnitName)){
            terms.put("mediateUnitName", mediateUnitName);
        }
        // 实际调解部门编号
        String mediateDeptId = request.getParameter("mediateDeptId");
        if (StringUtils.isNotBlank(mediateDeptId)){
            terms.put("mediateDeptId", mediateDeptId);
        }
        // 实际调解部门名称
        String mediateDeptName = request.getParameter("mediateDeptName");
        if (StringUtils.isNotBlank(mediateDeptName)){
            terms.put("mediateDeptName", mediateDeptName);
        }
        // 实际调解员编号
        String mediatorId = request.getParameter("mediatorId");
        if (StringUtils.isNotBlank(mediatorId)){
            terms.put("mediatorId", mediatorId);
        }
        // 实际调解员
        String mediator = request.getParameter("mediator");
        if (StringUtils.isNotBlank(mediator)){
            terms.put("mediator", mediator);
        }
        // 实际调解员手机号码
        String mediatorMobile = request.getParameter("mediatorMobile");
        if (StringUtils.isNotBlank(mediatorMobile)){
            terms.put("mediatorMobile", mediatorMobile);
        }
        // 配合组织，多个用,隔开
        String assistUnitId = request.getParameter("assistUnitId");
        if (StringUtils.isNotBlank(assistUnitId)){
            terms.put("assistUnitId", assistUnitId);
        }
        // 配合组织名称，多个用、隔开
        String assistUnitName = request.getParameter("assistUnitName");
        if (StringUtils.isNotBlank(assistUnitName)){
            terms.put("assistUnitName", assistUnitName);
        }
        // 调解开始时间
        String mediStartTime = request.getParameter("mediStartTime");
        if (StringUtils.isNotBlank(mediStartTime)){
            terms.put("mediStartTime", mediStartTime);
        }
        // 调解结束时间
        String mediEndTime = request.getParameter("mediEndTime");
        if (StringUtils.isNotBlank(mediEndTime)){
            terms.put("mediEndTime", mediEndTime);
        }
        // 调解结果
        String mediResult = request.getParameter("mediResult");
        if (StringUtils.isNotBlank(mediResult)){
            terms.put("mediResult", mediResult);
        }
        // 调解结果名称
        String mediResultName = request.getParameter("mediResultName");
        if (StringUtils.isNotBlank(mediResultName)){
            terms.put("mediResultName", mediResultName);
        }
        // 达成协议类型
        String agreeType = request.getParameter("agreeType");
        if (StringUtils.isNotBlank(agreeType)){
            terms.put("agreeType", agreeType);
        }
        // 达成协议类型名称
        String agreeTypeName = request.getParameter("agreeTypeName");
        if (StringUtils.isNotBlank(agreeTypeName)){
            terms.put("agreeTypeName", agreeTypeName);
        }
        // 已达成协议
        String agreeContent = request.getParameter("agreeContent");
        if (StringUtils.isNotBlank(agreeContent)){
            terms.put("agreeContent", agreeContent);
        }
        // 结案意见
        String windupContent = request.getParameter("windupContent");
        if (StringUtils.isNotBlank(windupContent)){
            terms.put("windupContent", windupContent);
        }
        // 调解不成功原因
        String mediFalse = request.getParameter("mediFalse");
        if (StringUtils.isNotBlank(mediFalse)){
            terms.put("mediFalse", mediFalse);
        }
        // 调解不成功原因名称
        String mediFalseName = request.getParameter("mediFalseName");
        if (StringUtils.isNotBlank(mediFalseName)){
            terms.put("mediFalseName", mediFalseName);
        }
        // 是否转诉讼案件，0：不转诉讼，1：转诉讼
        String civilStatus = request.getParameter("civilStatus");
        if (StringUtils.isNotBlank(civilStatus)){
            terms.put("civilStatus", civilStatus);
        }
        // 诉讼法院编号
        String courtId = request.getParameter("courtId");
        if (StringUtils.isNotBlank(courtId)){
            terms.put("courtId", courtId);
        }
        // 诉讼法院名称
        String courtName = request.getParameter("courtName");
        if (StringUtils.isNotBlank(courtName)){
            terms.put("courtName", courtName);
        }
        // 办结时间
        String closeTime = request.getParameter("closeTime");
        if (StringUtils.isNotBlank(closeTime)){
            terms.put("closeTime", closeTime);
        }
        // 是否申请司法确认，0：未申请，1：已申请
        String judicApply = request.getParameter("judicApply");
        if (StringUtils.isNotBlank(judicApply)){
            terms.put("judicApply", judicApply);
        }
        // 司法确认结果
        String judicResult = request.getParameter("judicResult");
        if (StringUtils.isNotBlank(judicResult)){
            terms.put("judicResult", judicResult);
        }
        // 司法确认结果名称
        String judicResultName = request.getParameter("judicResultName");
        if (StringUtils.isNotBlank(judicResultName)){
            terms.put("judicResultName", judicResultName);
        }
        // 是否已归档，0：未归档，1：已归档
        String fileStatus = request.getParameter("fileStatus");
        if (StringUtils.isNotBlank(fileStatus)){
            terms.put("fileStatus", fileStatus);
        }
        // 归档人编号
        String fileUserId = request.getParameter("fileUserId");
        if (StringUtils.isNotBlank(fileUserId)){
            terms.put("fileUserId", fileUserId);
        }
        // 归档人名称
        String fileUserName = request.getParameter("fileUserName");
        if (StringUtils.isNotBlank(fileUserName)){
            terms.put("fileUserName", fileUserName);
        }
        // 归档时间
        String fileTime = request.getParameter("fileTime");
        if (StringUtils.isNotBlank(fileTime)){
            terms.put("fileTime", fileTime);
        }
        // 档案年度
        String fileYear = request.getParameter("fileYear");
        if (StringUtils.isNotBlank(fileYear)){
            terms.put("fileYear", fileYear);
        }
        // 档案卷名
        String fileBookName = request.getParameter("fileBookName");
        if (StringUtils.isNotBlank(fileBookName)){
            terms.put("fileBookName", fileBookName);
        }
        // 档案卷号
        String fileBookNo = request.getParameter("fileBookNo");
        if (StringUtils.isNotBlank(fileBookNo)){
            terms.put("fileBookNo", fileBookNo);
        }
        // 档案编号
        String fileNo = request.getParameter("fileNo");
        if (StringUtils.isNotBlank(fileNo)){
            terms.put("fileNo", fileNo);
        }
        // 档案保管年限，单位：年
        String fileLimitYear = request.getParameter("fileLimitYear");
        if (StringUtils.isNotBlank(fileLimitYear)){
            terms.put("fileLimitYear", fileLimitYear);
        }
        // 档案存档位置
        String fileAddr = request.getParameter("fileAddr");
        if (StringUtils.isNotBlank(fileAddr)){
            terms.put("fileAddr", fileAddr);
        }
        // 卷宗情况说明
        String fileContent = request.getParameter("fileContent");
        if (StringUtils.isNotBlank(fileContent)){
            terms.put("fileContent", fileContent);
        }
        // 履行情况
        String fulfilSitu = request.getParameter("fulfilSitu");
        if (StringUtils.isNotBlank(fulfilSitu)){
            terms.put("fulfilSitu", fulfilSitu);
        }
        // 履行情况名称
        String fulfilSituName = request.getParameter("fulfilSituName");
        if (StringUtils.isNotBlank(fulfilSituName)){
            terms.put("fulfilSituName", fulfilSituName);
        }
        // 是否已回访，0：未回访，1：已回访
        String visitUpStatus = request.getParameter("visitUpStatus");
        if (StringUtils.isNotBlank(visitUpStatus)){
            terms.put("visitUpStatus", visitUpStatus);
        }
        // 回访情况
        String visitUpContent = request.getParameter("visitUpContent");
        if (StringUtils.isNotBlank(visitUpContent)){
            terms.put("visitUpContent", visitUpContent);
        }
        // 当事人是否满意，0：不满意，1：满意
        String partyJoy = request.getParameter("partyJoy");
        if (StringUtils.isNotBlank(partyJoy)){
            terms.put("partyJoy", partyJoy);
        }
        // 顾客编号
        String custId = request.getParameter("custId");
        if (StringUtils.isNotBlank(custId)){
            terms.put("custId", custId);
        }
        // 创建时间区间
        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 updateStart = request.getParameter("updateStart");
        String updateEnd = request.getParameter("updateEnd");
        if(StringUtils.isNotBlank(updateStart) && StringUtils.isNotBlank(updateEnd)) {
            terms.put("updateStart", updateStart);
            terms.put("updateEnd", updateEnd);
        }
        // 网格非警情线索办案人、组织
        String gridHandle = request.getParameter("gridHandle");
        if (StringUtils.isNotBlank(gridHandle)){
            terms.put("gridHandle", gridHandle);
        }
        return terms;
    }

    /**
    * 条件查询多个
    * @url {ctx}/api/web/caseInfoUnfold/listQuery
    * @return Object
    */
    @GetMapping("/listQuery")
    public Object listQuery() {
        try {
            Map<String, Object> terms = getParameter();
            return ReturnSucUtils.getRepInfo(service.listTerms(terms));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 条件分页查询
    * @url {ctx}/api/web/caseInfoUnfold/pageQuery
    * @param page 页码
    * @param size 每页数量
    * @return Object
    */
    @GetMapping("/pageQuery")
    public Object pageQuery(@RequestParam(value = "page") int page, @RequestParam(value = "size") int size) {
        try {
            Map<String, Object> terms = getParameter();
            Sort sort = Sort.by(Sort.Direction.DESC, "create_time");
            PageRequest pageRequest = PageRequest.of(page-1, size, sort);
            Page<CaseInfoUnfold> caseInfoUnfoldPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo( "处理成功", caseInfoUnfoldPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据编号查询单个
    * @url {ctx}/api/web/caseInfoUnfold/getById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/getById")
    public Object getById(@RequestParam(value = "id") String id) {
        try {
            return ReturnSucUtils.getRepInfo(service.getById(id));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 根据主键单个
    * @url {ctx}/api/web/caseInfoUnfold/deleteById
    * @param id 主键编号
    * @return Object
    */
    @GetMapping("/deleteById")
    public Object deleteById(@RequestParam(value = "id") String id) {
        try {
            service.removeById(id);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
    * 新增或更新对象
    * @url {ctx}/api/web/caseInfoUnfold/saveCaseInfoUnfold
    * @param caseInfoUnfold 实体对象
    * @return Object
    */
    @PostMapping("/saveCaseInfoUnfold")
    public Object saveCaseInfoUnfold(@RequestBody CaseInfoUnfold caseInfoUnfold) {
        try {
            service.saveCaseInfoUnfold(caseInfoUnfold);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 查询办理结果
     * @url {ctx}/api/web/caseInfoUnfold/getTransactResult
     * @param caseId 事项ID
     * @return Object
     */
    @GetMapping("/getTransactResult")
    public Object getTransactResult(@RequestParam(value = "caseId") String caseId) {
        try {
            return ReturnSucUtils.getRepInfo(service.getTransactResult(caseId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * PC端-选择经办人
     * @url {ctx}/api/web/caseInfoUnfold/choosePrincipal?
     * @param caseId 纠纷编号
     * @return Object
     */
    @GetMapping("/choosePrincipal")
    public Object choosePrincipal(@RequestParam(value = "caseId") String caseId, @RequestParam(value = "caseTaskId") String caseTaskId,
                                  @RequestParam(value = "userId") String userId) {
        try {
            service.choosePrincipal(caseId, caseTaskId, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * PC端-删除经办人
     * @url {ctx}/api/web/caseInfoUnfold/deletePrincipal?
     * @param caseId 纠纷编号
     * @return Object
     */
    @GetMapping("/deletePrincipal")
    public Object deletePrincipal(@RequestParam(value = "caseId") String caseId, @CurrentUser String userId) {
        try {
            service.deletePrincipal(caseId, userId);
            return ReturnSucUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo(e.getMessage());
        }
    }

    /**
     * 联合处置申请-查询组织
     * @url {ctx}/api/web/caseInfoUnfold/superviceUnitChoose
     * @param caseId 事项ID
     * @return Object
     */
    @GetMapping("/superviceUnitChoose")
    public Object superviceUnitChoose(@RequestParam(value = "caseId") String caseId) {
        try {
            return ReturnSucUtils.getRepInfo(service.superviceUnitChoose(caseId));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 联合处置申请-批量查询组织
     * @url {ctx}/api/web/caseInfoUnfold/superviceUnitBatchChoose
     * @param caseIdList 事项ID
     * @return Object
     */
    @PostMapping("/superviceUnitBatchChoose")
    public Object superviceUnitBatchChoose(@RequestBody List<String> caseIdList) {
        try {
            return ReturnSucUtils.getRepInfo(service.superviceUnitBatchChoose(caseIdList));
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }
}