package cn.huge.module.ai.controller;

import cn.huge.base.common.utils.*;
import cn.huge.module.ai.controller.domain.dto.CaseInfoDetailDto;
import cn.huge.module.ai.controller.domain.dto.CaseInfoDto;
import cn.huge.module.ai.controller.domain.dto.CaseRiskDto;
import cn.huge.module.ai.controller.domain.dto.LawInfoDto;
import cn.huge.module.ai.controller.domain.po.AiConversation;
import cn.huge.module.ai.controller.domain.po.AiMessage;
import cn.huge.module.ai.controller.domain.po.CaseSimilarityExplanatory;
import cn.huge.module.ai.controller.domain.vo.AiRequestVo;
import cn.huge.module.ai.controller.service.AiChatService;
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;

    @Autowired
    private AiChatService aiChatService;


    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);
        }
        return terms;
    }

    /**
     * 创建会话
     * @url {ctx}/api/ai/case-law/createAiChat
     * @param
     * @return Object
     */
    @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();
        }
    }

    /**
     * 获取智能会话列表
     * @url {ctx}/api/ai/case-law/queryAiChatList
     * @param
     * @return Object
     */
    @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();
        }
    }

    /**
     * 创建对话
     * @url {ctx}/api/ai/case-law/createAiChatMessage
     * @param
     * @return Object
     */
    @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;
        }
    }

    /**
     * 获取智能会话列表
     * @url {ctx}/api/ai/case-law/getAiChatMessageList
     * @return
     */
    @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();
        }
    }

    /**
     * 删除会话
     * @url {ctx}/api/ai/case-law/deleteConversation
     * @return
     */
    @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();
        }
    }

    /**
     * 获取案件总结
     * @url {ctx}/api/ai/case-law/getJudgmentSummarize
     * @return
     */
    @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();
        }
    }

    /**
     * 类案推荐评价
     * @url {ctx}/api/ai/case-law/setLikeStatus
     * @return
     */
    @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) {
        Object cacheAi = GuavaCacheUtils.getCacheAi("get-law"+aiRequestVo.getCaseId());
        if(ObjectUtils.isNotEmpty(cacheAi)){
            return ReturnSucUtils.getRepInfo("请求成功", cacheAi);
        }
        List<LawInfoDto> lawInfoDtos = new ArrayList<>();
        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 + "/queryLawProvision", 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);
                LawInfoDto lawInfoDto = new LawInfoDto();
                lawInfoDto.setLawInfoId(jsonObject.getString("law_info_id"));
                lawInfoDto.setLawIndex(jsonObject.getString("provision_index"));
                lawInfoDto.setLawDesc(jsonObject.getString("provision_text"));
                lawInfoDto.setLawTitle(jsonObject.getString("law_title"));
                lawInfoDtos.add(lawInfoDto);
            }
        }
        GuavaCacheUtils.putCacheAi("get-law"+aiRequestVo.getCaseId(), lawInfoDtos);
        return ReturnSucUtils.getRepInfo("请求成功", lawInfoDtos);
    }

    @RequestMapping("/get-case-detail")
    public Object getCaseLawDetail(@RequestParam String caseId, @RequestParam int type) {
        String s = "";
        CaseInfoDetailDto caseInfoDetailDto = new CaseInfoDetailDto();
        if (type == 1) {//表示纠纷类案件
            s = HttpClientUtils.httpGet(aiUrl + "/getConciliationCaseText?caseId=" + caseId, new HashMap<>(), "utf-8");
            JSONObject object = JSONObject.parseObject(s);
            int code = object.getIntValue("code");
            if (code == 200) {
                JSONObject data = object.getJSONObject("data");
                caseInfoDetailDto.setCaseId(data.getString("id"));
                caseInfoDetailDto.setCaseTitle(data.getString("case_title"));
                caseInfoDetailDto.setCaseDesc(data.getString("case_des"));
                caseInfoDetailDto.setCaseClaim(data.getString("case_claim"));
                caseInfoDetailDto.setAgreeContent(data.getString("agree_content"));
            }
        } else {
            s = HttpClientUtils.httpGet(aiUrl + "/getJudgmentCaseText?cpwsCaseInfoId=" + caseId, new HashMap<>(), "utf-8");
            JSONObject object = JSONObject.parseObject(s);
            int code = object.getIntValue("code");
            if (code == 200) {
                JSONObject data = object.getJSONObject("data");
                caseInfoDetailDto.setCaseId(data.getString("idcpws_case_info_id"));
                caseInfoDetailDto.setCaseTitle(data.getString("basic_case_info"));
                caseInfoDetailDto.setCaseDesc(data.getString("full_text"));
                caseInfoDetailDto.setAgreeContent(data.getString("judgment"));
                caseInfoDetailDto.setLegalBasis(data.getString("legal_basis"));
            }
        }
        return ReturnSucUtils.getRepInfo("请求成功", caseInfoDetailDto);
    }

    @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);
    }

}