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

import cn.huge.base.common.bo.R;
import cn.huge.base.common.utils.*;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.file.service.FileInfoService;
import cn.huge.module.file.utils.FtpUtils;
import cn.huge.module.grid.domain.dto.GridFileUploadDTO;
import cn.huge.module.grid.domain.po.GridEvent;
import cn.huge.module.grid.domain.po.GridEventRequest;
import cn.huge.module.grid.domain.vo.*;
import cn.huge.module.grid.service.*;
import cn.huge.module.sys.constant.GridEnum;
import cn.huge.module.sys.dto.FileInfoBaseDTO;
import cn.huge.module.sys.vo.GridOrgUsersVo;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
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.io.File;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @title: dyh_th_grid_event接口api-web端
 * @description: dyh_th_grid_event接口api-web端
 * @company: hugeinfo
 * @author: wangwh
 * @time: 2025-02-21 17:42:19
 * @version: 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/web/gridEvent")
public class GridEventWebController {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Autowired
    private GridEventService service;

    @Autowired
    private FileInfoService fileInfoService;

    @Autowired
    private GridCaseDataService gridCaseDataService;

    @Autowired
    private GridCaseTaskService gridCaseTaskService;

    @Autowired
    private GridEventRequestService gridEventRequestService;

    @Autowired
    private GridUserService gridUserService;

    @Autowired
    private CustClientImpl custClient;

    /**
     * 获取请求URL参数
     *
     * @return Map<String, Object>
     */
    private Map<String, Object> getParameter() {
        Map<String, Object> terms = Maps.newHashMap();
        // id
        String id = request.getParameter("id");
        if (StringUtils.isNotBlank(id)) {
            terms.put("id", id);
        }
        // event_code
        String eventCode = request.getParameter("eventCode");
        if (StringUtils.isNotBlank(eventCode)) {
            terms.put("eventCode", eventCode);
        }
        // title
        String title = request.getParameter("title");
        if (StringUtils.isNotBlank(title)) {
            terms.put("title", title);
        }
        // entry_item_name
        String entryItemName = request.getParameter("entryItemName");
        if (StringUtils.isNotBlank(entryItemName)) {
            terms.put("entryItemName", entryItemName);
        }
        // event_time
        String eventTime = request.getParameter("eventTime");
        if (StringUtils.isNotBlank(eventTime)) {
            terms.put("eventTime", eventTime);
        }
        // sys_org_id
        String sysOrgId = request.getParameter("sysOrgId");
        if (StringUtils.isNotBlank(sysOrgId)) {
            terms.put("sysOrgId", sysOrgId);
        }
        // sys_org_name
        String sysOrgName = request.getParameter("sysOrgName");
        if (StringUtils.isNotBlank(sysOrgName)) {
            terms.put("sysOrgName", sysOrgName);
        }
        // eventX
        String eventx = request.getParameter("eventx");
        if (StringUtils.isNotBlank(eventx)) {
            terms.put("eventx", eventx);
        }
        // eventY
        String eventy = request.getParameter("eventy");
        if (StringUtils.isNotBlank(eventy)) {
            terms.put("eventy", eventy);
        }
        // address
        String address = request.getParameter("address");
        if (StringUtils.isNotBlank(address)) {
            terms.put("address", address);
        }
        // handle_time
        String handleTime = request.getParameter("handleTime");
        if (StringUtils.isNotBlank(handleTime)) {
            terms.put("handleTime", handleTime);
        }
        // delay_count
        String delayCount = request.getParameter("delayCount");
        if (StringUtils.isNotBlank(delayCount)) {
            terms.put("delayCount", delayCount);
        }
        // now_work_date
        String nowWorkDate = request.getParameter("nowWorkDate");
        if (StringUtils.isNotBlank(nowWorkDate)) {
            terms.put("nowWorkDate", nowWorkDate);
        }
        // yj_flag
        String yjFlag = request.getParameter("yjFlag");
        if (StringUtils.isNotBlank(yjFlag)) {
            terms.put("yjFlag", yjFlag);
        }
        // processing_time
        String processingTime = request.getParameter("processingTime");
        if (StringUtils.isNotBlank(processingTime)) {
            terms.put("processingTime", processingTime);
        }
        // info_source
        String infoSource = request.getParameter("infoSource");
        if (StringUtils.isNotBlank(infoSource)) {
            terms.put("infoSource", infoSource);
        }
        // cur_node_custom_tag
        String curNodeCustomTag = request.getParameter("curNodeCustomTag");
        if (StringUtils.isNotBlank(curNodeCustomTag)) {
            terms.put("curNodeCustomTag", curNodeCustomTag);
        }
        // event_area
        String eventArea = request.getParameter("eventArea");
        if (StringUtils.isNotBlank(eventArea)) {
            terms.put("eventArea", eventArea);
        }
        // select_handle_org_name
        String selectHandleOrgName = request.getParameter("selectHandleOrgName");
        if (StringUtils.isNotBlank(selectHandleOrgName)) {
            terms.put("selectHandleOrgName", selectHandleOrgName);
        }
        // status
        String status = request.getParameter("status");
        if (StringUtils.isNotBlank(status)) {
            terms.put("status", status);
        }
        // grid_code
        String gridCode = request.getParameter("gridCode");
        if (StringUtils.isNotBlank(gridCode)) {
            terms.put("gridCode", gridCode);
        }
        // entry_item_code
        String entryItemCode = request.getParameter("entryItemCode");
        if (StringUtils.isNotBlank(entryItemCode)) {
            terms.put("entryItemCode", entryItemCode);
        }
        // case_id
        String caseId = request.getParameter("caseId");
        if (StringUtils.isNotBlank(caseId)) {
            terms.put("caseId", caseId);
        }
        // 创建时间区间
        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);
        }
        return terms;
    }

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

    /**
     * 条件分页查询
     *
     * @param page 页码
     * @param size 每页数量
     * @return Object
     * @url {ctx}/api/web/gridEvent/pageQuery
     */
    @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<GridEvent> gridEventPage = service.pageQuery(pageRequest, terms);
            return ReturnSucUtils.getRepInfo("处理成功", gridEventPage);
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

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

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

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

    /**
     * 根据编号查询单个
     *
     * @param caseId 案件编号
     * @return Object
     * @url {ctx}/api/web/gridEvent/getGridEventId
     */
    @GetMapping("/getGridEventId")
    public Object getGridEventId(@RequestParam(value = "caseId") String caseId) {
        try {
            QueryWrapper<GridEvent> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("case_id", caseId);
            GridEvent gridEvent = service.getOne(queryWrapper);
            if (ObjectUtils.isNotEmpty(gridEvent)) {
                return ReturnSucUtils.getRepInfo(gridEvent);
            }
            return ReturnFailUtils.getRepInfo();
        } catch (Exception e) {
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 根据编号查询单个
     *
     * @param gridApprovalRecordVo
     * @return Object
     * @url {ctx}/api/web/gridEvent/updateCaseEvent
     */
    @PostMapping("/updateCaseEvent")
    public Object updateCaseEvent(@RequestBody GridApprovalRecordVo gridApprovalRecordVo) {
        GridEventRequest gridEventRequest = new GridEventRequest();
        gridEventRequest.setEventStatus(gridApprovalRecordVo.getHandleName());
        //添加请求记录
        gridEventRequest.setId(IdUtils.getNewTimeId());
        gridEventRequest.setEventId(gridApprovalRecordVo.getEventId());
        gridEventRequest.setCaseId(gridApprovalRecordVo.getCaseId());
        gridEventRequest.setCreateTime(DateUtils.getNowDate());
        QueryWrapper<GridEvent> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("case_id", gridApprovalRecordVo.getCaseId());
        GridEvent gridEvent = service.getOne(queryWrapper);
        try {
            //查询网格组织编号
            String appGridUnitId = null;
            if (StringUtils.isNotBlank(gridApprovalRecordVo.getAppOrgId())) {
                appGridUnitId = gridCaseTaskService.getGridUnitIdByUnitId(gridApprovalRecordVo.getAppOrgId());
                gridApprovalRecordVo.setAppOrgId(appGridUnitId);
                if (StringUtils.isBlank(appGridUnitId)) {
                    throw new Exception("当前环节处理网格组织不存在");
                }
            } else {
                gridApprovalRecordVo.setAppOrgId(gridEvent.getSysOrgId());
                gridApprovalRecordVo.setAppOrgName(gridEvent.getSysOrgName());
            }
            log.info("当前环节组织：" + gridApprovalRecordVo.getAppOrgId());

            if (StringUtils.isNotBlank(gridApprovalRecordVo.getAppUserId())) {
                CtUserDTO ctUserDTO = custClient.clientGetUserAll(gridApprovalRecordVo.getAppUserId());
                if (ObjectUtils.isNotEmpty(ctUserDTO)) {
                    if (StringUtils.isNotBlank(ctUserDTO.getIdcard())) {
                        GridUserIdNumberVo gridUserIdNumberVo = new GridUserIdNumberVo();
                        gridUserIdNumberVo.setIdNumber(ctUserDTO.getIdcard());
                        R<GridUserVo> result = gridUserService.getUserByIdNumber(gridUserIdNumberVo);
                        if (R.SUCCESS == result.getCode()) {
                            gridApprovalRecordVo.setAppUserId(result.getData().getId());
                            log.info("当前环节审批用户为: " + gridApprovalRecordVo.getAppUserId());
                        } else {
                            gridApprovalRecordVo.setAppUserId("a9406a88c8234cda82452799bf6bd6cd");
                            log.info("当前环节审批用户为特殊用户，身份证找不到用户{},{}", ctUserDTO.getIdcard(), ctUserDTO.getTrueName());
                        }
                    } else {
                        gridApprovalRecordVo.setAppUserId("a9406a88c8234cda82452799bf6bd6cd");
                        log.info("当前环节审批用户为特殊用户，找不到用户{}", gridApprovalRecordVo.getAppUserId());
                    }
                } else {
                    gridApprovalRecordVo.setAppUserId("a9406a88c8234cda82452799bf6bd6cd");
                    log.info("当前环节审批用户为特殊用户，找不到用户{}", gridApprovalRecordVo.getAppUserId());
                }
            } else {
                gridApprovalRecordVo.setAppUserId("a9406a88c8234cda82452799bf6bd6cd");
                log.info("当前环节审批用户为特殊用户");
            }
            String nextGridUnitId = null;
            if (StringUtils.isNotBlank(gridApprovalRecordVo.getNextOrgId())) {
                nextGridUnitId = gridCaseTaskService.getGridUnitIdByUnitId(gridApprovalRecordVo.getNextOrgId());
                gridApprovalRecordVo.setNextOrgId(nextGridUnitId);
                if (StringUtils.isBlank(nextGridUnitId)) {

                    throw new Exception("下一环节处理网格组织不存在:" + gridApprovalRecordVo.getNextOrgId() + "-" + gridApprovalRecordVo.getNextOrgName());
                }
                log.info("下一环节组织：" + gridApprovalRecordVo.getNextOrgId());
            }


            //添加附件查询条件
            List<String> ownerIdList = gridApprovalRecordVo.getOwnerIdList();
            log.info("开始获取附件：{}", gridApprovalRecordVo.getOwnerIdList());
            log.info("开始获取附件：{}", gridApprovalRecordVo.getCaseId());
            Map<String, Object> terms = new HashMap<>();
            if (ownerIdList != null && ownerIdList.size() != 0) {
                terms.put("ownerIdList", ownerIdList);
                if (ObjectUtils.isNotEmpty(gridApprovalRecordVo) && StringUtils.isNotBlank(gridApprovalRecordVo.getCaseId())) {
                    terms.put("mainId", gridApprovalRecordVo.getCaseId());
                }
                List<FileInfoBaseDTO> fileInfoBaseDTOList = fileInfoService.listFileInfoByTerms(terms);
                Map<String, Object> terms2 = new HashMap<>();
                if (ObjectUtils.isNotEmpty(gridApprovalRecordVo) && StringUtils.isNotBlank(gridApprovalRecordVo.getCaseId())) {
                    terms2.put("mainId", gridApprovalRecordVo.getCaseId());
                    terms2.put("ownerCat", "22_00014-5");
                }
                List<FileInfoBaseDTO> windUpList = fileInfoService.listFileInfoByTerms(terms2);
                List<GridFileRelatedVo> windupRelateVoList = new ArrayList<>();
                log.info("获取到附件上传：" + fileInfoBaseDTOList.size());
                if (windUpList != null && windUpList.size() > 0) {
                    log.info("获取到结案附件上传：" + windUpList.size());
                    for (FileInfoBaseDTO fileInfoBaseDTO : windUpList) {
                        try {
                            GridFileUploadVo gridFileUploadVo = new GridFileUploadVo();
                            gridFileUploadVo.setFileName(fileInfoBaseDTO.getFileName());
                            gridFileUploadVo.setFilePath(fileInfoBaseDTO.getFullPath());
                            gridFileUploadVo.setFileSize(fileInfoBaseDTO.getSize() != null ? fileInfoBaseDTO.getSize().longValue() : 0L);
                            gridFileUploadVo.setType(fileInfoBaseDTO.getSuffix());
                            R<GridFileUploadDTO> result = null;
                            //上传附件信息
                            result = gridCaseDataService.uploadFileInfo(gridFileUploadVo);
                            if (R.SUCCESS == result.getCode()) {
                                //获取上传结果，组成新的附件对象
                                GridFileUploadDTO gridFileUploadDTO = result.getData();
                                GridFileRelatedVo gridFileRelatedVo = new GridFileRelatedVo();
                                gridFileRelatedVo.setFileName(gridFileUploadDTO.getFileName());
                                gridFileRelatedVo.setFilePath(gridFileUploadDTO.getFilePath());
                                gridFileRelatedVo.setOriginalFileName(gridFileUploadDTO.getOriginalFileName());
                                gridFileRelatedVo.setFileSize(gridFileUploadDTO.getFileSize());
                                gridFileRelatedVo.setType("add");
                                gridFileRelatedVo.setFileType(gridFileUploadDTO.getFileType());
                                windupRelateVoList.add(gridFileRelatedVo);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            log.info("附件上传失败：" + fileInfoBaseDTO.getId());
                        }
                    }
                }
                List<GridFileRelatedVo> gridFileRelatedVoList = new ArrayList<>();
                for (FileInfoBaseDTO fileInfoBaseDTO : fileInfoBaseDTOList) {
                    try {
                        GridFileUploadVo gridFileUploadVo = new GridFileUploadVo();
                        gridFileUploadVo.setFileName(fileInfoBaseDTO.getFileName());
                        gridFileUploadVo.setFilePath(fileInfoBaseDTO.getFullPath());
                        gridFileUploadVo.setFileSize(fileInfoBaseDTO.getSize() != null ? fileInfoBaseDTO.getSize().longValue() : 0L);
                        gridFileUploadVo.setType(fileInfoBaseDTO.getSuffix());
                        R<GridFileUploadDTO> result = null;
                        //上传附件信息
                        result = gridCaseDataService.uploadFileInfo(gridFileUploadVo);
                        if (R.SUCCESS == result.getCode()) {
                            //获取上传结果，组成新的附件对象
                            GridFileUploadDTO gridFileUploadDTO = result.getData();
                            GridFileRelatedVo gridFileRelatedVo = new GridFileRelatedVo();
                            gridFileRelatedVo.setFileName(gridFileUploadDTO.getFileName());
                            gridFileRelatedVo.setFilePath(gridFileUploadDTO.getFilePath());
                            gridFileRelatedVo.setOriginalFileName(gridFileUploadDTO.getOriginalFileName());
                            gridFileRelatedVo.setFileSize(gridFileUploadDTO.getFileSize());
                            gridFileRelatedVo.setType("add");
                            gridFileRelatedVo.setFileType(gridFileUploadDTO.getFileType());
                            gridFileRelatedVoList.add(gridFileRelatedVo);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                        log.info("附件上传失败：" + fileInfoBaseDTO.getId());
                    }
                }
                log.info("xsdgridApprovalRecordVo{}",gridApprovalRecordVo);
                if (gridApprovalRecordVo.getHandleName().equals(GridEnum.EVENT_FLOW_3.getIndex())) {
                    //插入到更新事件对象中
                    log.info("gridFileRelatedVoList{}",gridFileRelatedVoList);
                    log.info("windupRelateVoList{}",windupRelateVoList);
                    gridApprovalRecordVo.setAfterAttachmentInfoList(gridFileRelatedVoList);
                    gridApprovalRecordVo.setEndAttachmentInfoList(windupRelateVoList);
                } else {
                    //插入到更新事件对象中
                    gridApprovalRecordVo.setAttachmentInfoList(gridFileRelatedVoList);
                }

            }

            if (SpringContextUtil.checkDev()) {
                gridEventRequest.setReqInfo("http://183.2.142.21:9007" + "/api/thrid/grid/casedata/upload-node-info" + JSON.toJSONString(gridApprovalRecordVo));
            } else {
                gridEventRequest.setReqInfo("http://219.137.166.84:8061" + "/event/saveApproveContent" + JSON.toJSONString(gridApprovalRecordVo));
            }
            R<String> result = gridCaseDataService.uploadCaseNodeInfo(gridApprovalRecordVo);
            if (result.getCode() == 0) {
                //记录请求成功信息
                gridEventRequest.setReqStatus(0);
                gridEventRequestService.save(gridEventRequest);
            } else {
                //记录请求失败信息
                gridEventRequest.setReqStatus(1);
                gridEventRequest.setErrorInfo(result.getMsg());
                gridEventRequestService.save(gridEventRequest);
            }
        } catch (Exception e) {
            //记录请求失败信息
            gridEventRequest.setReqStatus(1);
            gridEventRequest.setErrorInfo(e.getMessage());
            gridEventRequestService.save(gridEventRequest);
            log.error("更新事件信息失败", e);
            return ReturnFailUtils.getRepInfo();
        }
        return ReturnSucUtils.getRepInfo();
    }
}