let chatBox = document.getElementById('aiChatBox');
let chatMessages = document.getElementById('chatMessages');
let chatInput = document.getElementById('chatInput');
let datajson = VG.datajson; //本地知识库路径
let welcome_str = VG.welcome_str
let logo_local = VG.logo_local
let nickname = VG.nickname
let textareaContent = VG.textareaContent

// 防止消息重复发送的标志
let isProcessingMessage = false;

if(welcome_str){
    setTimeout(function () {
        appendMessage(welcome_str, false, 'welcome');
    }, 100);
}
function toggleChat() {
    chatBox.classList.toggle('active');
    if (chatBox.classList.contains('active')) {
        setTimeout(() => {
            document.getElementById('chatInput').focus();
        }, 100);
    }
}
let isWaiting = false;
function appendMessage(content, isUser = false, type = '') {
    let msgDiv = document.createElement('div');
    msgDiv.className = isUser ? 'chat-message user' : 'chat-message ai';
    // 获取当前时间
    const now = new Date();
    const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
    msgDiv.innerHTML = `
    <div class="message-wrapper">
        <div class="pc-service-left">
            ${isUser ? '' : '<img src="'+VG.logo_local+'" alt="">'}
        </div>
        <div class="pc-service-right message-box ${isUser ? 'tr' : 'tl'}">
            <div class="message-info">
                <span class="nickname">${isUser ? '我' : VG.nickname}</span>
                <span class="time" ${type == 'welcome' ? 'style="display: none;"' : ''}>${timeStr}</span>
            </div>
            <div class="message-content">${processMessageContent(content)}</div>
        </div>
        <div class="clear"></div>
    </div>`;
    chatMessages.appendChild(msgDiv);
    // 修改滚动逻辑
    const chatBody = document.getElementById('chatBody');
    setTimeout(() => {
        chatBody.scrollTop = chatBody.scrollHeight;
        chatMessages.scrollTop = chatMessages.scrollHeight;
    }, 100);
}
// 添加处理消息内容的函数
function processMessageContent(content) {
    // 使用正则表达式匹配 <img> 标签
    return content.replace(/<img(.*?)>/g, '<img$1 class="ai-zoomable" onclick="zoomImage(this)">');
}

// 添加图片缩放功能
function zoomImage(img) {
    const overlay = document.createElement('div');
    overlay.className = 'ai-image-overlay';
    overlay.onclick = function() {
        document.body.removeChild(this);
    };
    const zoomedImg = document.createElement('img');
    zoomedImg.src = img.src;
    zoomedImg.className = 'ai-zoomed-image';
    overlay.appendChild(zoomedImg);
    document.body.appendChild(overlay);
}
function removeTypingIndicator() {
    const typingIndicator = document.querySelector('.chat-message.ai:last-child');
    if (typingIndicator && typingIndicator.querySelector('.typing-indicator')) {
        typingIndicator.remove();
    }
    isWaiting = true;
}
// 修改 sendMessage 函数中的相关部分
async function sendMessage(frm, txt, typename) {
    try {
        // 防止重复发送
        if (isProcessingMessage) {
            return;
        }
        isProcessingMessage = true;
        
        var message = '';
        var typename = '';
        if (frm == 1) {
            message = chatInput.value.trim();
        } else {
            message = txt
        }
        if (!message) {
            isProcessingMessage = false;
            return;
        }
        // 显示等待动画
        const typingIndicator = document.createElement('div');
        typingIndicator.className = 'chat-message ai';
        typingIndicator.innerHTML = `
            <div class="message-wrapper">
                <div class="pc-service-left">
                    <img src="`+VG.logo_local+`" alt="">
                </div>
                <div class="pc-service-right message-box tl">
                    <div class="typing-indicator">
                        <span></span><span></span><span></span>
                    </div>
                </div>
                <div class="clear"></div>
            </div>`;
        chatInput.value = '';
        //记得每次对话start
        // 记录对话的函数
        const recordChat = async (question, answer, type = '', score = 0) => {
            try {
                await fetch(VG.recordChatUrl, {
                    method: 'POST',
                    headers: {
                        'Content-Type': 'application/json',
                    },
                    body: JSON.stringify({
                        question: question,
                        answer: answer,
                        type: type,
                        score: score
                    })
                });
            } catch (error) {
                console.error('记录对话失败:', error);
            }
        };
        // end
        
        const knowledgeResponse = await fetch(datajson);
        if (!knowledgeResponse.ok) {
            appendMessage('抱歉，知识库加载失败。');
            isProcessingMessage = false;
            return false;
            //throw new Error(`知识库加载失败: ${knowledgeResponse.status}`);
        }
        const knowledge = await knowledgeResponse.json();
        const keywords = splitKeywords(message);
        // 搜索知识库并计算相关度评分
        // 先进行精确匹配
        let bestMatch = {
            score: 0,
            answer: null
        };
        let isGreeting = false;
        if (!isGreeting) {
            appendMessage(message, true);
        }
        // ... existing code ...
        chatMessages.appendChild(typingIndicator);
        chatBody.scrollTop = chatBody.scrollHeight;
        // 获取问题类型
        const questionType = typename || '';
        let matches = []; // 存储所有匹配的结果
        if (questionType) {
            // 在指定类型中查找完全匹配
            let exactMatch = knowledge[questionType]?.find(qa => qa.问.trim() === message.trim());
            if (exactMatch) {
                bestMatch.score = 1;
                bestMatch.answer = exactMatch.答;
            } else {
                // 搜索指定类型的问题
                knowledge[questionType]?.forEach(qa => {
                    const score = calculateMatchScore(qa.问, keywords);
                    if (score >= 0.3) { // 相关度阈值
                        matches.push({
                            question: qa.问,
                            answer: qa.答,
                            score: score
                        });
                    }
                });
            }
        } else {
            Object.keys(knowledge).forEach(type => {
                // 先查找完全匹配
                let exactMatch = knowledge[type].find(qa => qa.问.trim() === message.trim());
                if (exactMatch) {
                    bestMatch.score = 1;
                    bestMatch.answer = exactMatch.答;
                    return; // 找到完全匹配就退出
                }
                knowledge[type].forEach(qa => {
                    let score = 0;
                    if (qa.关键字) {
                        const keywordArray = typeof qa.关键字 === 'string' ? qa.关键字.split('|') : qa.关键字;
                        if (keywordArray.length > 0) {
                            const keywordMatches = keywordArray.filter(k => message.includes(k.trim()));
                            if (keywordMatches.length > 0) {
                                score = 0.5 + (keywordMatches.length / keywordArray.length * 0.5);
                            }
                        }
                    }
                    if (score < 0.3) {
                        score = calculateMatchScore(qa.问, keywords);
                    }
                    if (score >= 0.3) {
                        matches.push({
                            question: qa.问,
                            answer: qa.答,
                            keywords: qa.关键字,
                            score: score
                        });
                    }
                });
            });
        }
        // 如果有完全匹配，直接使用
        if (bestMatch.score === 1) {
            setTimeout(() => {
                removeTypingIndicator();
                appendMessage(bestMatch.answer);
                recordChat(message, bestMatch.answer, '完全匹配', 1);
                isProcessingMessage = false; // 重置处理标志
            }, 1000);
            return;
        }
        // 如果有多个匹配结果
        if (matches.length > 0) {
            // 按相关度排序
            matches.sort((a, b) => b.score - a.score);
            // 如果只有一条匹配结果，直接显示答案
            if (matches.length === 1) {
                setTimeout(() => {
                    removeTypingIndicator();
                    appendMessage(matches[0].answer);
                    recordChat(message, matches[0].answer, '相关匹配', matches[0].score);
                    isProcessingMessage = false; // 重置处理标志
                }, 1000);
                return;
            }
            // 如果有多条匹配结果，显示问题列表
            let responseHtml = '<p>找到以下相关问题：</p><ul>';
            matches.forEach((match, index) => {
                responseHtml += `<li><a href="javascript:void(0)" onclick="sendMessage(2,'${match.question}')">${index + 1}. ${match.question}</a></li>`;
            });
            responseHtml += '</ul><p>请点击相关问题或重新描述您的问题。</p>';
            setTimeout(() => {
                removeTypingIndicator();
                appendMessage(responseHtml);
                recordChat(message, responseHtml, '相关推荐', matches[0].score);
                isProcessingMessage = false; // 重置处理标志
            }, 1000);
            return;
        }
        const eventSource = new EventSource(VG.ai_url+'&text=' + encodeURIComponent(message));
        let isFirstMessage = true;
        let newcontent = '';
        let currentMessageDiv = null;
        eventSource.onmessage = function(e) {
            try {
                const data = JSON.parse(e.data);
                if (isFirstMessage && data.code ==1) {
                    removeTypingIndicator();
                    // 创建新的消息div
                    currentMessageDiv = document.createElement('div');
                    currentMessageDiv.className = 'chat-message ai';
                    const now = new Date();
                    const timeStr = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
                    currentMessageDiv.innerHTML = `
                        <div class="message-wrapper">
                            <div class="pc-service-left">
                                <img src="${VG.logo_local}" alt="">
                            </div>
                            <div class="pc-service-right message-box tl">
                                <div class="message-info">
                                    <span class="nickname">${VG.nickname}</span>
                                    <span class="time">${timeStr}</span>
                                </div>
                                <div class="message-content"></div>
                                <div class="ai-disclaimer" style="font-size: 12px; color: #999; margin-top: 5px;">
                                    本回答由AI生成，内容仅供参考，请仔细甄别。
                                </div>
                            </div>
                            <div class="clear"></div>
                        </div>`;
                    chatMessages.appendChild(currentMessageDiv);
                    isFirstMessage = false;
                }
                if(data.code!=1){
                    removeTypingIndicator();
                    var nodata = VG.nodata;
                    appendMessage(nodata);
                    isProcessingMessage = false; // 重置处理标志
                    return false;
                }
                newcontent += data.content;
                // 更新现有消息的内容
                const messageContent = currentMessageDiv.querySelector('.message-content');
                messageContent.innerHTML = newcontent;
                // 滚动到底部
                const chatBody = document.getElementById('chatBody');
                chatBody.scrollTop = chatBody.scrollHeight;
                chatMessages.scrollTop = chatMessages.scrollHeight;
            } catch (err) {
                console.log('解析错误:', err);
                isProcessingMessage = false; // 出错时重置处理标志
            }
        };
        eventSource.onerror = function(err) {
            eventSource.close();
            isFirstMessage = true; // 重置状态
            if (newcontent) {
                recordChat(message, newcontent, 'Ai联网作答', '0.5');
            }
            isProcessingMessage = false; // 重置处理标志
        };
        // 如果知识库中没有匹配的内容,则调用DeepSeek API
        // const response = await fetch(VG.ai_url, {
        //     method: 'POST',
        //     headers: {
        //         'Content-Type': 'application/json',
        //     },
        //     body: JSON.stringify({
        //         messages: message
        //     })
        // });
        // const data = await response.json();
        // removeTypingIndicator();
        // if(data.code==1){
        //     appendMessage(data.data);
        //     recordChat(message, data.data, 'API回答', 1);
        // }else{
        //     appendMessage(data.msg);
        //     recordChat(message, data.msg, 'API错误', 0);
        // }
    } catch (error) {
        console.error('发生错误:', error);
        removeTypingIndicator();
        var nodata = VG.nodata;
        appendMessage(nodata);
        recordChat(message,nodata, 'API错误', 0);
        isProcessingMessage = false;
    }
}
// 分词函数
function splitKeywords(text) {
    let keysCode = [];
    try {
        keysCode = Array.isArray(VG.keysCode) ? VG.keysCode : 
                   (typeof VG.keysCode === 'string' ? VG.keysCode.split(',') : []);
    } catch (error) {
        console.warn('关键词列表解析失败，使用默认列表');
    }
    text = text.replace(/[.,?!，。？！]/g, ' ');
    const keywords = keysCode.filter(keyword => 
        keyword && typeof keyword === 'string' && text.includes(keyword.trim())
    );
    if (keywords.length === 0) {
        return text.split(/\s+/).filter(word => word.length > 1);
    }
    return keywords;
}
// 计算相关度评分
function calculateMatchScore(text, keywords) {
    if (!keywords.length) return 0;
    let matchCount = 0;
    keywords.forEach(keyword => {
        if (text.includes(keyword)) {
            matchCount++;
        }
    });
    // 计算相关度得分 (0-1之间)
    return matchCount / Math.max(keywords.length, text.split(/\s+/).length);
}
// 按回车发送消息
chatInput.addEventListener('keypress', (e) => {
    if (e.key === 'Enter') {
        event.preventDefault();
        sendMessage(1, 'hello','');
    }
});
// 初始化知识库索引
async function initKnowledgeBase() {
    if (knowledgeCache) return knowledgeCache;
    const response = await fetch(datajson);
    if (!response.ok) throw new Error(`知识库加载失败: ${response.status}`);

    const knowledge = await response.json();
    knowledgeCache = knowledge;
    // 建立倒排索引
    Object.keys(knowledge).forEach(category => {
        knowledge[category].forEach(qa => {
            // 如果关键词为空，从问题中提取关键词
            const keywords = qa.关键词?.length ? qa.关键词 : 
                        qa.问.split(/[\s,.!?，。？！]/).filter(word => word.length > 1);
            const words = [...new Set([
                ...qa.问.toLowerCase().split(/[\s,.!?，。？！]/),
                ...keywords
            ])];
            words.forEach(word => {
                if (word.length > 1) {
                    if (!invertedIndex[word]) {
                        invertedIndex[word] = [];
                    }
                    invertedIndex[word].push({
                        category,
                        question: qa.问,
                        answer: qa.答,
                        keywords: keywords // 使用处理后的关键词
                    });
                }
            });
        });
    });
    return knowledge;
}
// 改进的相关度评分算法
function calculateRelevanceScore(userInput, qaItem) {
    const input = userInput.toLowerCase();
    const question = qaItem.question.toLowerCase();
    const keywords = qaItem.keywords || [];
    let score = 0;
    // 完全匹配检查
    if (input === question) return 1;
    // 关键词匹配权重
    if (keywords.length > 0) {
        keywords.forEach(keyword => {
            if (input.includes(keyword.toLowerCase())) {
                score += 0.3;
            }
        });
    } else {
        // 如果没有关键词，增加问题文本匹配的权重
        score += (input.includes(question) || question.includes(input)) ? 0.5 : 0;
    }
    // 问题文本相似度
    const inputWords = input.split(/[\s,.!?，。？！]/);
    const questionWords = question.split(/[\s,.!?，。？！]/);
    const commonWords = inputWords.filter(word => 
        questionWords.includes(word) && word.length > 1
    );
    score += (commonWords.length / Math.max(inputWords.length, questionWords.length)) * 0.7;
    return Math.min(score, 1);
}

document.addEventListener('click', function(e) {
    const title = e.target.closest('.faq-title');
    const subItem = e.target.closest('.sub-item');
    if (title) {
        const allItems = document.querySelectorAll('.faq-item');
        allItems.forEach(item => {
            if (item !== title.parentElement) {
                item.classList.remove('active');
            }
        });
        title.parentElement.classList.toggle('active');
        const titleText = title.textContent.trim();
    }
    if (subItem) {
        const subItemText = subItem.textContent.trim().replace(/^\d+\.\s*/, '');
        const subItemName = subItem.getAttribute('data-name');
        sendMessage(2, subItemText,subItemName);
    }
});

function newWin_ai_helper(url, id) {
    var a = document.createElement("a");
    a.setAttribute("href", url);
    a.setAttribute("target", "_blank");
    a.setAttribute("id", id);
    // 防止反复添加
    if(!document.getElementById(id)) {
        document.body.appendChild(a);
    }
    a.click();
}