/**
 * HuSNS 安全工具模块
 * 提供XSS防护和输入验证功能
 */

var HuSNS = window.HuSNS || {};

/**
 * 安全HTML输出
 * 使用textContent安全插入文本内容
 */
HuSNS.safe = {
    /**
     * 安全设置文本内容
     * @param {HTMLElement} element - 目标元素
     * @param {string} content - 文本内容（会自动转义）
     */
    text: function(element, content) {
        if (element && content !== undefined && content !== null) {
            element.textContent = content;
        }
        return element;
    },

    /**
     * 安全追加HTML（仅用于可信内容）
     * @param {HTMLElement} element - 目标元素
     * @param {string} html - HTML内容（需确保可信）
     */
    appendHTML: function(element, html) {
        if (element && html) {
            var template = document.createElement('template');
            template.innerHTML = html;
            element.appendChild(template.content.cloneNode(true));
        }
        return element;
    },

    /**
     * 安全设置HTML（仅用于可信内容）
     * @param {HTMLElement} element - 目标元素
     * @param {string} html - HTML内容（需确保可信）
     */
    setHTML: function(element, html) {
        if (element && html) {
            element.innerHTML = html;
        }
        return element;
    },

    /**
     * 转义HTML特殊字符
     * @param {string} str - 原始字符串
     * @returns {string} 转义后的字符串
     */
    escape: function(str) {
        if (str === undefined || str === null) return '';
        var div = document.createElement('div');
        div.textContent = str;
        return div.innerHTML;
    },

    /**
     * 安全创建元素
     * @param {string} tag - 标签名
     * @param {object} attrs - 属性对象
     * @param {string} text - 文本内容
     * @returns {HTMLElement}
     */
    createElement: function(tag, attrs, text) {
        var el = document.createElement(tag);
        if (attrs) {
            for (var key in attrs) {
                if (key === 'className') {
                    el.className = attrs[key];
                } else if (key === 'dataset') {
                    for (var dk in attrs[key]) {
                        el.dataset[dk] = attrs[key][dk];
                    }
                } else {
                    el.setAttribute(key, attrs[key]);
                }
            }
        }
        if (text) {
            el.textContent = text;
        }
        return el;
    }
};

/**
 * 验证工具
 */
HuSNS.validator = {
    /**
     * 验证文件类型
     * @param {File} file - 文件对象
     * @param {string[]} allowedTypes - 允许的MIME类型数组
     * @returns {boolean}
     */
    isValidFileType: function(file, allowedTypes) {
        if (!file || !allowedTypes || !allowedTypes.length) return false;
        return allowedTypes.some(function(type) {
            return file.type === type || file.type.startsWith(type + '/');
        });
    },

    /**
     * 验证文件扩展名
     * @param {File} file - 文件对象
     * @param {string[]} allowedExtensions - 允许的扩展名数组
     * @returns {boolean}
     */
    isValidFileExtension: function(file, allowedExtensions) {
        if (!file || !allowedExtensions || !allowedExtensions.length) return false;
        var filename = file.name.toLowerCase();
        return allowedExtensions.some(function(ext) {
            return filename.endsWith('.' + ext.toLowerCase());
        });
    },

    /**
     * 验证文件大小
     * @param {File} file - 文件对象
     * @param {number} maxSizeMB - 最大大小（MB）
     * @returns {boolean}
     */
    isValidFileSize: function(file, maxSizeMB) {
        if (!file) return false;
        return file.size <= maxSizeMB * 1024 * 1024;
    },

    /**
     * 验证邮箱格式
     * @param {string} email - 邮箱地址
     * @returns {boolean}
     */
    isValidEmail: function(email) {
        if (!email) return false;
        var re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return re.test(email);
    },

    /**
     * 验证手机号格式
     * @param {string} phone - 手机号
     * @returns {boolean}
     */
    isValidPhone: function(phone) {
        if (!phone) return false;
        var re = /^1[3-9]\d{9}$/;
        return re.test(phone);
    },

    /**
     * 验证密码强度
     * @param {string} password - 密码
     * @returns {object} {valid: boolean, level: number, message: string}
     */
    checkPasswordStrength: function(password) {
        if (!password) {
            return { valid: false, level: 0, message: '请输入密码' };
        }
        
        var level = 0;
        var messages = [];
        
        if (password.length >= 6) {
            level++;
        } else {
            messages.push('至少6个字符');
        }
        
        if (/[a-z]/.test(password)) {
            level++;
        } else {
            messages.push('需包含小写字母');
        }
        
        if (/[A-Z]/.test(password)) {
            level++;
        } else {
            messages.push('需包含大写字母');
        }
        
        if (/\d/.test(password)) {
            level++;
        } else {
            messages.push('需包含数字');
        }
        
        if (/[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?]/.test(password)) {
            level++;
        } else {
            messages.push('需包含特殊字符');
        }
        
        var valid = password.length >= 6;
        var message = messages.length > 0 ? messages.join(', ') : '密码强度良好';
        
        if (level >= 4) {
            message = '密码强度：强';
        } else if (level >= 2) {
            message = '密码强度：中等';
        } else {
            message = '密码强度：弱';
        }
        
        return { valid: valid, level: Math.min(level, 5), message: message };
    },

    /**
     * 验证用户名
     * @param {string} username - 用户名
     * @returns {object} {valid: boolean, message: string}
     */
    isValidUsername: function(username) {
        if (!username) {
            return { valid: false, message: '请输入用户名' };
        }
        if (username.length < 3) {
            return { valid: false, message: '用户名至少3个字符' };
        }
        if (username.length > 20) {
            return { valid: false, message: '用户名最多20个字符' };
        }
        if (!/^[a-zA-Z0-9_\u4e00-\u9fa5]+$/.test(username)) {
            return { valid: false, message: '用户名只能包含字母、数字、下划线和中文' };
        }
        return { valid: true, message: '用户名格式正确' };
    }
};

if (typeof module !== 'undefined' && module.exports) {
    module.exports = { safe: HuSNS.safe, validator: HuSNS.validator };
}
