/**
 * 回访记录功能JavaScript - 修复版本
 * 处理字符计数、保存等功能
 * 修复：使用完整的API URL地址
 */

// API服务器配置
const API_BASE_URL = (typeof window !== 'undefined' && window.API_BASE_URL) ? window.API_BASE_URL : '';

// 页面加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    initializeCallbackRecord();
});

/**
 * 初始化回访记录功能
 */
function initializeCallbackRecord() {
    // 初始化字符计数
    initCharacterCount();
    
    // 初始化表单验证
    initFormValidation();
    
    console.log('回访记录功能初始化完成 - 修复版本');
    console.log('API服务器地址:', API_BASE_URL);
}

/**
 * 初始化字符计数功能
 */
function initCharacterCount() {
    const textareas = document.querySelectorAll('textarea[name="callback-record"]');
    
    textareas.forEach(textarea => {
        const caseNumber = textarea.id.replace('callback-record-', '');
        const countElement = document.getElementById(`char-count-${caseNumber}`);
        
        if (countElement) {
            // 初始化计数
            updateCharacterCount(textarea.id);
            
            // 监听输入事件
            textarea.addEventListener('input', function() {
                updateCharacterCount(this.id);
            });
            
            // 监听粘贴事件
            textarea.addEventListener('paste', function() {
                setTimeout(() => {
                    updateCharacterCount(this.id);
                }, 0);
            });
        }
    });
}

/**
 * 更新字符计数
 * @param {string} textareaId - 文本域ID
 */
function updateCharacterCount(textareaId) {
    const textarea = document.getElementById(textareaId);
    const caseNumber = textareaId.replace('callback-record-', '');
    const countElement = document.getElementById(`char-count-${caseNumber}`);
    
    if (textarea && countElement) {
        const currentLength = textarea.value.length;
        const maxLength = textarea.getAttribute('maxlength') || 500;
        
        countElement.textContent = currentLength;
        
        // 根据字符数改变颜色
        if (currentLength > maxLength * 0.9) {
            countElement.className = 'text-red-500 font-medium';
        } else if (currentLength > maxLength * 0.7) {
            countElement.className = 'text-yellow-600';
        } else {
            countElement.className = 'text-gray-500';
        }
    }
}

/**
 * 初始化表单验证
 */
function initFormValidation() {
    const textareas = document.querySelectorAll('textarea[name="callback-record"]');
    
    textareas.forEach(textarea => {
        textarea.addEventListener('blur', function() {
            validateCallbackRecord(this);
        });
    });
}

/**
 * 验证回访记录
 * @param {HTMLElement} textarea - 文本域元素
 */
function validateCallbackRecord(textarea) {
    const value = textarea.value.trim();
    const minLength = 5; // 最少5个字符
    
    // 移除之前的错误样式
    textarea.classList.remove('border-red-500', 'border-green-500');
    
    if (value.length > 0 && value.length < minLength) {
        textarea.classList.add('border-red-500');
        showToast('回访记录至少需要5个字符', 'warning');
    } else if (value.length >= minLength) {
        textarea.classList.add('border-green-500');
    }
}

/**
 * 获取当前登录用户的真实姓名
 * @returns {string} 用户真实姓名或用户名
 */
function getCurrentUserRealName() {
    // 尝试从页面中获取用户信息
    const userInfoElement = document.getElementById('user-info');
    if (userInfoElement) {
        const userText = userInfoElement.textContent || userInfoElement.innerText;
        if (userText && userText !== '未登录') {
            // 提取用户名（去掉"欢迎，"等前缀）
            const match = userText.match(/欢迎，(.+)/);
            if (match && match[1]) {
                return match[1].trim();
            }
            return userText.trim();
        }
    }
    
    // 尝试从localStorage获取
    const storedUser = localStorage.getItem('currentUser');
    if (storedUser) {
        try {
            const userData = JSON.parse(storedUser);
            return userData.real_name || userData.username || '未知用户';
        } catch (e) {
            return storedUser;
        }
    }
    
    // 尝试从sessionStorage获取
    const sessionUser = sessionStorage.getItem('currentUser');
    if (sessionUser) {
        try {
            const userData = JSON.parse(sessionUser);
            return userData.real_name || userData.username || '未知用户';
        } catch (e) {
            return sessionUser;
        }
    }
    
    // 如果都获取不到，返回默认值
    return '系统用户';
}

/**
 * 保存回访记录
 * @param {string} patientId - 患者ID
 */
function saveCallbackRecord(patientId) {
    // 获取当前用户的真实姓名
    const currentUser = getCurrentUserRealName();
    
    // 获取表单数据
    const checkboxes = document.querySelectorAll(`input[name="callback-method-${patientId}"]:checked`);
    const resultRadio = document.querySelector(`input[name="callback-result-${patientId}"]:checked`);
    const appointmentInput = document.getElementById(`next-appointment-${patientId}`);
    const failureSelect = document.getElementById(`failure-reason-${patientId}`);
    const abandonSelect = document.getElementById(`abandon-reason-${patientId}`);
    const aiFeedbackSelect = document.getElementById(`ai-feedback-${patientId}`);
    
    // 验证回访方式
    const methods = Array.from(checkboxes).map(cb => cb.value);
    if (methods.length === 0) {
        alert('请选择至少一种回访方式');
        return;
    }
    
    // 验证回访结果
    if (!resultRadio) {
        alert('请选择回访结果');
        return;
    }
    
    const callbackResult = resultRadio.value;
    let nextAppointmentTime = null;
    let failureReason = null;
    let abandonReason = null;
    
    if (callbackResult === '成功') {
        nextAppointmentTime = appointmentInput ? appointmentInput.value : null;
    } else if (callbackResult === '不成功') {
        if (!failureSelect || !failureSelect.value) {
            alert('回访不成功时，请选择具体原因');
            if (failureSelect) failureSelect.focus();
            return;
        }
        failureReason = failureSelect.value;
    } else if (callbackResult === '放弃回访') {
        if (!abandonSelect || !abandonSelect.value) {
            alert('放弃回访时，请选择具体原因');
            if (abandonSelect) abandonSelect.focus();
            return;
        }
        abandonReason = abandonSelect.value;
    }
    
    // AI反馈（可选）
    const aiFeedback = aiFeedbackSelect ? aiFeedbackSelect.value : null;
    
    // 构建保存数据
    const saveData = {
        caseNumber: patientId,
        callbackMethods: methods,
        callbackResult: callbackResult,
        nextAppointmentTime: nextAppointmentTime,
        failureReason: failureReason,
        abandonReason: abandonReason,
        aiFeedbackType: aiFeedback,
        operator: currentUser  // 使用真实用户名
    };
    
    console.log('保存回访记录数据:', saveData);
    console.log('当前用户:', currentUser);
    
    // 显示保存中状态
    const saveBtn = document.querySelector(`button[onclick="saveCallbackRecord('${patientId}')"]`);
    const originalText = saveBtn.innerHTML;
    saveBtn.innerHTML = '<i class="fas fa-spinner fa-spin mr-1"></i>保存中...';
    saveBtn.disabled = true;
    
    // 调用保存API
    fetch('/api/callback-records', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
        },
        body: JSON.stringify(saveData)
    })
    .then(response => response.json())
    .then(data => {
        console.log('API响应:', data);
        if (data.success) {
            showSuccessToast('回访记录保存成功！');
            clearCallbackForm(patientId);
            // 实时更新回访记录显示
            updateCallbackRecords(patientId);
        } else {
            showErrorToast(`保存失败：${data.message}`);
        }
    })
    .catch(error => {
        console.error('保存失败:', error);
        showErrorToast('网络错误，保存失败。请检查网络连接或联系管理员。');
    })
    .finally(() => {
        saveBtn.innerHTML = originalText;
        saveBtn.disabled = false;
    });
}

/**
 * 保存回访记录到MySQL数据库 - 修复版本
 * @param {Object} data - 保存数据
 * @returns {Promise} - 保存结果
 */
async function saveCallbackRecordToDatabase(data) {
    console.log('准备保存到MySQL数据库的数据:', data);
    
    // 构建完整的API URL
    const apiUrl = `${API_BASE_URL}/api/callback-records`;
    console.log('API请求地址:', apiUrl);
    
    try {
        const response = await fetch(apiUrl, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Accept': 'application/json'
            },
            body: JSON.stringify(data)
        });
        
        console.log('API响应状态:', response.status);
        
        if (!response.ok) {
            const errorText = await response.text();
            console.error('API错误响应:', errorText);
            throw new Error(`HTTP ${response.status}: ${errorText}`);
        }
        
        const result = await response.json();
        console.log('API响应结果:', result);
        
        if (result.success) {
            return result;
        } else {
            throw new Error(result.message || '保存失败');
        }
        
    } catch (error) {
        console.error('保存回访记录到MySQL失败:', error);
        
        // 如果是网络错误或API不可用，显示友好提示
        if (error.name === 'TypeError' || error.message.includes('fetch')) {
            throw new Error(`无法连接到服务器 (${apiUrl})，请检查：\n1. API服务器是否正在运行\n2. 服务器地址是否正确\n3. 网络连接是否正常`);
        }
        
        throw error;
    }
}

/**
 * 测试API连接
 */
async function testAPIConnection() {
    const healthUrl = `${API_BASE_URL}/api/health`;
    try {
        const response = await fetch(healthUrl);
        const result = await response.json();
        console.log('API健康检查结果:', result);
        showToast('API服务器连接正常', 'success');
        return true;
    } catch (error) {
        console.error('API连接测试失败:', error);
        showToast(`API服务器连接失败: ${error.message}`, 'error');
        return false;
    }
}

/**
 * 设置下次回访（预留功能）
 * @param {string} caseNumber - 病历号
 */
function scheduleNextCallback(caseNumber) {
    showToast('此功能正在开发中...', 'info');
    console.log('设置下次回访:', caseNumber);
}

/**
 * 新建预约（预留功能）
 * @param {string} caseNumber - 病历号
 */
function createAppointment(caseNumber) {
    showToast('此功能正在开发中...', 'info');
    console.log('新建预约:', caseNumber);
}

/**
 * 显示提示消息
 * @param {string} message - 消息内容
 * @param {string} type - 消息类型 (success, error, warning, info)
 */
function showToast(message, type = 'info') {
    // 创建提示元素
    const toast = document.createElement('div');
    toast.className = `fixed top-4 right-4 px-6 py-3 rounded-lg shadow-lg z-50 transition-all duration-300 transform translate-x-full max-w-md`;
    
    // 根据类型设置样式
    switch (type) {
        case 'success':
            toast.classList.add('bg-green-500', 'text-white');
            break;
        case 'error':
            toast.classList.add('bg-red-500', 'text-white');
            break;
        case 'warning':
            toast.classList.add('bg-yellow-500', 'text-white');
            break;
        default:
            toast.classList.add('bg-blue-500', 'text-white');
    }
    
    // 处理多行消息
    if (message.includes('\n')) {
        const lines = message.split('\n');
        toast.innerHTML = lines.map(line => `<div>${line}</div>`).join('');
    } else {
        toast.textContent = message;
    }
    
    document.body.appendChild(toast);
    
    // 显示动画
    setTimeout(() => {
        toast.classList.remove('translate-x-full');
    }, 100);
    
    // 自动隐藏
    setTimeout(() => {
        toast.classList.add('translate-x-full');
        setTimeout(() => {
            if (toast.parentNode) {
                toast.parentNode.removeChild(toast);
            }
        }, 300);
    }, 5000); // 延长显示时间到5秒
}

/**
 * 显示成功提示消息
 * @param {string} message - 消息内容
 */
function showSuccessToast(message) {
    showToast(message, 'success');
}

/**
 * 显示错误提示消息
 * @param {string} message - 消息内容
 */
function showErrorToast(message) {
    showToast(message, 'error');
}

/**
 * 获取认证令牌（如果需要的话）
 * @returns {string} - 认证令牌
 */
function getAuthToken() {
    // 这里可以实现获取认证令牌的逻辑
    // 比如从localStorage、sessionStorage或cookie中获取
    return '';
}

// 页面加载完成后测试API连接
document.addEventListener('DOMContentLoaded', function() {
    // 延迟3秒后自动测试API连接
    setTimeout(() => {
        console.log('自动测试API连接...');
        testAPIConnection();
    }, 3000);
});

// 导出函数供全局使用
window.saveCallbackRecord = saveCallbackRecord;
window.scheduleNextCallback = scheduleNextCallback;
window.createAppointment = createAppointment;
window.testAPIConnection = testAPIConnection; 