/**
 * 公告弹窗模块 - Announcement Modal Module
 * 支持HTML格式的公告内容显示，多端响应式适配
 * @version 2.0.0
 */

(function(window, document) {
    'use strict';

    // 配置项
    var CONFIG = {
        cookieName: 'announcement_closed',
        cookieExpireHours: 1,
        animationDuration: 400,
        overlaySelector: 'announcementOverlay',
        modalSelector: 'announcementModal',
        version: '2.0.0'
    };

    // 存储当前弹窗元素引用
    var currentElements = null;
    var isModalOpen = false;

    /**
     * 设置Cookie
     * @param {string} name - Cookie名称
     * @param {string} value - Cookie值
     * @param {number} hours - 过期时间（小时）
     */
    function setCookie(name, value, hours) {
        var expires = '';
        if (hours) {
            var date = new Date();
            date.setTime(date.getTime() + (hours * 60 * 60 * 1000));
            expires = '; expires=' + date.toUTCString();
        }
        // 添加SameSite和Secure属性以提高安全性
        var secure = window.location.protocol === 'https:' ? '; Secure' : '';
        document.cookie = name + '=' + encodeURIComponent(value) + expires + '; path=/; SameSite=Lax' + secure;
    }

    /**
     * 获取Cookie
     * @param {string} name - Cookie名称
     * @returns {string|null} Cookie值
     */
    function getCookie(name) {
        var nameEQ = name + '=';
        var ca = document.cookie.split(';');
        for (var i = 0; i < ca.length; i++) {
            var c = ca[i];
            while (c.charAt(0) === ' ') {
                c = c.substring(1);
            }
            if (c.indexOf(nameEQ) === 0) {
                return decodeURIComponent(c.substring(nameEQ.length));
            }
        }
        return null;
    }

    /**
     * 检查是否应该显示公告
     * @returns {boolean}
     */
    function shouldShowAnnouncement() {
        return !getCookie(CONFIG.cookieName);
    }

    /**
     * HTML转义函数（防止XSS攻击）
     * @param {string} text - 需要转义的文本
     * @returns {string} 转义后的文本
     */
    function escapeHtml(text) {
        if (typeof text !== 'string') {
            return '';
        }
        var div = document.createElement('div');
        div.textContent = text;
        return div.innerHTML;
    }

    /**
     * 检测字符串是否包含HTML标签
     * @param {string} str - 需要检测的字符串
     * @returns {boolean} 是否包含HTML标签
     */
    function containsHtmlTags(str) {
        if (typeof str !== 'string') {
            return false;
        }
        // 检测常见的HTML标签模式
        var htmlTagPattern = /<[^>]+>/;
        return htmlTagPattern.test(str);
    }

    /**
     * 处理公告内容
     * - 如果内容包含HTML标签，直接返回（支持HTML格式）
     * - 如果内容不包含HTML标签，将换行符转换为<br>标签
     * @param {string} content - 原始内容
     * @returns {string} 处理后的内容
     */
    function processContent(content) {
        if (typeof content !== 'string' || content.trim() === '') {
            return '';
        }

        // 检测是否包含HTML标签
        if (containsHtmlTags(content)) {
            // 包含HTML标签，直接返回原内容（支持HTML格式）
            return content;
        } else {
            // 不包含HTML标签，是纯文本
            // 将换行符转换为<br>标签，同时转义HTML特殊字符防止XSS
            return escapeHtml(content).replace(/\n/g, '<br>');
        }
    }

    /**
     * 检测设备类型
     * @returns {string} 设备类型：'mobile' | 'tablet' | 'desktop'
     */
    function detectDevice() {
        var width = window.innerWidth || document.documentElement.clientWidth;
        if (width < 480) {
            return 'mobile';
        } else if (width < 768) {
            return 'tablet';
        }
        return 'desktop';
    }

    /**
     * 创建弹窗HTML结构
     * @param {string} title - 弹窗标题
     * @param {string} content - 弹窗内容（支持HTML）
     * @param {Object} options - 额外选项
     * @returns {Object} 弹窗元素对象
     */
    function createModal(title, content, options) {
        options = options || {};

        // 如果已存在弹窗，先移除
        removeExistingModal();

        // 创建遮罩层
        var overlay = document.createElement('div');
        overlay.className = 'announcement-overlay';
        overlay.id = CONFIG.overlaySelector;
        overlay.setAttribute('role', 'dialog');
        overlay.setAttribute('aria-modal', 'true');
        overlay.setAttribute('aria-labelledby', 'announcementTitle');

        // 创建弹窗容器
        var modal = document.createElement('div');
        modal.className = 'announcement-modal';
        modal.id = CONFIG.modalSelector;

        // 添加特殊样式类
        if (options.type === 'important') {
            modal.classList.add('important');
        } else if (options.type === 'success') {
            modal.classList.add('success');
        }

        // 弹窗头部
        var header = document.createElement('div');
        header.className = 'announcement-header';

        var titleEl = document.createElement('h3');
        titleEl.className = 'announcement-title';
        titleEl.id = 'announcementTitle';
        titleEl.innerHTML = '<i class="fa fa-bullhorn" aria-hidden="true"></i> ' + escapeHtml(title || '系统公告');

        var closeBtn = document.createElement('button');
        closeBtn.className = 'announcement-close';
        closeBtn.innerHTML = '&times;';
        closeBtn.setAttribute('aria-label', '关闭公告');
        closeBtn.setAttribute('type', 'button');
        closeBtn.onclick = function() { closeModal(); };

        header.appendChild(titleEl);
        header.appendChild(closeBtn);

        // 弹窗内容区
        var body = document.createElement('div');
        body.className = 'announcement-body';

        var icon = document.createElement('div');
        icon.className = 'announcement-icon';
        icon.setAttribute('aria-hidden', 'true');
        icon.innerHTML = '<i class="fa fa-info-circle"></i>';

        var contentEl = document.createElement('div');
        contentEl.className = 'announcement-content';
        // 处理内容：检测是否包含HTML标签，如果不包含则将换行符转换为<br>
        var processedContent = processContent(content || '');
        contentEl.innerHTML = processedContent;

        body.appendChild(icon);
        body.appendChild(contentEl);

        // 弹窗底部
        var footer = document.createElement('div');
        footer.className = 'announcement-footer';

        var dontShowLabel = document.createElement('label');
        dontShowLabel.className = 'announcement-dont-show';

        var checkbox = document.createElement('input');
        checkbox.type = 'checkbox';
        checkbox.id = 'announcementDontShow';
        checkbox.setAttribute('aria-label', CONFIG.cookieExpireHours + '小时内不再显示此公告');

        var checkboxText = document.createTextNode(CONFIG.cookieExpireHours + '小时内不再提示');

        dontShowLabel.appendChild(checkbox);
        dontShowLabel.appendChild(checkboxText);

        var confirmBtn = document.createElement('button');
        confirmBtn.className = 'announcement-btn';
        confirmBtn.textContent = '我知道了';
        confirmBtn.setAttribute('type', 'button');
        confirmBtn.onclick = function() { closeModal(); };

        footer.appendChild(dontShowLabel);
        footer.appendChild(confirmBtn);

        // 组装弹窗
        modal.appendChild(header);
        modal.appendChild(body);
        modal.appendChild(footer);

        // 添加到文档
        document.body.appendChild(overlay);
        document.body.appendChild(modal);

        // 点击遮罩层关闭
        overlay.onclick = function(e) {
            if (e.target === overlay) {
                closeModal();
            }
        };

        // 存储当前元素引用
        currentElements = { overlay: overlay, modal: modal };

        return currentElements;
    }

    /**
     * 移除已存在的弹窗
     */
    function removeExistingModal() {
        var existingOverlay = document.getElementById(CONFIG.overlaySelector);
        var existingModal = document.getElementById(CONFIG.modalSelector);

        if (existingOverlay && existingOverlay.parentNode) {
            existingOverlay.parentNode.removeChild(existingOverlay);
        }
        if (existingModal && existingModal.parentNode) {
            existingModal.parentNode.removeChild(existingModal);
        }

        // 清理事件监听
        document.removeEventListener('keydown', handleEscKey);
        window.removeEventListener('resize', handleResize);
    }

    /**
     * 处理ESC键事件
     * @param {KeyboardEvent} e
     */
    function handleEscKey(e) {
        if (e.key === 'Escape' && isModalOpen) {
            closeModal();
        }
    }

    /**
     * 处理窗口大小变化
     */
    function handleResize() {
        // 可以在这里添加响应式调整逻辑
        if (isModalOpen && currentElements && currentElements.modal) {
            // 确保弹窗在可视区域内
            var rect = currentElements.modal.getBoundingClientRect();
            var viewportHeight = window.innerHeight;

            if (rect.height > viewportHeight * 0.9) {
                currentElements.modal.style.maxHeight = (viewportHeight * 0.88) + 'px';
            }
        }
    }

    /**
     * 显示弹窗
     * @param {string} title - 弹窗标题
     * @param {string} content - 弹窗内容（支持HTML）
     * @param {Object} options - 额外选项
     */
    function showModal(title, content, options) {
        if (isModalOpen) {
            return;
        }

        options = options || {};

        // 检查是否应该显示
        if (!options.forceShow && !shouldShowAnnouncement()) {
            return;
        }

        var elements = createModal(title, content, options);

        // 触发重绘以确保动画生效
        void elements.modal.offsetWidth;

        // 添加激活类和动画类
        elements.overlay.classList.add('active', 'animating-in');
        elements.modal.classList.add('active', 'animating-in');

        isModalOpen = true;

        // 动画结束后移除动画类
        setTimeout(function() {
            elements.modal.classList.remove('animating-in');
            elements.overlay.classList.remove('animating-in');
        }, CONFIG.animationDuration);

        // 禁止背景滚动
        document.body.style.overflow = 'hidden';

        // 添加键盘事件监听
        document.addEventListener('keydown', handleEscKey);

        // 添加窗口大小变化监听
        window.addEventListener('resize', handleResize);

        // 触发显示回调
        if (typeof options.onShow === 'function') {
            options.onShow();
        }

        // 设置焦点到确认按钮（无障碍支持）
        setTimeout(function() {
            var confirmBtn = elements.modal.querySelector('.announcement-btn');
            if (confirmBtn) {
                confirmBtn.focus();
            }
        }, 100);
    }

    /**
     * 关闭弹窗
     * @param {Function} callback - 关闭后的回调函数
     */
    function closeModal(callback) {
        if (!isModalOpen || !currentElements) {
            if (typeof callback === 'function') {
                callback();
            }
            return;
        }

        var overlay = currentElements.overlay;
        var modal = currentElements.modal;
        var checkbox = document.getElementById('announcementDontShow');

        if (!overlay || !modal) {
            isModalOpen = false;
            if (typeof callback === 'function') {
                callback();
            }
            return;
        }

        // 如果勾选了不再提示，设置Cookie
        if (checkbox && checkbox.checked) {
            setCookie(CONFIG.cookieName, 'true', CONFIG.cookieExpireHours);
        }

        // 添加关闭动画
        modal.classList.add('animating-out');
        overlay.classList.add('animating-out');
        overlay.classList.remove('active');

        isModalOpen = false;

        // 动画结束后移除元素
        setTimeout(function() {
            removeExistingModal();
            document.body.style.overflow = '';

            // 触发关闭回调
            if (typeof callback === 'function') {
                callback();
            }
        }, 250);
    }

    /**
     * 初始化公告弹窗
     * @param {Object} options - 配置选项
     * @param {string} options.title - 弹窗标题
     * @param {string} options.content - 弹窗内容（支持HTML）
     * @param {number} options.expireHours - Cookie过期时间（小时）
     * @param {boolean} options.forceShow - 强制显示（忽略Cookie）
     * @param {string} options.type - 弹窗类型：'normal' | 'important' | 'success'
     * @param {Function} options.onShow - 显示时的回调函数
     * @param {Function} options.onClose - 关闭时的回调函数
     */
    function init(options) {
        options = options || {};

        // 更新配置
        if (options.expireHours && typeof options.expireHours === 'number') {
            CONFIG.cookieExpireHours = options.expireHours;
        }

        if (options.cookieName && typeof options.cookieName === 'string') {
            CONFIG.cookieName = options.cookieName;
        }

        // 强制显示时清除Cookie
        if (options.forceShow) {
            setCookie(CONFIG.cookieName, '', -1);
        }

        // 检查内容是否为空
        if (!options.content || options.content.trim() === '') {
            console.warn('AnnouncementModal: 公告内容为空，不显示弹窗');
            return;
        }

        // DOM加载完成后显示
        function show() {
            showModal(options.title, options.content, {
                type: options.type || 'normal',
                forceShow: options.forceShow,
                onShow: options.onShow,
                onClose: options.onClose
            });
        }

        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', show);
        } else {
            // 使用setTimeout确保其他脚本已执行完毕
            setTimeout(show, 0);
        }
    }

    /**
     * 重置公告状态（清除Cookie）
     */
    function reset() {
        setCookie(CONFIG.cookieName, '', -1);
        console.log('AnnouncementModal: 公告状态已重置');
    }

    /**
     * 获取当前版本
     * @returns {string}
     */
    function getVersion() {
        return CONFIG.version;
    }

    /**
     * 检查弹窗是否正在显示
     * @returns {boolean}
     */
    function isOpen() {
        return isModalOpen;
    }

    // 暴露公共API
    window.AnnouncementModal = {
        init: init,
        show: showModal,
        close: closeModal,
        reset: reset,
        getVersion: getVersion,
        isOpen: isOpen,
        getDevice: detectDevice
    };

    // 添加DOMContentLoaded事件监听，确保DOM完全加载
    document.addEventListener('DOMContentLoaded', function() {
        // 可以在这里添加初始化逻辑
        console.log('AnnouncementModal v' + CONFIG.version + ' 已加载');
    });

})(window, document);
