package cn.huge.module.ai.service;

import cn.huge.base.common.utils.*;
import cn.huge.module.ai.domain.dto.CaseInfoDto;
import cn.huge.module.ai.domain.dto.LawInfoDto;
import cn.huge.module.ai.domain.po.CaseSimilarityRelations;
import cn.huge.module.ai.domain.po.CpwsCaseInfo;
import cn.huge.module.ai.domain.po.DyhCaseInfo;
import cn.huge.module.ai.domain.po.LawProvision;
import cn.huge.module.ai.domain.po.LawSimilarityRelations;
import cn.huge.module.ai.domain.vo.AiRequestVo;
import cn.huge.module.client.api.impl.KnowledgeCaseClientImpl;
import cn.huge.module.constant.AiCaseType;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

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

import static cn.huge.module.ai.service.AiCaseClassService.httpPostRaw;

@Slf4j
@Service
public class AiSimilarityCaseService {

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

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

    @Value("${dify.getSimilarityCpwsCaseApi}")
    private String getSimilarityCpwsCaseApi;
    // @Value("${dify.getSimilarityCpwsCaseNum}")
    // private String getSimilarityCpwsCaseNum;


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


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

    @Autowired
    private KnowledgeCaseClientImpl knowledgeCaseClient;

    public Object getSimilarityCase(AiRequestVo aiRequestVo) {
        // 先从缓存获取
        Object cacheAi = GuavaCacheUtils.getCacheAi("getSimilarityCase" + aiRequestVo.getCaseId());
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }

        // 先检查数据库中是否存在相似案件关系
        CaseSimilarityRelations relations = new CaseSimilarityRelations();
        relations.setCaseId(aiRequestVo.getCaseId());
        List<CaseSimilarityRelations> existingRelations = knowledgeCaseClient.checkRelations(relations);
        
        // 如果数据库中没有数据，则调用AI服务
        if (existingRelations == null || existingRelations.isEmpty()) {
            JSONObject dyhResponse = requestSimilarCases(aiRequestVo, getSimilarityDyhCaseApi);
            JSONObject cpwsResponse = requestSimilarCases(aiRequestVo, getSimilarityCpwsCaseApi);
            if (dyhResponse == null && cpwsResponse == null) {
                log.error("获取相似案件响应异常");
                return ReturnSucUtils.getRepInfo("获取相似案件失败", null);
            }
            // AI调用后重新获取数据库中的关系
            existingRelations = knowledgeCaseClient.checkRelations(relations);
            if (existingRelations == null || existingRelations.isEmpty()) {
                return ReturnSucUtils.getRepInfo("未找到相似案件", null);
            }
        }

        // 转换为前端所需的数据格式
        List<CaseInfoDto> caseInfoDtoList = convertToCaseInfoList(existingRelations);

        // 放入缓存
        if (!caseInfoDtoList.isEmpty()) {
            GuavaCacheUtils.putCacheAi("getSimilarityCase" + aiRequestVo.getCaseId(), caseInfoDtoList);
        }
        
        return ReturnSucUtils.getRepInfo("请求成功", caseInfoDtoList);
    }

    /**
     * 请求相似案件
     * @param aiRequestVo 请求参数
     * @param apiKey API密钥
     * @return JSONObject 响应结果
     */
    private JSONObject requestSimilarCases(AiRequestVo aiRequestVo, String apiKey) {
        // 构建请求参数
        Map<String, Object> requestBody = new HashMap<>();
        Map<String, Object> inputs = new HashMap<>();
        inputs.put("caseText", aiRequestVo.getCaseDes() + "\n" + aiRequestVo.getCaseClaim());
        inputs.put("caseId", aiRequestVo.getCaseId());
        inputs.put("topK", getSimilarityDyhCaseNum);
        requestBody.put("inputs", inputs);
        requestBody.put("response_mode", "blocking");
        requestBody.put("user", user);

        // 设置请求头
        Map<String, String> headers = new HashMap<>();
        headers.put("Authorization", "Bearer " + apiKey);
        String response;
        try {
            log.info("requestBody:{}", requestBody);
            response = httpPostRaw(difyUrl + "/workflows/run",
                JSONObject.toJSONString(requestBody), headers, "utf-8");
        } catch (Exception e) {
            log.error("获取相似案件失败: {}", e.getMessage());
            return JSONObject.parseObject("{'msg':'获取相似案件失败'}");
        }
        return JSONObject.parseObject(response);
    }

    /**
     * 将相似案件关系转换为案件信息列表
     * @param relations 相似案件关系列表
     * @return List<CaseInfoDto> 案件信息列表
     */
    private List<CaseInfoDto> convertToCaseInfoList(List<CaseSimilarityRelations> relations) {
        List<CaseInfoDto> caseInfoDtoList = new ArrayList<>();
        for (CaseSimilarityRelations relation : relations) {
            int similarityCaseType = Integer.parseInt(relation.getSimilarityCaseType());
            DyhCaseInfo caseInfo = new DyhCaseInfo();
            try {
                if (similarityCaseType == AiCaseType.AI_CASE_TYPE_DYH) {

                    caseInfo = knowledgeCaseClient.getCaseTitleById(relation.getSimilarityCaseId());
                } else if (similarityCaseType == AiCaseType.AI_CASE_TYPE_JUD) {
                    CpwsCaseInfo cpwsCaseInfo = knowledgeCaseClient.getCpwsCaseTitleById(relation.getSimilarityCaseId());
                    if (ObjectUtils.isNotEmpty(cpwsCaseInfo)) {
                        caseInfo.setId(cpwsCaseInfo.getCpwsCaseInfoId());
                        caseInfo.setCaseTitle(cpwsCaseInfo.getCaseName());
                    }
                }
                if (caseInfo.getCaseTitle() != null) {
                    log.info("获取案件标题成功, caseId: {}, caseTitle: {}", caseInfo.getId(), caseInfo.getCaseTitle());
                    CaseInfoDto caseInfoDto = new CaseInfoDto();
                    caseInfoDto.setCaseId(relation.getSimilarityCaseId());
                    caseInfoDto.setCaseName(caseInfo.getCaseTitle());
                    caseInfoDto.setCaseType(similarityCaseType);
                    caseInfoDtoList.add(caseInfoDto);
                }else{
                    log.error("获取案件标题失败, caseId: {},当前案件标题为空", relation.getSimilarityCaseId());
                    // 如果获取标题失败，使用关系表中的标题作为后备
                    CaseInfoDto caseInfoDto = new CaseInfoDto();
                    caseInfoDto.setCaseId(relation.getSimilarityCaseId());
                    caseInfoDto.setCaseName("-");
                    caseInfoDto.setCaseType(similarityCaseType);
                    caseInfoDtoList.add(caseInfoDto);
                }
            } catch (Exception e) {
                log.error("获取案件标题失败, caseId: {}, error: {}", relation.getSimilarityCaseId(), e.getMessage());
            }
        }
        return caseInfoDtoList;
    }

    /**
     * 获取AI推荐法条
     */
    public Object getCaseLaw(AiRequestVo aiRequestVo) {
        // 先从缓存获取
        Object cacheAi = GuavaCacheUtils.getCacheAi("get-law" + aiRequestVo.getCaseId());
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }

        // 先检查数据库中是否存在案件法条关系
        LawSimilarityRelations relations = new LawSimilarityRelations();
        relations.setCaseId(aiRequestVo.getCaseId());
        List<LawSimilarityRelations> existingRelations = knowledgeCaseClient.checkLawRelations(relations);

        List<LawInfoDto> lawInfoDtos = new ArrayList<>();
        
        // 如果数据库中没有数据，则调用AI服务
        if (existingRelations == null || existingRelations.isEmpty()) {
            JSONObject aiResponse = requestCaseLaw(aiRequestVo);
            if (aiResponse == null) {
                return ReturnSucUtils.getRepInfo("获取AI推荐法条失败", null);
            }
            // AI调用后重新获取数据库中的关系
            existingRelations = knowledgeCaseClient.checkLawRelations(relations);
            if (existingRelations == null || existingRelations.isEmpty()) {
                return ReturnSucUtils.getRepInfo("未找到推荐法条", null);
            }
        }

        // 转换为前端所需的数据格式
        lawInfoDtos = convertToLawInfoList(existingRelations);

        // 放入缓存
        if (!lawInfoDtos.isEmpty()) {
            GuavaCacheUtils.putCacheAi("get-law" + aiRequestVo.getCaseId(), lawInfoDtos);
        }
        
        return ReturnSucUtils.getRepInfo("请求成功", lawInfoDtos);
    }

    /**
     * 请求AI推荐法条
     */
    private JSONObject requestCaseLaw(AiRequestVo aiRequestVo) {
        try {
            // 构建请求参数
            Map<String, Object> requestBody = new HashMap<>();
            Map<String, Object> inputs = new HashMap<>();
            inputs.put("caseText", aiRequestVo.getCaseDes() + "\n" + aiRequestVo.getCaseClaim());
            inputs.put("caseId", aiRequestVo.getCaseId());
            requestBody.put("inputs", inputs);
            requestBody.put("response_mode", "blocking");
            inputs.put("topK", getCaseLawNum);
            requestBody.put("user", user);

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

            log.info("请求AI推荐法条, requestBody: {}", requestBody);
            log.info("请求AI推荐法条, headers: {}", headers);
            String response = httpPostRaw(difyUrl + "/workflows/run",
                    JSONObject.toJSONString(requestBody), headers, "utf-8");

            return JSONObject.parseObject(response);
        } catch (Exception e) {
            log.error("获取AI推荐法条失败: {}", e.getMessage());
            return null;
        }
    }

    /**
     * 将法条关系转换为法条信息列表
     */
    private List<LawInfoDto> convertToLawInfoList(List<LawSimilarityRelations> relations) {
        List<LawInfoDto> lawInfoDtos = new ArrayList<>();
        for (LawSimilarityRelations relation : relations) {
            try {
                LawInfoDto lawInfoDto = new LawInfoDto();
                lawInfoDto.setLawInfoId(relation.getLawProvisionId());
                LawProvision lawProvision = knowledgeCaseClient.getLawProvisionById(relation.getLawProvisionId());
                if (lawProvision != null) {
                    lawInfoDto.setLawIndex(lawProvision.getProvisionIndex());
                    lawInfoDto.setLawDesc(lawProvision.getProvisionText());
                    lawInfoDto.setLawTitle(relation.getLawTitle());
                    lawInfoDtos.add(lawInfoDto);
                }
            } catch (Exception e) {
                log.error("转换法条信息失败, lawId: {}, error: {}", relation.getLawInfoId(), e.getMessage());
            }
        }
        return lawInfoDtos;
    }

}