package cn.huge.module.ai.controller;

import cn.huge.base.common.utils.*;
import cn.huge.module.ai.domain.dto.*;
import cn.huge.module.ai.domain.po.*;
import cn.huge.module.ai.domain.vo.AiChatVo;
import cn.huge.module.ai.domain.vo.AiMediateStrategyVo;
import cn.huge.module.ai.domain.vo.AiRepeatVo;
import cn.huge.module.ai.domain.vo.AiRequestVo;
import cn.huge.module.ai.domain.vo.AiRiskVo;
import cn.huge.module.ai.domain.vo.AiPropertyChatVo;
import cn.huge.module.ai.service.AiCaseClassService;
import cn.huge.module.ai.service.AiChatService;
import cn.huge.module.ai.service.AiDifyService;
import cn.huge.module.ai.service.AiSimilarityCaseService;
import cn.huge.module.constant.AiCaseType;
import cn.huge.module.client.api.impl.KnowledgeCaseClientImpl;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBody;

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

/**
 * AI请求调用/get-case获取案件列表(一般包含3个纠纷类和3个判决类)，/get-law获取法条推荐列表；案件详情在根据案件列表的id及type调用/get-case-detail获取案件详情
 */
@Slf4j
@RestController
@RequestMapping("/api/ai/case-law")
public class AiController {

    @Autowired(required = false)
    private HttpServletRequest request;

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

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

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

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

    @Autowired
    private AiChatService aiChatService;

    @Autowired
    private AiCaseClassService aiCaseClassService;

    @Autowired
    private AiDifyService aiDifyService;

    @Autowired
    private KnowledgeCaseClientImpl knowledgeCaseClient;

    @Autowired
    private AiSimilarityCaseService aiSimilarityCaseService;

    private Map<String, Object> getParameter() {
        Map<String, Object> terms = Maps.newHashMap();
        // 案件id
        String caseId = request.getParameter("caseId");
        if (StringUtils.isNotBlank(caseId)) {
            terms.put("caseId", caseId);
        }
        // 用户id
        String userId = request.getParameter("userId");
        if (StringUtils.isNotBlank(userId)) {
            terms.put("userId", userId);
        }
        // 会话标题
        String conversationTitle = request.getParameter("conversationTitle");
        if (StringUtils.isNotBlank(conversationTitle)) {
            terms.put("conversationTitle", conversationTitle);
        }
        // 会话id
        String aiConversationId = request.getParameter("aiConversationId");
        if (StringUtils.isNotBlank(aiConversationId)) {
            terms.put("aiConversationId", aiConversationId);
        }
        // 案件描述
        String caseDes = request.getParameter("caseDes");
        if (StringUtils.isNotBlank(caseDes)) {
            terms.put("caseDes", caseDes);
        }
        // 案件诉求
        String caseClaim = request.getParameter("caseClaim");
        if (StringUtils.isNotBlank(caseClaim)) {
            terms.put("caseClaim", caseClaim);
        }
        // 用户消息（提问）
        String userMessage = request.getParameter("userMessage");
        if (StringUtils.isNotBlank(userMessage)) {
            terms.put("userMessage", userMessage);
        }
        // 相似案件id
        String similarityCaseId = request.getParameter("similarityCaseId");
        if (StringUtils.isNotBlank(similarityCaseId)) {
            terms.put("similarityCaseId", similarityCaseId);
        }
        // 判决案件正文
        String caseContent = request.getParameter("caseContent");
        if (StringUtils.isNotBlank(caseContent)) {
            terms.put("caseContent", caseContent);
        }
        // 评价
        String likeStatus = request.getParameter("likeStatus");
        if (StringUtils.isNotBlank(likeStatus)) {
            terms.put("likeStatus", likeStatus);
        }
        // 需要判断的案件文本
        String caseText = request.getParameter("caseText");
        if (StringUtils.isNotBlank(caseText)) {
            terms.put("caseText", caseText);
        }
        // 申请方当事人-证件号码
        String plaintiffsCertiNo = request.getParameter("plaintiffsCertiNo");
        if (StringUtils.isNotBlank(plaintiffsCertiNo)) {
            terms.put("plaintiffsCertiNo", plaintiffsCertiNo);
        }
        // 被申请方当事人-证件号码
        String defendantsCertiNo = request.getParameter("defendantsCertiNo");
        if (StringUtils.isNotBlank(defendantsCertiNo)) {
            terms.put("defendantsCertiNo", defendantsCertiNo);
        }
        return terms;
    }

    /**
     * 获取查询案件的重复案件
     *
     * @return
     * @url {ctx}/api/ai/case-law/getRepeatResult
     */
    @PostMapping("/getRepeatResult")
    public Object getRepeatResult(@RequestBody AiRepeatVo aiRepeatVo) {
        try {
//             return ReturnSucUtils.getRepInfo("请求成功", aiCaseClassService.getRepeatResult(aiRepeatVo));
            return ReturnSucUtils.getRepInfo("请求成功", new ArrayList<>());
        } catch (Exception e) {
            log.error("判断案件是否为重复来访案件失败：{}", e.getMessage());
            return ReturnSucUtils.getRepInfo();
        }
    }

    /**
     * 请求ai判断案件是否为风险、重点案件并保存标签到数据库
     *
     * @return
     * @url {ctx}/api/ai/case-law/getRiskResult
     */
    @PostMapping("/getRiskResult")
    public Object getRiskResult(@RequestBody AiRiskVo aiRiskVo) {
        try {
            // return ReturnSucUtils.getRepInfo("请求成功", aiCaseClassService.getRiskResult(aiRiskVo));
            return ReturnSucUtils.getRepInfo("请求成功", aiCaseClassService.getCaseRisk(aiRiskVo));
        } catch (Exception e) {
            log.error("判断案件是否为风险/重点案件失败：{}", e.getMessage());
            // return ReturnFailUtils.getRepInfo();
            return ReturnSucUtils.getRepInfo();
        }
    }

    /**
     * 向量化案件到向量数据库
     *
     * @return
     * @url {ctx}/api/ai/case-law/embeddingTextToMilvus
     */
    @PostMapping("/embeddingTextToMilvus")
    public Object embeddingTextToMilvus(@RequestBody AiRepeatVo aiRepeatVo) {
        try {
            return ReturnSucUtils.getRepInfo("请求成功", aiCaseClassService.embeddingTextToMilvus(aiRepeatVo));
        } catch (Exception e) {
            log.error("向量化案件到向量数据库失败：{}", e.getMessage());
            // return ReturnFailUtils.getRepInfo();
            return ReturnSucUtils.getRepInfo();
        }
    }

    /**
     * 创建会话
     *
     * @param
     * @return Object
     * @url {ctx}/api/ai/case-law/createAiChat
     */
    @PostMapping("/createAiChat")
    public Object createAiChat() {
        Map<String, Object> terms = getParameter();

        try {
            AiConversation aiConversation = aiChatService.createAiChat(terms);
            return ReturnSucUtils.getRepInfo("请求成功", aiConversation);
        } catch (Exception e) {
            log.error("创建AI会话失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 获取智能会话列表
     *
     * @param
     * @return Object
     * @url {ctx}/api/ai/case-law/queryAiChatList
     */
    @GetMapping("/queryAiChatList")
    public Object queryAiChatList() {
        Map<String, Object> terms = getParameter();
        String caseId = terms.get("caseId").toString();
        String userId = terms.get("userId").toString();

        // 先从缓存中获取，如果有直接返回
        Object cacheAi = GuavaCacheUtils.getCacheAi("queryAiChatList" + caseId + userId);
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }

        try {
            List<AiConversation> aiConversations = aiChatService.queryAiChatList(caseId, userId);
            // 放入缓存
            GuavaCacheUtils.putCacheAi("queryAiChatList" + caseId + userId, aiConversations);
            return ReturnSucUtils.getRepInfo("请求成功", aiConversations);
        } catch (Exception e) {
            log.error("查询AI会话列表失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 创建对话
     *
     * @param
     * @return Object
     * @url {ctx}/api/ai/case-law/createAiChatMessage
     */
    @PostMapping(value = "/createAiChatMessage", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
    public StreamingResponseBody createAiChatMessage() {
        Map<String, Object> terms = getParameter();

        try {
            return aiChatService.createAiChatMessage(terms);
        } catch (Exception e) {
            log.error("创建AI会话消息失败：{}", e.getMessage());
            return null;
        }
    }

    /**
     * 获取智能会话列表
     *
     * @return
     * @url {ctx}/api/ai/case-law/getAiChatMessageList
     */
    @GetMapping("/getAiChatMessageList")
    public Object getAiChatMessageList() {
        Map<String, Object> terms = getParameter();
        String aiConversationId = terms.get("aiConversationId").toString();

        // 先从缓存中获取，如果有直接返回
        Object cacheAi = GuavaCacheUtils.getCacheAi("getAiChatMessageList" + aiConversationId);
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }

        try {
            List<AiMessage> aiConversationMessages = aiChatService.getAiChatMessageList(aiConversationId);
            // 放入缓存
            GuavaCacheUtils.putCacheAi("getAiChatMessageList" + aiConversationId, aiConversationMessages);
            return ReturnSucUtils.getRepInfo("请求成功", aiConversationMessages);
        } catch (Exception e) {
            log.error("查询AI会话消息列表失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 删除会话
     *
     * @return
     * @url {ctx}/api/ai/case-law/deleteConversation
     */
    @PostMapping("/deleteConversation")
    public Object deleteConversation() {
        Map<String, Object> terms = getParameter();

        try {
            return ReturnSucUtils.getRepInfo("请求成功", aiChatService.deleteConversation(terms));
        } catch (Exception e) {
            log.error("删除AI会话失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 获取案件总结
     *
     * @return
     * @url {ctx}/api/ai/case-law/getJudgmentSummarize
     */
    @PostMapping("/getJudgmentSummarize")
    public Object getJudgmentSummarize() {
        Map<String, Object> terms = getParameter();

        String similarityCaseId = terms.get("similarityCaseId").toString();
        String caseContent = terms.get("caseContent").toString();
        String caseId = terms.get("caseId").toString();

        // 先从缓存中获取，如果有直接返回
        Object cacheAi = GuavaCacheUtils.getCacheAi("getJudgmentSummarize" + caseId + similarityCaseId);
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }
        try {
            CaseSimilarityExplanatory caseSimilarityExplanatory = aiChatService.getJudgmentSummarize(similarityCaseId, caseContent, caseId);

            // 放入缓存
            GuavaCacheUtils.putCacheAi("getJudgmentSummarize" + caseId + similarityCaseId, caseSimilarityExplanatory);
            return ReturnSucUtils.getRepInfo("请求成功", caseSimilarityExplanatory);
        } catch (Exception e) {
            log.error("获取案件总结失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    /**
     * 类案推荐评价
     *
     * @return
     * @url {ctx}/api/ai/case-law/setLikeStatus
     */
    @PostMapping("/setLikeStatus")
    public Object setLikeStatus() {
        Map<String, Object> terms = getParameter();

        try {
            aiChatService.setLikeStatus(terms);
            return ReturnSucUtils.getRepInfo(true);
        } catch (Exception e) {
            log.error("设置点赞状态失败：{}", e.getMessage());
            return ReturnFailUtils.getRepInfo();
        }
    }

    // @PostMapping("/get-case")
    public Object getCase(@RequestBody AiRequestVo aiRequestVo) {
        Object cacheAi = GuavaCacheUtils.getCacheAi("get-case" + aiRequestVo.getCaseId());
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }
        List<CaseInfoDto> caseInfoDtoList = new ArrayList<>();
        Map<String, String> params = new HashMap<>();
        params.put("caseDes", aiRequestVo.getCaseDes());//案件描述
        params.put("caseClaim", aiRequestVo.getCaseClaim());//案件诉求
        params.put("caseId", aiRequestVo.getCaseId());//案件id
        params.put("topK", "2");
        params.put("metricType", "IP");
        String s = HttpClientUtils.httpPostForm(aiUrl + "/queryConciliationCase", params, new HashMap<>(), "utf-8");
        JSONObject object = JSONObject.parseObject(s);
        int code = object.getIntValue("code");
        if (code == 200) {
            JSONArray data = object.getJSONArray("data");
            for (int i = 0; i < data.size(); i++) {
                JSONObject jsonObject = data.getJSONObject(i);
                CaseInfoDto caseInfoDto = new CaseInfoDto();
                caseInfoDto.setCaseId(jsonObject.getString("id"));
                caseInfoDto.setCaseName(jsonObject.getString("case_title"));
                caseInfoDto.setCaseType(1);//表示调解类案件
                caseInfoDtoList.add(caseInfoDto);
            }
        }
        if (caseInfoDtoList.size() < 4) {
            s = HttpClientUtils.httpPostForm(aiUrl + "/queryJudgmentCase", params, new HashMap<>(), "utf-8");
            object = JSONObject.parseObject(s);
            code = object.getIntValue("code");
            if (code == 200) {
                JSONArray data = object.getJSONArray("data");
                for (int i = 0; i < data.size(); i++) {
                    JSONObject jsonObject = data.getJSONObject(i);
                    CaseInfoDto caseInfoDto = new CaseInfoDto();
                    caseInfoDto.setCaseId(jsonObject.getString("cpws_case_info_id"));
                    caseInfoDto.setCaseName(jsonObject.getString("case_name"));
                    caseInfoDto.setCaseType(2);//表示判决类案件
                    caseInfoDtoList.add(caseInfoDto);
                    if (caseInfoDtoList.size() == 3) {
                        break;
                    }
                }
            }
        }
        GuavaCacheUtils.putCacheAi("get-case" + aiRequestVo.getCaseId(), caseInfoDtoList);
        return ReturnSucUtils.getRepInfo("请求成功", caseInfoDtoList);
    }

    @PostMapping("/get-law")
    public Object getLaw(@RequestBody AiRequestVo aiRequestVo) {
        return aiSimilarityCaseService.getCaseLaw(aiRequestVo);
    }

    @RequestMapping("/get-case-detail")
    public Object getCaseLawDetail(@RequestParam String caseId, @RequestParam int type) {
        CaseInfoDetailDto caseInfoDetailDto = new CaseInfoDetailDto();
        try {
            if (type == AiCaseType.AI_CASE_TYPE_DYH) {//表示纠纷类案件
                DyhCaseDetailDTO dyhCaseDetailDTO = knowledgeCaseClient.getCaseDetail(caseId);
                if (ObjectUtils.isNotEmpty(dyhCaseDetailDTO)) {
                    caseInfoDetailDto.setCaseId(dyhCaseDetailDTO.getId());
                    caseInfoDetailDto.setCaseTitle(
                        StringUtils.defaultIfBlank(dyhCaseDetailDTO.getCaseTitle(), ""));
                    caseInfoDetailDto.setCaseDesc(
                        StringUtils.defaultIfBlank(dyhCaseDetailDTO.getCaseDes(), ""));
                    caseInfoDetailDto.setAgreeContent(
                        StringUtils.defaultIfBlank(dyhCaseDetailDTO.getAgreeContent(), ""));
                    caseInfoDetailDto.setCaseClaim(
                        StringUtils.defaultIfBlank(dyhCaseDetailDTO.getCaseClaim(), ""));
                }
            } else {
                CpwsCaseText cpwsCaseText = knowledgeCaseClient.getCpwsCaseTextById(caseId);
                if (cpwsCaseText != null) {
                    caseInfoDetailDto.setCaseId(cpwsCaseText.getCpwsCaseTextId());
                    caseInfoDetailDto.setCaseTitle(
                        StringUtils.defaultIfBlank(cpwsCaseText.getBasicCaseInfo(), ""));
                    
                    // 拼接完整文本,处理可能为null的字段
                    List<String> textParts = new ArrayList<>();
                    if (StringUtils.isNotBlank(cpwsCaseText.getTrialProcess())) {
                        textParts.add(cpwsCaseText.getTrialProcess());
                    }
                    if (StringUtils.isNotBlank(cpwsCaseText.getBasicCaseInfo())) {
                        textParts.add(cpwsCaseText.getBasicCaseInfo());
                    }
                    if (StringUtils.isNotBlank(cpwsCaseText.getTrialFinding())) {
                        textParts.add(cpwsCaseText.getTrialFinding());
                    }
                    if (StringUtils.isNotBlank(cpwsCaseText.getJudgment())) {
                        textParts.add(cpwsCaseText.getJudgment());
                    }
                    if (StringUtils.isNotBlank(cpwsCaseText.getLegalBasis())) {
                        textParts.add(cpwsCaseText.getLegalBasis());
                    }
                    
                    String fullText = String.join("\n", textParts);
                    caseInfoDetailDto.setCaseDesc(fullText);
                    caseInfoDetailDto.setAgreeContent(
                        StringUtils.defaultIfBlank(cpwsCaseText.getJudgment(), ""));
                    caseInfoDetailDto.setLegalBasis(
                        StringUtils.defaultIfBlank(cpwsCaseText.getLegalBasis(), ""));
                }
            }
            return ReturnSucUtils.getRepInfo("处理成功", caseInfoDetailDto);
        } catch (Exception e) {
            log.error("获取案件详情失败：", e);
            return ReturnFailUtils.getRepInfo();
        }
    }

    @PostMapping("/get-clain-rise-case")
    public Object getClaimRiskByCase(@RequestBody AiRequestVo aiRequestVo) {
        Object cacheAi = GuavaCacheUtils.getCacheAi("get-clain-rise-case" + aiRequestVo.getCaseId());
        if (ObjectUtils.isNotEmpty(cacheAi)) {
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }
        CaseRiskDto caseRiskDto = new CaseRiskDto();
        Map<String, String> params = new HashMap<>();
        params.put("caseDes", aiRequestVo.getCaseDes());//案件描述
        params.put("caseClaim", aiRequestVo.getCaseClaim());//案件诉求
        params.put("caseId", aiRequestVo.getCaseId());//案件id
        String s = HttpClientUtils.httpPostForm(aiUrl + "/getClaimRiskByCase", params, new HashMap<>(), "utf-8");
        JSONObject object = JSONObject.parseObject(s);
        int code = object.getIntValue("code");
        if (code == 200) {
            JSONObject data = object.getJSONObject("data");
            caseRiskDto.setIsClaimRisk(data.getIntValue("is_claim_risk"));
            caseRiskDto.setAnalysisProcess(data.getString("analysis_process"));
        }
        GuavaCacheUtils.putCacheAi("get-clain-rise-case" + aiRequestVo.getCaseId(), caseRiskDto);
        return ReturnSucUtils.getRepInfo("请求成功", caseRiskDto);
    }

    @PostMapping("/get-case")
    public Object getSimilarityCase(@RequestBody AiRequestVo aiRequestVo) {
        return aiSimilarityCaseService.getSimilarityCase(aiRequestVo);
    }

    /**
     * 根据案件描述生成调解策略
     *
     * @return
     * @url {ctx}/api/ai/case-law/getMediateStrategy
     */
    @PostMapping("/getMediateStrategy")
    public Object getMediateStrategy(@RequestBody AiMediateStrategyVo aiMediateStrategyVo) {
        try {
            String caseText = aiMediateStrategyVo.getCaseText();
            return aiDifyService.getMediateStrategy(caseText);
        } catch (Exception e) {
            log.error("获取案件调解策略失败：{}", e.getMessage());
            return ReturnSucUtils.getRepInfo("获取调解策略失败", null);
        }
    }

    /**
     * 流式AI对话
     *
     * @return StreamingResponseBody 流式响应体
     * @url {ctx}/api/ai/case-law/streamChat
     */
    @PostMapping(value = "/streamChat", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
    public StreamingResponseBody streamChat(@RequestBody AiChatVo aiChatVo) {
        try {
            return aiDifyService.streamChat(
                aiChatVo.getCaseText(), 
                aiChatVo.getQuery(), 
                aiChatVo.getConversationId(),
                aiChatVo.getResponseMode()
            );
        } catch (Exception e) {
            log.error("AI流式对话失败：{}", e.getMessage(), e);
            return null;
        }
    }

    /**
     * 阻塞式AI对话，直接返回完整回答
     *
     * @return 包含AI回答和对话ID的对象
     * @url {ctx}/api/ai/case-law/blockingChat
     */
    @PostMapping("/blockingChat")
    public Object blockingChat(@RequestBody AiChatVo aiChatVo) {
        try {
            Map<String, Object> result = aiDifyService.blockingChat(
                aiChatVo.getCaseText(),
                aiChatVo.getQuery(),
                aiChatVo.getConversationId()
            );
            return ReturnSucUtils.getRepInfo("请求成功", result);
        } catch (Exception e) {
            log.error("AI阻塞式对话失败：{}", e.getMessage(), e);
            return ReturnSucUtils.getRepInfo("对话失败", null);
        }
    }

    /**
     * 阻塞式AI财产对话，直接返回完整回答
     *
     * @return 包含AI回答和对话ID的对象
     * @url {ctx}/api/ai/case-law/blockingPropertyChat
     */
    @PostMapping("/blockingPropertyChat")
    public Object blockingPropertyChat(@RequestBody AiPropertyChatVo aiPropertyChatVo) {
        try {
            Map<String, Object> result = aiDifyService.blockingPropertyChat(
                aiPropertyChatVo.getQuery(),
                aiPropertyChatVo.getConversationId(),
                aiPropertyChatVo.getCheckRationality()
            );
            return ReturnSucUtils.getRepInfo("请求成功", result);
        } catch (Exception e) {
            log.error("AI阻塞式财产对话失败：{}", e.getMessage(), e);
            return ReturnSucUtils.getRepInfo("对话失败", null);
        }
    }

}