package cn.huge.module.client.api.impl;

import cn.huge.base.common.bo.ReturnBO;
import cn.huge.base.common.constant.ReturnConsts;
import cn.huge.base.common.exception.ClientException;
import cn.huge.base.common.exception.ServiceException;
import cn.huge.module.ai.domain.dto.CaseInfoDetailDto;
import cn.huge.module.ai.domain.dto.DyhCaseDetailDTO;
import cn.huge.module.ai.domain.po.*;
import cn.huge.module.client.api.KnowledgeCaseClient;
import cn.huge.module.cust.dto.CtUserDTO;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.PostConstruct;

/**
 * @title: 案件知识库微服务调用接口实现
 * @description: 案件知识库微服务调用接口实现
 * @company: hugeinfo
 * @version: 1.0.0
 */
@Slf4j
@Component
public class KnowledgeCaseClientImpl {

    private KnowledgeCaseClient knowledgeCaseClient;

    @Autowired
    public KnowledgeCaseClientImpl(KnowledgeCaseClient knowledgeCaseClient) {
        this.knowledgeCaseClient = knowledgeCaseClient;
    }

    /**
     * ObjectMapper工具类
     */
    private ObjectMapper objectMapper = new ObjectMapper();
    //
    // @PostConstruct
    // public void init() {
    //     // 配置ObjectMapper支持常用日期格式
    //     objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    //     // 配置日期反序列化更宽松的处理
    //     objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    // }

    /**
     * 获取案件详情
     * @param id 案件ID
     * @return DyhCaseDetailDTO
     */
    public DyhCaseDetailDTO getCaseDetail(String id) {
        try {
            ReturnBO returnBO = knowledgeCaseClient.getCaseDetail(id);
            if (ReturnConsts.OK == returnBO.getCode()) {
                return objectMapper.convertValue(returnBO.getData(), DyhCaseDetailDTO.class);
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.getCaseDetail]请求异常：未获取到案件详情");
                throw new ClientException("KnowledgeCaseClientImpl.getCaseDetail", "未获取到案件详情");
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.getCaseDetail]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.getCaseDetail", e);
        }
    }

    /**
     * 检查案件相似度关系
     * @param relations 查询条件
     * @return List<CaseSimilarityRelations>
     */
    public List<CaseSimilarityRelations> checkRelations(CaseSimilarityRelations relations) {
        try {
            List<CaseSimilarityRelations> similarityRelations = knowledgeCaseClient.checkRelations(relations);
            // List<CaseSimilarityRelations> similarityRelations = objectMapper.convertValue(knowledgeCaseClient.checkRelations(relations), List.class);
            if (similarityRelations != null) {
                return similarityRelations;
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.checkRelations]请求异常：未获取到相似案件关系");
                return new ArrayList<>();
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.checkRelations]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.checkRelations", e);
        }
    }

    /**
     * 获取案件标题
     * @param id 案件ID
     * @return DyhCaseInfo 仅包含id和caseTitle
     */
    public DyhCaseInfo getCaseTitleById(String id) {
        try {
            // DyhCaseInfo caseInfo = knowledgeCaseClient.getCaseTitleById(id);
            ReturnBO returnBo = knowledgeCaseClient.getCaseTitleById(id);
            log.info("Client外服务接口[KnowledgeCaseClientImpl.getCaseTitleById]请求成功，返回结果：" + returnBo);
            if (ReturnConsts.OK == returnBo.getCode()){
                return objectMapper.convertValue(returnBo.getData(), DyhCaseInfo.class);
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.getCaseTitleById]请求异常：未获取到案件标题");
                throw new ClientException("KnowledgeCaseClientImpl.getCaseTitleById", "未获取到案件标题");
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.getCaseTitleById]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.getCaseTitleById", e);
        }
    }

    /**
     * 获取裁判文书案件标题
     * @param id 案件ID
     * @return CpwsCaseInfo 仅包含id和caseName
     */
    public CpwsCaseInfo getCpwsCaseTitleById(String id) {
        try {
            ReturnBO returnBo = knowledgeCaseClient.getCpwsCaseTitleById(id);
            log.info("Client外服务接口[KnowledgeCaseClientImpl.getCpwsCaseTitleById]请求成功，返回结果：" + returnBo);
            if (ReturnConsts.OK == returnBo.getCode()){
                return objectMapper.convertValue(returnBo.getData(), CpwsCaseInfo.class);
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.getCpwsCaseTitleById]请求异常：未获取到案件标题");
                throw new ClientException("KnowledgeCaseClientImpl.getCpwsCaseTitleById", "未获取到案件标题");
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.getCpwsCaseTitleById]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.getCpwsCaseTitleById", e);
        }
    }

    /**
     * 检查案件风险评估记录
     * @param caseId 案件ID
     * @return List<AiCaseRisk>
     */
    public List<AiCaseRisk> checkRisks(AiCaseRisk risk) {
        try {
            List<AiCaseRisk> aiCaseRiskList = knowledgeCaseClient.checkRisks(risk);
            log.debug("Client外服务接口[KnowledgeCaseClientImpl.checkRisks]请求成功，返回结果：" + aiCaseRiskList);
            if (aiCaseRiskList != null) {
                return aiCaseRiskList;
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.checkRisks]请求异常：未获取到风险评估记录");
                return new ArrayList<>();
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.checkRisks]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.checkRisks", e);
        }
    }

    /**
     * 获取裁判文书案件文本详情
     * @param id 案件文本ID
     * @return CpwsCaseText
     */
    public CpwsCaseText getCpwsCaseTextById(String id) {
        try {
            ReturnBO returnBo = knowledgeCaseClient.getCpwsCaseTextById(id);
            log.info("Client外服务接口[KnowledgeCaseClientImpl.getCpwsCaseTextById]请求成功，返回结果：" + returnBo);
            if (ReturnConsts.OK == returnBo.getCode()){
                return objectMapper.convertValue(returnBo.getData(), CpwsCaseText.class);
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.getCpwsCaseTextById]请求异常：未获取到案件文本详情");
                throw new ClientException("KnowledgeCaseClientImpl.getCpwsCaseTextById", "未获取到案件文本详情");
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.getCpwsCaseTextById]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.getCpwsCaseTextById", e);
        }
    }

    /**
     * 检查案件与法条关系
     * @param relations 查询条件
     * @return List<LawSimilarityRelations>
     */
    public List<LawSimilarityRelations> checkLawRelations(LawSimilarityRelations relations) {
        try {
            List<LawSimilarityRelations> lawRelations = knowledgeCaseClient.checkLawRelations(relations);
            if (lawRelations != null) {
                return lawRelations;
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.checkLawRelations]请求异常：未获取到法条关系");
                return new ArrayList<>();
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.checkLawRelations]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.checkLawRelations", e);
        }
    }

    /**
     * 获取法律详情
     * @param id 法律ID
     * @return LawProvision
     */
    public LawProvision getLawProvisionById(String id) {
        try {
            ReturnBO returnBo = knowledgeCaseClient.getLawProvisionById(id);
            log.info("Client外服务接口[KnowledgeCaseClientImpl.getLawProvisionById]请求成功，返回结果：" + returnBo);
            if (ReturnConsts.OK == returnBo.getCode()){
                return objectMapper.convertValue(returnBo.getData(), LawProvision.class);
            } else {
                log.error("Client外服务接口[KnowledgeCaseClientImpl.getLawProvisionById]请求异常：未获取到法律详情");
                throw new ClientException("KnowledgeCaseClientImpl.getLawProvisionById", "未获取到法律详情");
            }
        } catch (Exception e) {
            log.error("service方法[KnowledgeCaseClientImpl.getLawProvisionById]调用异常：" + e, e);
            throw new ServiceException("KnowledgeCaseClientImpl.getLawProvisionById", e);
        }
    }
}