package cn.huge.module.casebook.service;

import cn.huge.base.common.constant.ReturnConsts;
import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.*;
import cn.huge.module.casebook.domain.dto.CaseBookPageDTO;
import cn.huge.module.casebook.domain.po.*;
import cn.huge.module.client.api.impl.CustClientImpl;
import cn.huge.module.client.api.impl.SysClientImpl;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.casebook.dao.mapper.CasebookInfoMapper;
import cn.huge.module.cust.dto.CtUserDTO;
import cn.huge.module.sys.dto.FileInfoBaseDTO;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @title: dyh_casebook_info业务逻辑处理
 * @Description dyh_casebook_info业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-10-26 12:31:22
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class CasebookInfoService extends ServiceImpl<CasebookInfoMapper, CasebookInfo>{

    @Autowired
    private CasebookInfoMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;
    @Autowired
    private CustClientImpl custClient;
    @Autowired
    private SysClientImpl sysClient;
    @Autowired
    private CasebookPersonService casebookPersonService;
    @Autowired
    private CasebookAgentService casebookAgentService;
    @Autowired
    private CasebookAssistInfoService casebookAssistInfoService;
    @Autowired
    private CasebookFileService casebookFileService;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateCasebookInfo(CasebookInfo entity){
        try{
            mapper.updateCasebookInfo(entity);
        }catch (Exception e){
            log.error("[CasebookInfoService.updateCasebookInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.updateCasebookInfo", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateCasebookInfoTerms(CasebookInfo entity, Map<String, Object> terms){
        try{
            mapper.updateCasebookInfoTerms(entity, terms);
        }catch (Exception e){
            log.error("[CasebookInfoService.updateCasebookInfoTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.updateCasebookInfoTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteCasebookInfo(String id){
        try{
            mapper.deleteCasebookInfo(id);
        }catch (Exception e){
            log.error("[CasebookInfoService.deleteCasebookInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.deleteCasebookInfo", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<CasebookInfo> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<CasebookInfo> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<CasebookInfo> content = mapper.pageTerms(page, terms);
        return new PageImpl<CasebookInfo>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param casebookInfo 实体对象
    */
    public void saveCasebookInfo(CasebookInfo casebookInfo){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(casebookInfo.getId())){
                casebookInfo.setId(utilsClient.getNewTimeId());
                casebookInfo.setCreateTime(nowDate);
            }
            casebookInfo.setUpdateTime(nowDate);
            this.saveOrUpdate(casebookInfo);
        }catch (Exception e){
            log.error("[CasebookInfoService.saveCasebookInfo]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.saveCasebookInfo", e);
        }
    }

    /**
     * 条件分页查询-导入草稿
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<CaseBookPageDTO> pageImportDraft(PageRequest page, Map<String, Object> terms){
        long total = mapper.countImportDraft(terms);
        List<CaseBookPageDTO> content = mapper.pageImportDraft(page, terms);
        return new PageImpl<CaseBookPageDTO>(content, page, total);
    }

    /**
     * 条件分页查询-导入成功
     * @param page 分页对象
     * @param terms 条件
     * @return Page
     */
    public Page<CaseBookPageDTO> pageImportSuc(PageRequest page, Map<String, Object> terms){
        long total = mapper.countImportSuc(terms);
        List<CaseBookPageDTO> content = mapper.pageImportSuc(page, terms);
        return new PageImpl<CaseBookPageDTO>(content, page, total);
    }

    /**
     * 案件导入-导入操作-通过Excel导入
     * @param fileId
     * @param userId
     * @param request
     * @return
     */
    public Object inputCaseByExcel(String fileId, String userId, HttpServletRequest request){
        int row = 0;
        int cll = 0;
        int countFalse = 1;
        int countSuccess = 3;
        int all = 0;
        try{
            CtUserDTO loginUser = custClient.clientGetUser(userId);
            Date nowDate = DateUtils.getNowDate();
            SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
            SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd");
            SimpleDateFormat sdf5 = new SimpleDateFormat("yyyy.MM.dd");
            SimpleDateFormat sdf4 = new SimpleDateFormat("yyyy年");

            //当重复导入判断是否继续
            String adopt = request.getParameter("adopt");
            FileInfoBaseDTO fileInfo = sysClient.getFileInfoById(fileId);
            //判断是否近期内是否有重复导入
            if(StringUtils.isBlank(adopt) && ObjectUtils.isNotEmpty(fileInfo)){
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String dateStart = sdf.format(DateUtils.addDay(nowDate, -1));
                Map<String, Object> caseBookFileTerms = new HashMap<>();
                caseBookFileTerms.put("fileName", fileInfo.getTrueName());
                caseBookFileTerms.put("fileSize", fileInfo.getSize());
                caseBookFileTerms.put("userId", loginUser.getId());
                caseBookFileTerms.put("createTimeStart", dateStart);
                List<CasebookFile> caseBookFileList = casebookFileService.listTerms(caseBookFileTerms);
                if(CollectionUtils.isNotEmpty(caseBookFileList)){
                    return ReturnFailUtils.getAesInfo(ReturnConsts.ERROR_5, "", null);
                }
            }

            if (countFalse != all) {
                CasebookFile casebookFile = new CasebookFile();
                casebookFile.setFileName(fileInfo.getTrueName());
                casebookFile.setFileSize(String.valueOf(fileInfo.getSize()));
                casebookFile.setUserId(loginUser.getId());
                casebookFile.setUserName(loginUser.getTrueName());
                casebookFile.setCreateTime(nowDate);
                casebookFile.setUpdateTime(nowDate);
                casebookFile.setId(utilsClient.getNewTimeId());
                casebookFile.setCustId(loginUser.getCustId());
                casebookFileService.save(casebookFile);
            }

            List<String> reasonList = new ArrayList<>();
            String reason = "(1)序号14：纠纷受理时间数据格式错误";
            reasonList.add(reason);

            Map<String, Object> result = new HashMap<>();
            result.put("countSuccess", countSuccess);
            result.put("countFalse", countFalse);
            result.put("countFalseContent", reasonList);
            return ReturnSucUtils.getRepInfo(result);
        }catch (Exception e){
            log.error("[CasebookInfoService.inputCaseByExcel]调用失败，异常信息："+e, e);
            return ReturnFailUtils.getAesInfo("您导入Excel的内容不正确");
        }
    }

    /**
     * 案件导入-删除草稿
     * @param idList
     * @return
     */
    public void deleteDraft(List<String> idList){
        try{
            QueryWrapper<CasebookInfo> caseBookQueryWrapper = new QueryWrapper<>();
            caseBookQueryWrapper.in("id", idList);
            this.remove(caseBookQueryWrapper);

            QueryWrapper<CasebookAgent> casebookAgentQueryWrapper = new QueryWrapper<>();
            casebookAgentQueryWrapper.in("case_id", idList);
            casebookAgentService.remove(casebookAgentQueryWrapper);

            QueryWrapper<CasebookPerson> casebookPersonQueryWrapper = new QueryWrapper<>();
            casebookPersonQueryWrapper.in("case_id", idList);
            casebookPersonService.remove(casebookPersonQueryWrapper);

            QueryWrapper<CasebookAssistInfo> casebookAssistInfoQueryWrapper = new QueryWrapper<>();
            casebookAssistInfoQueryWrapper.in("case_id", idList);
            casebookAssistInfoService.remove(casebookAssistInfoQueryWrapper);
        }catch (Exception e){
            log.error("[CasebookInfoService.deleteDraft]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.deleteDraft", e);
        }
    }

    /**
     * 案件导入-草稿转入正式案件
     * @param idList
     * @return
     */
    public void importToCase(List<String> idList, String userId){
        try{

        }catch (Exception e){
            log.error("[CasebookInfoService.importToCase]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.importToCase", e);
        }
    }

    /**
     * 案件导入-全部草稿转入正式案件
     * @param terms 条件
     * @return Page
     */
    public void importToCaseAll(Map<String, Object> terms){
        try{
            List<CaseBookPageDTO> caseBookPageDTOList = mapper.listImportDraft(terms);
            for (CaseBookPageDTO caseBookPageDTO: caseBookPageDTOList){

            }

        }catch (Exception e){
            log.error("[CasebookInfoService.importToCase]调用失败，异常信息："+e, e);
            throw new ServiceException("CasebookInfoService.importToCase", e);
        }
    }

}