// 会话管理模块
import {getCurrentSessionId} from './dom-utils.js';
import {customAlert, customConfirm} from './modal.js';
import {highlightCodeBlocks} from './highlight.js';
import {scrollToBottom} from './dom-utils.js';

let pendingSessionElement = null;

export function getPendingSessionElement() {
    return pendingSessionElement;
}

export async function createNewSession(sessionList, sessionSidebar, sidebarOverlay, switchSession) {
    const existingPending = document.querySelector('.session-item.pending');
    if (existingPending) {
        await customAlert('已有待创建的新会话，请先发送消息完成创建', '提示');
        document.querySelectorAll('.session-item').forEach(item => item.classList.remove('active'));
        existingPending.classList.add('active');
        return;
    }

    try {
        // 尝试切换到空会话，但不阻止创建临时会话项（即使失败也继续）
        try {
            await switchSession('');
        } catch (err) {
            console.warn('切换空会话时出错，但继续创建新会话:', err);
        }

        document.querySelectorAll('.session-item').forEach(item => item.classList.remove('active'));

        const tempSessionId = 'temp_' + Date.now();
        const tempSession = document.createElement('div');
        tempSession.className = 'session-item pending active';
        tempSession.dataset.sessionId = tempSessionId;
        tempSession.dataset.isNewSession = 'true';
        tempSession.innerHTML = `
            <div class="session-info">
                <div class="session-name">新建会话...</div>
                <div class="session-meta">
                    <span class="session-time">${new Date().toLocaleString('zh-CN', {
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
        })}</span>
                    <span class="session-count">0 条</span>
                </div>
            </div>
        `;
        tempSession.querySelector('.session-info').addEventListener('click', async () => {
            if (tempSession.dataset.isNewSession === 'true') {
                const currentId = getCurrentSessionId() || '';
                if (currentId !== '') {
                    try {
                        await switchSession('');
                        document.querySelectorAll('.session-item').forEach(i => i.classList.remove('active'));
                        tempSession.classList.add('active');
                    } catch (err) {
                        console.warn('切换回新会话时出错:', err);
                    }
                }
            }
        });

        if (sessionList) {
            sessionList.insertBefore(tempSession, sessionList.firstChild);
        }
        pendingSessionElement = tempSession;

        // 确保 currentSessionId 隐藏域被清空
        const currentSessionIdEl = document.getElementById('currentSessionId');
        if (currentSessionIdEl) {
            currentSessionIdEl.value = '';
        }

        if (window.innerWidth <= 600) {
            sessionSidebar.classList.remove('show');
            if (sidebarOverlay) sidebarOverlay.classList.remove('show');
        }

    } catch (err) {
        console.error('❌ 创建会话异常:', err);
        await customAlert('创建新会话失败，请重试');
    }
}

export async function deleteSession(sessionId, switchSessionCallback, refreshSessionListCallback) {
    if (!await customConfirm('确定要删除这个会话吗？')) {
        return;
    }
    try {
        const res = await fetch(`/AiChat/DeleteSession?sessionId=${encodeURIComponent(sessionId)}`, {method: 'DELETE'});
        const result = await res.json();
        if (result.success) {
            const isCurrent = (sessionId === getCurrentSessionId());

            // 调用刷新会话列表的回调（传递所有必要的参数）
            if (refreshSessionListCallback && typeof refreshSessionListCallback === 'function') {
                if (refreshSessionListCallback.length === 0) {
                    await refreshSessionListCallback();
                } else {
                    await refreshSessionListCallback();
                }
            }

            if (isCurrent) {
                const first = document.querySelector('.session-item');
                if (first && first.dataset.sessionId) {
                    const firstSessionId = first.dataset.sessionId;
                    // switchSessionCallback 是一个包装函数，只需要传递 sessionId
                    if (switchSessionCallback && typeof switchSessionCallback === 'function') {
                        await switchSessionCallback(firstSessionId);
                    }
                } else {
                    // 如果没有其他会话，创建新会话
                    await createNewSession(
                        document.getElementById('sessionList'),
                        document.getElementById('sessionSidebar'),
                        document.getElementById('sidebarOverlay'),
                        switchSessionCallback
                    );
                }
            }
        } else {
            await customAlert(result["msg"] || result.message || '删除失败');
        }
    } catch (err) {
        console.error('删除会话失败:', err);
        await customAlert('删除失败: ' + (err.message || err));
    }
}

export async function switchSession(sessionId, chatMain, updateDomReferences, bindChatEvents, setConnectionStatus, isConnected, updateInputState) {
    // 确保参数有效
    if (!chatMain) {
        chatMain = document.getElementById('chatMain');
    }
    if (!updateDomReferences || typeof updateDomReferences !== 'function') {
        console.error('switchSession: updateDomReferences 参数无效');
        await customAlert('切换会话失败：参数错误');
        return;
    }
    if (!bindChatEvents || typeof bindChatEvents !== 'function') {
        console.error('switchSession: bindChatEvents 参数无效');
        await customAlert('切换会话失败：参数错误');
        return;
    }

    const currentSessionId = getCurrentSessionId();
    // 处理空字符串的情况：如果都是空字符串，也认为是相同会话
    const normalizedSessionId = sessionId || '';
    const normalizedCurrentId = currentSessionId || '';

    if (normalizedSessionId === normalizedCurrentId) {
        console.log('⚠️ 已经在当前会话中，无需切换');
        if (window.innerWidth <= 600) {
            const sessionSidebar = document.getElementById('sessionSidebar');
            const sidebarOverlay = document.getElementById('sidebarOverlay');
            if (sessionSidebar) sessionSidebar.classList.remove('show');
            if (sidebarOverlay) sidebarOverlay.classList.remove('show');
        }
        return;
    }

    console.log('🔄 切换会话:', normalizedSessionId || '(新会话)');

    try {
        const res = await fetch(`/AiChat/ChatMessages?sessionId=${encodeURIComponent(normalizedSessionId)}`);
        if (!res.ok) {
            const errorText = await res.text().catch(() => '');
            console.error('切换会话请求失败:', res.status, errorText);
            // 如果是创建新会话（空 sessionId），允许继续，不显示错误
            if (normalizedSessionId === '') {
                console.warn('新会话请求失败，但允许继续创建临时会话');
                return;
            } else {
                await customAlert(`切换会话失败: ${res.status} ${res.statusText}`);
                return;
            }
        }

        const html = await res.text();

        if (chatMain) {
            chatMain.innerHTML = html;

            // 使用传入的 updateDomReferences 函数获取 DOM 引用
            const domRefs = updateDomReferences && typeof updateDomReferences === 'function'
                ? updateDomReferences()
                : null;

            if (!domRefs) {
                console.error('无法获取 DOM 引用');
                await customAlert('切换会话失败：无法获取 DOM 元素');
                return;
            }

            // 确保参数有效
            if (bindChatEvents && typeof bindChatEvents === 'function') {
                bindChatEvents(domRefs);
            }

            if (domRefs.statusEl && setConnectionStatus && typeof setConnectionStatus === 'function') {
                const connectionStatus = typeof isConnected === 'function' ? isConnected() : isConnected;
                // 创建一个更新输入状态的函数，使用当前的 domRefs
                const updateInputStateForSwitch = () => {
                    if (updateInputState && typeof updateInputState === 'function') {
                        updateInputState(domRefs);
                    }
                };
                setConnectionStatus(connectionStatus, domRefs.statusEl, updateInputStateForSwitch);
            } else if (updateInputState && typeof updateInputState === 'function') {
                // 即使没有 statusEl，也要更新输入状态
                updateInputState(domRefs);
            }

            if (domRefs.chatArea) {
                highlightCodeBlocks(domRefs.chatArea).catch(err => {
                    console.warn('代码高亮失败:', err);
                });
                scrollToBottom(domRefs.chatArea);
            }
        }

        // 更新会话列表的选中状态（包括空会话的情况）
        if (normalizedSessionId === '') {
            // 对于新会话，清除所有选中状态
            document.querySelectorAll('.session-item').forEach(item => {
                item.classList.remove('active');
            });
        } else {
            document.querySelectorAll('.session-item').forEach(item => {
                item.classList.toggle('active', item.dataset.sessionId === normalizedSessionId);
            });
        }

    } catch (err) {
        console.error('切换会话失败:', err);
        // 如果是创建新会话（空 sessionId），允许继续，不显示错误
        if (normalizedSessionId === '') {
            console.warn('新会话切换失败，但允许继续创建临时会话:', err);
        } else {
            await customAlert(`切换会话失败: ${err.message || err}`);
        }
    }

    if (window.innerWidth <= 600) {
        const sessionSidebar = document.getElementById('sessionSidebar');
        const sidebarOverlay = document.getElementById('sidebarOverlay');
        if (sessionSidebar) sessionSidebar.classList.remove('show');
        if (sidebarOverlay) sidebarOverlay.classList.remove('show');
    }
}

export async function refreshSessionList(switchSessionCallback, updateDomReferencesCallback, bindChatEventsCallback, setConnectionStatusCallback, getIsConnectedCallback, updateInputStateCallback) {
    try {
        const response = await fetch('/AiChat/Sessions');
        const result = await response.json();
        if (result.success && result.data) {
            renderSessionList(result.data, switchSessionCallback, updateDomReferencesCallback, bindChatEventsCallback, setConnectionStatusCallback, getIsConnectedCallback, updateInputStateCallback);
        }
    } catch (err) {
        console.error('刷新会话列表失败:', err);
    }
}

/**
 * 更新会话元素的辅助函数
 */
function applySessionUpdate(element, sessionId, name, time, count, switchSessionCallback, refreshSessionListCallback) {
    const nameEl = element.querySelector('.session-name');
    const timeEl = element.querySelector('.session-time');
    const countEl = element.querySelector('.session-count');
    
    if (nameEl) {
        nameEl.textContent = name;
        nameEl.title = name;
        nameEl.style.fontStyle = 'normal';
    }
    if (timeEl && time) {
        timeEl.textContent = new Date(time).toLocaleString('zh-CN', {
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
        });
    }
    if (countEl && count !== undefined) {
        countEl.textContent = `${count} 条`;
    }
    
    element.classList.remove('pending');
    
    // 更新点击事件
    const sessionInfo = element.querySelector('.session-info');
    if (sessionInfo) {
        const newSessionInfo = sessionInfo.cloneNode(true);
        sessionInfo.parentNode.replaceChild(newSessionInfo, sessionInfo);
        newSessionInfo.addEventListener('click', async () => {
            if (switchSessionCallback && typeof switchSessionCallback === 'function') {
                await switchSessionCallback(sessionId);
            }
        });
    }
    
    // 确保有删除按钮
    if (!element.querySelector('.btn-delete-session')) {
        const btn = document.createElement('button');
        btn.className = 'btn-delete-session';
        btn.textContent = '🗑️';
        btn.title = '删除会话';
        btn.onclick = async (e) => {
            e.stopPropagation();
            await deleteSession(sessionId, switchSessionCallback, refreshSessionListCallback);
        };
        element.appendChild(btn);
    }
}

/**
 * 更新指定会话的标题
 * @param {string} sessionId - 会话ID
 * @param {Function} switchSessionCallback - 切换会话的回调
 * @param {Function} refreshSessionListCallback - 刷新会话列表的回调（可选）
 * @param {string} [sessionName] - 会话名称（可选，如果有则直接更新不请求接口）
 */
export async function updateSessionTitle(sessionId, switchSessionCallback, refreshSessionListCallback, sessionName) {
    if (!sessionId || !pendingSessionElement) {
        return false;
    }
    
    // 如果 pending 元素的 sessionId 不匹配，说明不是要更新的会话
    if (pendingSessionElement.dataset.sessionId !== sessionId) {
        return false;
    }
    
    if (sessionName) {
        console.log('✅ 使用 SignalR 提供的会话名称更新:', sessionId, sessionName);
        applySessionUpdate(
            pendingSessionElement,
            sessionId,
            sessionName,
            new Date(),
            2,
            switchSessionCallback,
            refreshSessionListCallback
        );
        return true;
    }

    try {
        // 获取会话列表，查找对应的会话
        const response = await fetch('/AiChat/Sessions');
        const result = await response.json();
        if (result.success && result.data) {
            const matched = result.data.find(s => s.sessionId === sessionId);
            if (matched) {
                console.log('✅ 找到匹配的会话，更新标题:', sessionId, matched['sessionName']);
                
                applySessionUpdate(
                    pendingSessionElement,
                    sessionId,
                    matched['sessionName'] || '未命名会话',
                    matched['lastUpdateTime'],
                    matched['messageCount'],
                    switchSessionCallback,
                    refreshSessionListCallback
                );
                
                return true;
            } else {
                console.log('⚠️ 未找到匹配的会话，SessionId:', sessionId);
            }
        }
    } catch (err) {
        console.error('更新会话标题失败:', err);
    }
    
    return false;
}

export function renderSessionList(sessions, switchSessionCallback, updateDomReferencesCallback, bindChatEventsCallback, setConnectionStatusCallback, getIsConnectedCallback, updateInputStateCallback) {
    const sessionList = document.getElementById('sessionList');
    if (!sessionList) return;
    const pending = pendingSessionElement;

    sessionList.innerHTML = '';
    if (pending) {
        // 如果 pending 有真实的 sessionId（不是 temp_ 开头），尝试从服务器数据中更新
        if (pending.dataset.sessionId && !pending.dataset.sessionId.startsWith('temp_')) {
            const realId = pending.dataset.sessionId;
            const matched = sessions.find(s => s.sessionId === realId);
            if (matched) {
                console.log('✅ 找到匹配的会话，更新标题:', realId, matched['sessionName']);
                // 更新 pending 会话项的信息
                const nameEl = pending.querySelector('.session-name');
                const timeEl = pending.querySelector('.session-time');
                const countEl = pending.querySelector('.session-count');
                
                if (nameEl) {
                    const sessionName = matched['sessionName'] || '未命名会话';
                    nameEl.textContent = sessionName;
                    nameEl.title = sessionName;
                    nameEl.style.fontStyle = 'normal';
                }
                if (timeEl) {
                    const updateTime = matched['lastUpdateTime'];
                    if (updateTime) {
                        timeEl.textContent = new Date(updateTime).toLocaleString('zh-CN', {
                            month: '2-digit',
                            day: '2-digit',
                            hour: '2-digit',
                            minute: '2-digit'
                        });
                    }
                }
                if (countEl) {
                    const messageCount = matched['messageCount'] !== undefined ? matched['messageCount'] : 0;
                    countEl.textContent = `${messageCount} 条`;
                }

                pending.classList.remove('pending');
                // 更新点击事件
                const sessionInfo = pending.querySelector('.session-info');
                if (sessionInfo) {
                    // 移除旧的事件监听器
                    const newSessionInfo = sessionInfo.cloneNode(true);
                    sessionInfo.parentNode.replaceChild(newSessionInfo, sessionInfo);
                    newSessionInfo.addEventListener('click', async () => {
                        // switchSessionCallback 是包装函数，只需要传递 sessionId
                        if (switchSessionCallback && typeof switchSessionCallback === 'function') {
                            await switchSessionCallback(realId);
                        }
                    });

                    // 更新删除按钮的事件
                    const deleteBtn = pending.querySelector('.btn-delete-session');
                    if (deleteBtn) {
                        const newDeleteBtn = deleteBtn.cloneNode(true);
                        deleteBtn.parentNode.replaceChild(newDeleteBtn, deleteBtn);
                        newDeleteBtn.onclick = async (e) => {
                            e.stopPropagation();
                            await deleteSession(realId, switchSessionCallback, (switchCallback, updateCallback, bindCallback, statusCallback, connectedCallback, inputStateCallback) => {
                                refreshSessionList(switchCallback, updateCallback, bindCallback, statusCallback, connectedCallback, inputStateCallback);
                            });
                        };
                    }
                }

                // 确保有删除按钮
                if (!pending.querySelector('.btn-delete-session')) {
                    const btn = document.createElement('button');
                    btn.className = 'btn-delete-session';
                    btn.textContent = '🗑️';
                    btn.title = '删除会话';
                    btn.onclick = async (e) => {
                        e.stopPropagation();
                        await deleteSession(realId, switchSessionCallback, (switchCallback, updateCallback, bindCallback, statusCallback, connectedCallback, inputStateCallback) => {
                            refreshSessionList(switchCallback, updateCallback, bindCallback, statusCallback, connectedCallback, inputStateCallback);
                        });
                    };
                    pending.appendChild(btn);
                }

                // 从 sessions 数组中移除已匹配的项
                sessions = sessions.filter(s => s.sessionId !== realId);
            } else {
                console.log('⚠️ 未找到匹配的会话，SessionId:', realId, '服务器返回的会话列表:', sessions.map(s => s.sessionId));
            }
        }
        // 将 pending 元素插入到列表开头
        sessionList.appendChild(pending);
    }

    sessions.forEach(session => {
        const div = document.createElement('div');
        div.className = `session-item ${session.sessionId === getCurrentSessionId() ? 'active' : ''}`;
        div.dataset.sessionId = session.sessionId;
        div.innerHTML = `
            <div class="session-info">
                <div class="session-name" title="${session['sessionName']}">${session['sessionName']}</div>
                <div class="session-meta">
                    <span class="session-time">${new Date(session['lastUpdateTime']).toLocaleString('zh-CN', {
            month: '2-digit',
            day: '2-digit',
            hour: '2-digit',
            minute: '2-digit'
        })}</span>
                    <span class="session-count">${session['messageCount']} 条</span>
                </div>
            </div>
            <button class="btn-delete-session" title="删除会话">🗑️</button>
        `;
        div.querySelector('.session-info').onclick = async () => {
            // switchSessionCallback 是包装函数，只需要传递 sessionId
            if (switchSessionCallback && typeof switchSessionCallback === 'function') {
                await switchSessionCallback(session.sessionId);
            }
        };
        div.querySelector('.btn-delete-session').onclick = async (e) => {
            e.stopPropagation();
            await deleteSession(session.sessionId, switchSessionCallback, () => {
                refreshSessionList(switchSessionCallback, updateDomReferencesCallback, bindChatEventsCallback, setConnectionStatusCallback, getIsConnectedCallback, updateInputStateCallback);
            });
        };
        sessionList.appendChild(div);
    });
}

export function toggleSidebar(forceClose = false) {
    const sessionSidebar = document.getElementById('sessionSidebar');
    const sidebarOverlay = document.getElementById('sidebarOverlay');
    const isMobile = window.innerWidth <= 600;
    if (forceClose) {
        if (isMobile) {
            if (sessionSidebar) sessionSidebar.classList.remove('show');
            if (sidebarOverlay) sidebarOverlay.classList.remove('show');
        } else {
            if (sessionSidebar) sessionSidebar.classList.add('collapsed');
        }
        return;
    }
    if (isMobile) {
        if (sessionSidebar) sessionSidebar.classList.toggle('show');
        if (sidebarOverlay) sidebarOverlay.classList.toggle('show');
    } else {
        if (sessionSidebar) {
            sessionSidebar.classList.toggle('collapsed');
            sessionSidebar.classList.toggle('show');
        }
    }
}