package com.supervision.police.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.supervision.chat.client.LangChainChatService;
import com.supervision.chat.client.dto.chat.ChatReqDTO;
import com.supervision.chat.client.dto.chat.ChatResDTO;
import com.supervision.common.domain.R;
import com.supervision.constant.CaseAnalysisStatusEnum;
import com.supervision.police.domain.Conversation;
import com.supervision.police.domain.ConversationQa;
import com.supervision.police.domain.ModelCase;
import com.supervision.police.domain.ModelIndex;
import com.supervision.police.dto.AnalyseCaseDTO;
import com.supervision.police.dto.IndexDetail;
import com.supervision.police.dto.IndexResultQuery;
import com.supervision.police.service.*;
import com.supervision.police.vo.ChatReqVO;
import com.supervision.police.vo.ChatResVO;
import com.supervision.police.vo.ConversationResVo;
import com.supervision.police.vo.dify.DifyChatReqVO;
import com.supervision.police.vo.dify.DifyChatResVO;
import com.supervision.police.vo.dify.KnowledgeBaseSegmentVO;
import com.supervision.utils.DifyApiUtil;
import com.supervision.utils.UserUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

import static com.supervision.common.constant.DifyConstants.*;

@Slf4j
@Service
@RequiredArgsConstructor
public class ChatServiceImpl implements ChatService {

    private final LangChainChatService langChainChatService;
    private final ModelCaseService modelCaseService;
    private final ModelService modelService;
    private final ConversationService conversationService;
    private final ConversationQaService conversationQaService;
    private final ModelIndexService modelIndexService;
    private final DifyApiUtil difyApiUtil;
    private final NoteRecordService noteRecordService;


    @Override
    public ChatResVO chat(ChatReqVO chatReqVO) {


        Assert.notEmpty(chatReqVO.getQuery(), "query 不能为空");
        Assert.notEmpty(chatReqVO.getCaseId(), "caseId 不能为空");

        ModelCase modelCase = modelCaseService.getById(chatReqVO.getCaseId());
        Assert.notNull(modelCase, "案件不存在");

        log.info("chat: caseNo:{},query{}", modelCase.getCaseNo(), chatReqVO.getQuery());

        ChatResDTO chat = null;
        try {
            chat = langChainChatService.chat(
                    ChatReqDTO.create(chatReqVO.getQuery(), modelCase.getCaseNo(), chatReqVO.getHistory()));
        } catch (Exception e) {
            log.error("chat: caseNo:{},query{},error:{}", modelCase.getCaseNo(), chatReqVO.getQuery(), e.getMessage(), e);
            chat = new ChatResDTO();
            chat.setAnswer("服务繁忙，请稍后重试！");
        }

        if (null == chat) {
            chat = new ChatResDTO();
        }
        if (StrUtil.isEmpty(chat.getAnswer())) {
            chat.setAnswer("我暂时还不知道怎么回答，您可以尝试换一种问法！");
            chat.setDocs(new ArrayList<>(1));
        }

        log.info("chat: caseNo:{},query{},answer:{}", modelCase.getCaseNo(), chatReqVO.getQuery(), chat.getAnswer());

        return new ChatResVO(chat);
    }

    @Transactional(transactionManager = "dataSourceTransactionManager", rollbackFor = Exception.class)
    @Override
    public R<ChatResVO> chatNew(ChatReqVO chatReqVO) {
        ChatResVO chatResVO = new ChatResVO();
        Map<String, Object> answerMap = new HashMap<>();
        String query = chatReqVO.getQuery();
        String caseId = chatReqVO.getCaseId();
        String userId = UserUtil.getUser().getId();
        String type = chatReqVO.getType();
        String intentType = chatReqVO.getIntentType();
        long startTime = System.currentTimeMillis();
        if (StringUtils.isEmpty(chatReqVO.getConversationId())) {
            Conversation conversation = new Conversation();
            conversation.setId(UUID.randomUUID().toString());
            conversation.setCaseId(caseId);
            conversation.setUserId(userId);
            conversationService.save(conversation);
            chatReqVO.setConversationId(conversation.getId());
            log.info("会话已创建，conversationId:{}", conversation.getId());
        } else {
            Conversation conversation = conversationService.getById(chatReqVO.getConversationId());
            conversation.setUpdateTime(new Date());
            conversationService.updateById(conversation);
            log.info("会话已更新，conversationId:{}", conversation.getId());
        }
        List<ModelIndex> modelIndices = modelIndexService.list();
        switch (type) {
            case QA_TYPE_DIFY:
                if (modelIndices.stream().map(ModelIndex::getName).anyMatch(query::equals)) {
                    type = QA_TYPE_NX_LLM;
                    intentType = INTENT_TYPE_INDEX_RESULT;
                    handleIndexResultQA(modelIndices, query, caseId, answerMap);
                } else if (INTENT_TYPE_TEXT_CASE_RESULT.equals(query) || INTENT_TYPE_CASE_RESULT.equals(intentType)) {
                    type = QA_TYPE_NX_LLM;
                    intentType = INTENT_TYPE_CASE_RESULT;
                    ModelCase modelCase = modelCaseService.getById(caseId);
                    if (modelCase.getTotalScore() == null) {
                        log.info("案件【{}】尚未执行模型分析，现在开始执行", modelCase.getCaseName());
                        AnalyseCaseDTO analyseCaseDTO = new AnalyseCaseDTO();
                        analyseCaseDTO.setCaseId(caseId);
                        modelService.analyseCaseNew(analyseCaseDTO);
                    }
                    answerMap = JSON.parseObject(JSON.toJSONString(modelService.caseScoreDetail(caseId)), Map.class);
                } else if (INTENT_TYPE_TEXT_CASE_OVERVIEW.equals(query) || INTENT_TYPE_CASE_OVERVIEW.equals(intentType)) {
                    type = QA_TYPE_NX_LLM;
                    intentType = INTENT_TYPE_CASE_OVERVIEW;
                    answerMap.put("answerText", modelCaseService.getById(caseId).getCaseDetail());
                } else if (INTENT_TYPE_TEXT_CASE_EVIDENCE_GUIDE.equals(query) || INTENT_TYPE_CASE_EVIDENCE_GUIDE.equals(intentType)) {
                    type = QA_TYPE_NX_LLM;
                    intentType = INTENT_TYPE_CASE_EVIDENCE_GUIDE;
                    answerMap.put("guideDesc", modelService.caseScoreDetail(caseId).getGuideDesc());
                } else {
                    ModelCase modelCase = modelCaseService.getById(caseId);
                    DifyChatReqVO difyChatReqVO = new DifyChatReqVO();
                    difyChatReqVO.setUser(userId);
                    difyChatReqVO.setConversationId(chatReqVO.getConversationId());
                    difyChatReqVO.setQuery(query);
                    difyChatReqVO.setInputs(Map.of("dataset_id", modelCase.getKnowledgeBaseId(), "participator", modelCase.getLawActor()));
                    DifyChatResVO chat = difyApiUtil.chat(difyChatReqVO);
                    JSONObject json = JSON.parseObject(chat.getAnswer());
                    chatResVO.setAnswer(json.getString("answerText"));
                    chatResVO.setSegmentList(JSONArray.parseArray(json.getString("quote"), KnowledgeBaseSegmentVO.class));
                }
                break;
            case QA_TYPE_NX_LLM:
                switch (intentType) {
                    case INTENT_TYPE_INDEX_RESULT:
                        if (modelIndices.stream().map(ModelIndex::getName).anyMatch(query::equals)) {
                            handleIndexResultQA(modelIndices, query, caseId, answerMap);
                        } else {
                            answerMap.put("answerText", "暂无相关指标信息");
                        }
                        break;
                    case INTENT_TYPE_CASE_RESULT:
                        ModelCase modelCase = modelCaseService.getById(caseId);
                        if (modelCase.getTotalScore() == null) {
                            log.info("案件【{}】尚未执行模型分析，现在开始执行", modelCase.getCaseName());
                            AnalyseCaseDTO analyseCaseDTO = new AnalyseCaseDTO();
                            analyseCaseDTO.setCaseId(caseId);
                            modelService.analyseCaseNew(analyseCaseDTO);
                        }
                        answerMap = JSON.parseObject(JSON.toJSONString(modelService.caseScoreDetail(caseId)), Map.class);
                        break;
                    case INTENT_TYPE_CASE_OVERVIEW:
                        answerMap.put("answerText", modelCaseService.getById(caseId).getCaseDetail());
                        break;
                    case INTENT_TYPE_CASE_EVIDENCE_GUIDE:
                        answerMap.put("guideDesc", modelService.caseScoreDetail(caseId).getGuideDesc());
                        break;
                    default:
                        break;
                }
                break;
            default:
                break;
        }
        if (StringUtils.isEmpty(chatResVO.getAnswer()) && "{}".equals(JSON.toJSONString(answerMap))) {
            log.error("chatNew: 未找到答案，query:【{}】", query);
            return R.fail("未找到答案");
        }
        long end = System.currentTimeMillis();
        ConversationQa qa = new ConversationQa();
        qa.setId(UUID.randomUUID().toString());
        qa.setQuestion(query);
        qa.setQuestionTime(new Date(startTime));
        qa.setAnswer(chatResVO.getAnswer());
        qa.setAnswerMap(JSON.toJSONString(answerMap));
        qa.setSegmentList(chatResVO.getSegmentList());
        qa.setAnswerTime(new Date(end));
        qa.setType(type);
        qa.setIntentType(intentType);
        qa.setTimeInterval(String.valueOf(end - startTime));
        qa.setCaseId(caseId);
        qa.setUserId(userId);
        qa.setConversationId(chatReqVO.getConversationId());
        conversationQaService.save(qa);
        log.info("QA已保存，qaId:【{}】，question：【{}】，answer：【{}】", qa.getId(), query, JSON.toJSONString(answerMap));
        chatResVO.setAnswwerMap(answerMap);
        chatResVO.setType(type);
        chatResVO.setIntentType(intentType);
        chatResVO.setConversationId(chatReqVO.getConversationId());
        return R.ok(chatResVO);
    }

    @Override
    public IPage<ChatResVO> queryConversationInfoList(String conversationId, int page, int size) {
        Assert.notEmpty(conversationId, "会话id不能为空");

        IPage<ConversationQa> qaPage = conversationQaService.lambdaQuery().eq(ConversationQa::getConversationId, conversationId)
                .orderBy(true, true, ConversationQa::getQuestionTime).page(Page.of(page, size));

        return qaPage.convert(ChatResVO::new);
    }

    @Override
    public IPage<ConversationResVo> queryUserConversationList(String userId, int page, int size) {
        Assert.notEmpty(userId, "用户id不能为空");

        return conversationService.queryUserConversationList(userId, DateUtil.offsetDay(DateUtil.date(), -180), null, new Page<>(page, size));
    }

    @Override
    @Transactional(rollbackFor = Exception.class, transactionManager = "dataSourceTransactionManager")
    public void deleteConversation(List<String> conversationIdList) {
        if (CollUtil.isEmpty(conversationIdList)) {
            return;
        }
        for (String conversationId : conversationIdList) {
            boolean success = conversationService.removeById(conversationId);
            if (success) {
                conversationQaService.lambdaUpdate().eq(ConversationQa::getConversationId, conversationId).remove();
            }
        }
    }

    /**
     * 处理指标结果问答
     *
     * @param modelIndices 指标列表
     * @param query        问题
     * @param caseId       案件id
     * @param answerMap    答案map
     */
    private void handleIndexResultQA(List<ModelIndex> modelIndices, String query, String caseId, Map<String, Object> answerMap) {
        //如果案件分析状态不是分析成功，则先执行案件分析
        ModelCase modelCase = modelCaseService.getById(caseId);
        ModelIndex modelIndex = modelIndices.stream().filter(index -> query.contains(index.getName())).findFirst().get();
        IndexResultQuery indexResultQuery = new IndexResultQuery();
        indexResultQuery.setCaseId(caseId);
        indexResultQuery.setIndexType(modelIndex.getIndexType());
        indexResultQuery.setIndexName(modelIndex.getName());
        IPage<IndexDetail> indexDetailPage = modelCaseService.getIndexDetail(indexResultQuery, 1, 1);
        if (indexDetailPage.getRecords().isEmpty() || (modelCase.getTotalScore() == null && modelCase.getCaseAnalysisStatus() != CaseAnalysisStatusEnum.ANALYZED.getCode())) {
            log.info("案件【{}】尚未执行模型分析，现在开始执行", modelCase.getCaseName());
            AnalyseCaseDTO analyseCaseDTO = new AnalyseCaseDTO();
            analyseCaseDTO.setCaseId(caseId);
            modelService.analyseCaseNew(analyseCaseDTO);
        }
        indexDetailPage = modelCaseService.getIndexDetail(indexResultQuery, 1, 1);
        if (!indexDetailPage.getRecords().isEmpty()) {
            IndexDetail indexDetail = indexDetailPage.getRecords().get(0);
            answerMap.put("indexName", modelIndex.getName());
            answerMap.put("indexType", modelIndex.getIndexType());
            answerMap.put("result", Boolean.parseBoolean(indexDetail.getIndexResult()) ? "符合" : "不符合");
            List<Map<String, String>> qaSplitList = new ArrayList<>();
            if (!indexDetail.getChildren().isEmpty()) {
                indexDetail.getChildren().forEach(atomicIndexDTO -> {
                    if (!atomicIndexDTO.getRecordSegmentationList().isEmpty()) {
                        atomicIndexDTO.getRecordSegmentationList().forEach(split -> {
                            Map<String, String> qaMap = new HashMap<>();
                            qaMap.put("question", split.getQuestion());
                            qaMap.put("answer", split.getAnswer());
                            qaMap.put("noteRecordId", split.getNoteRecordId());
                            qaMap.put("splitId", split.getId());
                            qaMap.put("noteName", split.getNoteName());
                            qaMap.put("noteFileId", split.getNoteFileId());
                            qaSplitList.add(qaMap);
                        });
                    }
                });
            }
            answerMap.put("qaSplitList", qaSplitList);
            List<Map<String, String>> evidenceList = new ArrayList<>();
            if (!indexDetail.getChildren().isEmpty()) {
                indexDetail.getChildren().forEach(atomicIndexDTO -> {
                    if (!atomicIndexDTO.getEvidentResultList().isEmpty()) {
                        atomicIndexDTO.getEvidentResultList().forEach(evidentIndexResultDTO -> {
                            Map<String, String> evidenceMap = new HashMap<>();
                            evidenceMap.put("evidenceName", evidentIndexResultDTO.getEvidenceName());
                            evidenceMap.put("evidenceId", evidentIndexResultDTO.getEvidenceId());
                            evidenceList.add(evidenceMap);
                        });
                    }
                });
            }
            answerMap.put("evidenceNames", evidenceList);
        }
    }
}