package cn.huge.module.ai.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.GuavaCacheUtils;
import cn.huge.base.common.utils.HttpClientUtils;
import cn.huge.base.common.utils.ObjectUtils;
import cn.huge.base.common.utils.ReturnSucUtils;
import cn.huge.module.ai.domain.dto.DyhRepeatCaseDTO;
import cn.huge.module.ai.domain.po.AiCaseRisk;
import cn.huge.module.ai.domain.vo.AiRepeatVo;
import cn.huge.module.ai.domain.vo.AiRiskVo;
import cn.huge.module.cases.domain.po.CaseInfo;
import cn.huge.module.cases.domain.po.CaseInfoUnfold;
import cn.huge.module.cases.domain.po.CasePerson;
import cn.huge.module.cases.service.CaseInfoService;
import cn.huge.module.cases.service.CaseInfoUnfoldService;
import cn.huge.module.cases.service.CasePersonService;
import cn.huge.module.client.api.impl.KnowledgeCaseClientImpl;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.IOException;
import java.util.*;

import static cn.huge.module.constant.IsRiskConsts.IS_RISK_STATUS_1;

@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class AiCaseClassService {

    @Value("${ai.url}")
    private String aiUrl;

    @Value("${dify.url}")
    private String difyUrl;

    @Value("${dify.getCaseRiskApi}")
    private String getCaseRiskApi;

    @Value("${dify.user}")
    private String user;

    @Autowired
    private CaseInfoUnfoldService caseInfoUnfoldService;

    @Autowired
    private CaseInfoService caseInfoService;

    @Autowired
    private CasePersonService casePersonService;

    @Autowired
    private KnowledgeCaseClientImpl knowledgeCaseClient;

    /**
     * 发送 http post 请求，参数以原生字符串进行提交，因为ai请求时间过长，在此另外实现一个请求方法
     * @param url 请求地址
     * @param stringJson json字符串数据
     * @param headers 请求头
     * @param encode 编码
     * @return
     * @throws Exception
     */
    public static String httpPostRaw(String url, String stringJson, Map<String, String> headers, String encode) throws Exception{
        if(encode == null){
            encode = "utf-8";
        }
        CloseableHttpClient closeableHttpClient = HttpClients.createDefault();
        //设置请求和传输超时时间，这里将时间设置为五分钟
        RequestConfig requestConfig = RequestConfig.custom().setSocketTimeout(300000).setConnectTimeout(300000).build();
        HttpPost httpost = new HttpPost(url);
        httpost.setConfig(requestConfig);
        //设置header
        httpost.setHeader("Content-type", "application/json");
        if (ObjectUtils.isNotEmpty(headers)) {
            for (Map.Entry<String, String> entry : headers.entrySet()) {
                httpost.setHeader(entry.getKey(),entry.getValue());
            }
        }
        //组织请求参数
        StringEntity stringEntity = new StringEntity(stringJson, encode);
        httpost.setEntity(stringEntity);
        String content = null;
        CloseableHttpResponse httpResponse = null;
        try {
            //响应信息
            httpResponse = closeableHttpClient.execute(httpost);
            HttpEntity entity = httpResponse.getEntity();
            content = EntityUtils.toString(entity, encode);
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception("网络连接异常，请稍候重试!", e);
        }finally{
            try {
                httpResponse.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        try {  //关闭连接、释放资源
            closeableHttpClient.close();
        } catch (IOException e) {
            e.printStackTrace();
            throw new Exception("网络连接异常，请稍候重试!", e);
        }
        return content;
    }

    /**
     * 请求ai判断案件是否为风险、重点案件并保存标签到数据库
     *
     * @param aiRiskVo 包含案件描述、请求和案件ID的请求类
     * @return 如果案件被判定为风险或重点案件，则返回true，否则返回false
     */
    public boolean getRiskResult(AiRiskVo aiRiskVo){
        try{
            if (aiRiskVo == null || aiRiskVo.getCaseText() == null || aiRiskVo.getCaseId() == null) {
                log.warn("输入参数为空，aiRiskVo: {}", aiRiskVo);
                return false;
            }
            boolean isRisk = false;
            // 从terms中获取案件描述、请求和案件ID
            String caseText = aiRiskVo.getCaseText();
            String caseId = aiRiskVo.getCaseId();

            // 准备请求参数
            Map<String, String> params = new HashMap<>();
            params.put("caseText", caseText);
            params.put("caseId",caseId);

            // 发起HTTP请求到AI接口获取风险判断结果
            String response = HttpClientUtils.httpPostForm(aiUrl + "/getRiskResult", params, new HashMap<>(), "utf-8");
            JSONObject object = JSONObject.parseObject(response);
            // log.info("案件风险判断结果："+s);

            int code = object.getIntValue("code");
            if (code == 200) {
                // 获取  data 字段中的内容，true或false
                isRisk = object.getBooleanValue("data");
                // log.info("案件风险判断结果："+isRisk);
            } else {
                log.error("API返回异常，code: {}, response: {}", code, response);
            }

            if (isRisk){
                // 如果案件被判定为风险案件，更新数据库中的风险标签
                CaseInfoUnfold caseInfoUnfold = new CaseInfoUnfold();
                caseInfoUnfold.setIsRisk(IS_RISK_STATUS_1);
                Map<String, Object> caseInfoUnfoldTerms = new HashMap<>();
                caseInfoUnfoldTerms.put("id", caseId);
            
                // 更新案件风险标签
                caseInfoUnfoldService.updateCaseInfoUnfoldTerms(caseInfoUnfold,caseInfoUnfoldTerms);
            }

            // 返回案件是否为风险或重点案件的结果
            return isRisk;
        } catch (JSONException e) {
            log.error("[AiCaseClassService.getRiskResult] JSON解析失败，异常信息：{}", e.getMessage(), e);
            throw new ServiceException("AiCaseClassService.getRiskResult.JSON_PARSE_FAILED", e);
        }catch (Exception e){
            // 异常处理，记录日志并抛出自定义异常
            log.error("[AiCaseClassService.getRiskResult]调用失败，异常信息："+e, e);
            throw new ServiceException("AiCaseClassService.getRiskResult", e);
        }
    }

    /**
     * 获取重复案件的结果
     * 通过HTTP请求将案件文本发送到AI接口检查是否为重复来访案件
     *
     * @param aiRepeatVo 包含案件信息的请求类，包括案件描述、请求、案件ID和当事人信息
     * @return 返回一个包含重复来访案件信息的列表
     */
    public List<DyhRepeatCaseDTO> getRepeatResult(AiRepeatVo aiRepeatVo){
        try{
            List<DyhRepeatCaseDTO> caseInfos = new ArrayList<>();

            // 申请方当事人-证件号码（可能包含多个，用逗号分隔）
            String plaintiffsCertiNosStr = aiRepeatVo.getPlaintiffsCertiNo();
            List<String> plaintiffsCertiNos = Arrays.asList(plaintiffsCertiNosStr.split(","));

            // 被申请方当事人-证件号码（可能包含多个，用逗号分隔）
            String defendantsCertiNosStr = aiRepeatVo.getDefendantsCertiNo();
            List<String> defendantsCertiNos = Arrays.asList(defendantsCertiNosStr.split(","));

            // 准备请求参数
            String caseText = aiRepeatVo.getCaseDes() + "\n" + aiRepeatVo.getCaseClaim();
            Map<String, String> params = new HashMap<>();
            params.put("caseText", caseText);
            try {
                // 发起HTTP请求到AI接口获取风险判断结果
                String s = HttpClientUtils.httpPostForm(aiUrl + "/checkIsRepeat", params, new HashMap<>(), "utf-8");
                JSONObject object = JSONObject.parseObject(s);

                int code = object.getIntValue("code");
                List<String> repeatCaseIds;
                if (code == 200) {
                    // 获取  data 字段中的内容，一个列表，每个元素是一个案件ID
                    repeatCaseIds = object.getJSONArray("data").toJavaList(String.class);
                } else {
                    // 异常处理，记录日志并抛出自定义异常
                    log.error("[AiCaseClassService.getRiskResult]HTTP请求到AI接口获取风险判断结果失败，响应码: {}", code);
                    throw new ServiceException("AiCaseClassService.getRiskResult");
                }

                if (repeatCaseIds.isEmpty()) {
                    log.info("[AiCaseClassService.getRiskResult]无重复案件信息");
                    return caseInfos;
                }

                // 查询对应案件的信息
                for (String repeatCaseId : repeatCaseIds){
                    DyhRepeatCaseDTO caseInfo = buildCaseInfo(repeatCaseId, plaintiffsCertiNos, defendantsCertiNos);
                    if (caseInfo != null) {
                        // 添加案件信息到列表中
                        caseInfos.add(caseInfo);
                    }
                }
            } catch (Exception e) {
                log.error("[AiCaseClassService.getRiskResult]HTTP请求或JSON解析失败，异常信息：" + e.getMessage(), e);
                throw new ServiceException("AiCaseClassService.getRiskResult", e);
            }

            return caseInfos;
        } catch (Exception e){
            // 异常处理，记录日志并抛出自定义异常
            log.error("[AiCaseClassService.getRiskResult]调用失败，异常信息："+e, e);
            throw new ServiceException("AiCaseClassService.getRiskResult", e);
        }
    }

    /**
     * 构建案件信息对象
     * 该方法通过案件ID获取案件详细信息，并根据人员类型设置原告和被告的证件号
     * 同时，它会检查给定的原告和被告证件号列表，以确定是否存在相似的申请方或被申请方
     *
     * @param repeatCaseId 案件ID
     * @param plaintiffsCertiNos 原告证件号列表
     * @param defendantsCertiNos 被告证件号列表
     * @return 返回填充了案件信息和重复分析列表的DyhRepeatCaseDTO对象
     */
    private DyhRepeatCaseDTO buildCaseInfo(String repeatCaseId, List<String> plaintiffsCertiNos, List<String> defendantsCertiNos) {
        // 初始化案件信息对象
        DyhRepeatCaseDTO dyhRepeatCaseDTO = new DyhRepeatCaseDTO();

        try {
            CaseInfoUnfold caseInfoUnfold = caseInfoUnfoldService.getById(repeatCaseId);
            CaseInfo caseInfo = caseInfoService.getById(repeatCaseId);
            if (caseInfo == null || caseInfoUnfold == null) {
                log.warn("案件信息不存在，caseId: {}", repeatCaseId);
                return null;
            }
            // 从案件详细信息中复制属性
            BeanUtils.copyProperties(caseInfoUnfold, dyhRepeatCaseDTO);
            // 从案件基本信息中复制属性
            BeanUtils.copyProperties(caseInfo, dyhRepeatCaseDTO);

            // 获取案件涉及的所有人员信息
            List<CasePerson> casePersons = casePersonService.listByCaseId(repeatCaseId);
            for (CasePerson casePerson : casePersons) {
                // 为证件号为空的人员设置默认值
                if (Objects.equals(casePerson.getCertiNo(), null)) {
                    casePerson.setCertiNo("-");
                }
                // 根据人员类型设置案件信息中的原告或被告证件号
                if ("15_020008-1".equals(casePerson.getPerType())) {
                    dyhRepeatCaseDTO.setPlaintiffsCertiNo(casePerson.getCertiNo());
                } else if ("15_020008-2".equals(casePerson.getPerType())) {
                    dyhRepeatCaseDTO.setDefendantsCertiNo(casePerson.getCertiNo());
                }
            }

            // 初始化重复分析列表
            dyhRepeatCaseDTO.setRepeatAnalyseList(new ArrayList<>());

            // 检查原告证件号是否匹配
            if (!plaintiffsCertiNos.isEmpty() && plaintiffsCertiNos.contains(dyhRepeatCaseDTO.getPlaintiffsCertiNo())) {
                dyhRepeatCaseDTO.getRepeatAnalyseList().add("申请方当事人相似");
            }

            // 检查被告证件号是否匹配
            if (!defendantsCertiNos.isEmpty() && defendantsCertiNos.contains(dyhRepeatCaseDTO.getDefendantsCertiNo())) {
                dyhRepeatCaseDTO.getRepeatAnalyseList().add("被申请方当事人相似");
            }

            // 添加事项概况相似到分析列表
            dyhRepeatCaseDTO.getRepeatAnalyseList().add("事项概况相似");

            // 返回填充好的案件信息对象
            return dyhRepeatCaseDTO;
        } catch (Exception e) {
            log.error("构建案件信息对象失败，异常信息：" + e.getMessage(), e);
            throw new ServiceException("AiCaseClassService.buildCaseInfo", e);
        }

    }

    /**
     * 向量化案件到向量数据库
     *
     * @param aiRepeatVo 包含案件描述、请求和案件ID的请求类
     * @return 如果案件被判定为风险或重点案件，则返回true，否则返回false
     */
    public boolean embeddingTextToMilvus(AiRepeatVo aiRepeatVo){
        try{
            if (aiRepeatVo == null
                    || aiRepeatVo.getCaseDes() == null
                    || aiRepeatVo.getCaseClaim() == null
                    || aiRepeatVo.getCaseId() == null) {
                log.warn("输入参数为空，aiRepeatVo: {}", aiRepeatVo);
                return false;
            }
            boolean toMilvus = false;
            // 从terms中获取案件描述、请求和案件ID
            String caseText = aiRepeatVo.getCaseDes() + "\n" + aiRepeatVo.getCaseClaim();
            String caseId = aiRepeatVo.getCaseId();

            // 准备请求参数
            Map<String, String> params = new HashMap<>();
            params.put("caseId", caseId);
            params.put("originalText", caseText);

            // 发起HTTP请求到AI接口
            String response = HttpClientUtils.httpPostForm(aiUrl + "/embeddingTextToMilvus", params, new HashMap<>(), "utf-8");
            JSONObject object = JSONObject.parseObject(response);

            int code = object.getIntValue("code");
            if (code == 200) {
                // 获取  data 字段中的内容，true或false
                // object.getBooleanValue("data");
                toMilvus = true;
                // log.info("案件风险判断结果："+isRisk);
            } else {
                log.error("API返回异常，code: {}, response: {}", code, response);
            }
            return toMilvus;
        } catch (JSONException e) {
            log.error("[AiCaseClassService.getRiskResult] JSON解析失败，异常信息：{}", e.getMessage(), e);
            throw new ServiceException("AiCaseClassService.getRiskResult.JSON_PARSE_FAILED", e);
        }catch (Exception e){
            // 异常处理，记录日志并抛出自定义异常
            log.error("[AiCaseClassService.getRiskResult]调用失败，异常信息："+e, e);
            throw new ServiceException("AiCaseClassService.getRiskResult", e);
        }
    }

    /**
     * 获取案件风险评估结果
     * 处理流程：
     * 1. 优先从缓存获取评估结果
     * 2. 检查数据库是否存在历史评估记录
     * 3. 如无历史记录，则请求AI服务进行评估
     * 4. 评估完成后更新案件风险等级
     *
     * @param aiRiskVo 包含案件描述和ID的请求对象
     * @return ReturnSucUtils封装的评估结果
     */
    public Object getCaseRisk(AiRiskVo aiRiskVo) {
        String cacheKey = "getCaseRisk" + aiRiskVo.getCaseId();
        
        try {
            // 先从缓存获取
            Object cacheAi = GuavaCacheUtils.getCacheAi(cacheKey);
            if (ObjectUtils.isNotEmpty(cacheAi)) {
                return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
            }

            // 参数校验
            if (!validateRiskRequest(aiRiskVo)) {
                return ReturnSucUtils.getRepInfo("参数错误", null);
            }
            AiCaseRisk risk = new AiCaseRisk();
            risk.setCaseId(aiRiskVo.getCaseId());
            // 检查数据库历史记录
            AiCaseRisk riskResult = getExistingRiskAssessment(risk);
            if (riskResult != null) {
                return processRiskResult(riskResult, cacheKey);
            }

            // 请求AI服务并处理结果
            return processAiAssessment(aiRiskVo, cacheKey, risk);

        } catch (Exception e) {
            log.error("获取案件风险评估失败: {}", e.getMessage(), e);
            return ReturnSucUtils.getRepInfo("风险评估异常", null);
        }
    }

    /**
     * 验证风险评估请求参数
     */
    private boolean validateRiskRequest(AiRiskVo aiRiskVo) {
        if (aiRiskVo == null || aiRiskVo.getCaseText() == null || aiRiskVo.getCaseId() == null) {
            log.warn("输入参数为空，aiRiskVo: {}", aiRiskVo);
            return false;
        }
        return true;
    }

    /**
     * 获取已存在的风险评估记录
     * @param risk 案件ID
     * @return 最新的风险评估记录，如果不存在则返回null
     */
    private AiCaseRisk getExistingRiskAssessment(AiCaseRisk risk) {
        List<AiCaseRisk> existingRisks = knowledgeCaseClient.checkRisks(risk);
        return !existingRisks.isEmpty() ? existingRisks.get(0) : null;
    }

    /**
     * 处理风险评估结果
     * @param riskResult 风险评估结果
     * @param cacheKey 缓存键
     * @return 处理后的响应对象
     */
    private Object processRiskResult(AiCaseRisk riskResult, String cacheKey) {
        checkAndUpdateRiskLevel(riskResult, riskResult.getCaseId());
        GuavaCacheUtils.putCacheAi(cacheKey, riskResult);
        return ReturnSucUtils.getRepInfo("请求成功", riskResult);
    }

    /**
     * 处理AI评估请求及其结果
     * @param aiRiskVo 请求参数
     * @param cacheKey 缓存键
     * @return 处理后的响应对象
     */
    private Object processAiAssessment(AiRiskVo aiRiskVo, String cacheKey,AiCaseRisk risk) {
        JSONObject responseObj = requestAiRiskAssessment(aiRiskVo);
        
        if (responseObj != null) {
            AiCaseRisk latestRisk = getExistingRiskAssessment(risk);
            if (latestRisk != null) {
                return processRiskResult(latestRisk, cacheKey);
            } else {
                log.warn("AI评估成功但未获取到风险评估记录, caseId: {}", aiRiskVo.getCaseId());
            }
        }
        
        return "风险评估失败";
    }

    /**
     * 检查并更新案件风险等级
     * @param riskResult 风险评估结果
     * @param caseId 案件ID
     */
    private void checkAndUpdateRiskLevel(AiCaseRisk riskResult, String caseId) {
        if (riskResult != null && riskResult.getIsRiskAi() != null) {
            try {
                int riskLevel = Integer.parseInt(riskResult.getIsRiskAi());
                if (riskLevel > 3) {
                    CaseInfoUnfold caseInfoUnfold = new CaseInfoUnfold();
                    caseInfoUnfold.setIsRisk(IS_RISK_STATUS_1);
                    Map<String, Object> caseInfoUnfoldTerms = new HashMap<>();
                    caseInfoUnfoldTerms.put("id", caseId);
                    caseInfoUnfoldService.updateCaseInfoUnfoldTerms(caseInfoUnfold, caseInfoUnfoldTerms);
                }
            } catch (NumberFormatException e) {
                log.error("风险等级解析失败: {}", riskResult.getIsRiskAi());
            }
        }
    }

    /**
     * 请求AI风险评估服务
     * @param aiRiskVo 风险评估请求参数
     * @return AI服务响应结果
     */
    private JSONObject requestAiRiskAssessment(AiRiskVo aiRiskVo) {
        try {
            // 构建请求参数
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            inputs.put("caseText", aiRiskVo.getCaseText());
            inputs.put("caseId", aiRiskVo.getCaseId());
            requestBody.put("inputs", inputs);
            requestBody.put("response_mode", "blocking");
            requestBody.put("user", user);

            // 设置请求头
            Map<String, String> headers = new HashMap<>();
            headers.put("Authorization", "Bearer " + getCaseRiskApi);

            // 发送请求到Dify服务
            String response = httpPostRaw(difyUrl + "/workflows/run",
                    JSONObject.toJSONString(requestBody), headers, "utf-8");
            
            return JSONObject.parseObject(response);
        } catch (Exception e) {
            log.error("请求AI风险评估服务失败: {}", e.getMessage(), e);
            return null;
        }
    }
}