// ==UserScript==
// @name         Websites Base64 Helper
// @icon         https://raw.githubusercontent.com/XavierBar/Discourse-Base64-Helper/refs/heads/main/discourse.svg
// @namespace    http://tampermonkey.net/
// @version      1.4.41
// @description  Base64编解码工具 for all websites
// @author       Xavier
// @match        *://*/*
// @grant        GM_notification
// @grant        GM_setClipboard
// @grant        GM_addStyle
// @grant        GM_getValue
// @grant        GM_setValue
// @grant        GM_registerMenuCommand
// @grant        GM_unregisterMenuCommand
// @grant        GM_addValueChangeListener
// @run-at       document-idle
// @noframes     true
// @downloadURL none
// ==/UserScript==

(function () {
	('use strict');

	// 常量定义
	const Z_INDEX = 2147483647;
	const STORAGE_KEYS = {
		BUTTON_POSITION: 'btnPosition',
		SHOW_NOTIFICATION: 'showNotification',
		HIDE_BUTTON: 'hideButton',
		AUTO_DECODE: 'autoDecode',
	};

	// 存储管理器
	const storageManager = {
		get: (key, defaultValue) => {
			try {
				// 优先从 GM 存储获取
				const value = GM_getValue(`base64helper_${key}`);
				if (value !== undefined) {
					return value;
				}

				// 尝试从 localStorage 迁移数据（兼容旧版本）
				const localValue = localStorage.getItem(`base64helper_${key}`);
				if (localValue !== null) {
					const parsedValue = JSON.parse(localValue);
					// 迁移数据到 GM 存储
					GM_setValue(`base64helper_${key}`, parsedValue);
					// 清理 localStorage 中的旧数据
					localStorage.removeItem(`base64helper_${key}`);
					return parsedValue;
				}

				return defaultValue;
			} catch (e) {
				console.error('Error getting value from storage:', e);
				return defaultValue;
			}
		},
		set: (key, value) => {
			try {
				// 存储到 GM 存储
				GM_setValue(`base64helper_${key}`, value);
				return true;
			} catch (e) {
				console.error('Error setting value to storage:', e);
				return false;
			}
		},
		// 添加删除方法
		remove: (key) => {
			try {
				GM_deleteValue(`base64helper_${key}`);
				return true;
			} catch (e) {
				console.error('Error removing value from storage:', e);
				return false;
			}
		},
		// 添加监听方法
		addChangeListener: (key, callback) => {
			return GM_addValueChangeListener(`base64helper_${key}`,
				(_, oldValue, newValue, remote) => {
					callback(newValue, oldValue, remote);
				}
			);
		},
		// 移除监听方法
		removeChangeListener: (listenerId) => {
			if (listenerId) {
				GM_removeValueChangeListener(listenerId);
			}
		}
	};
	const BASE64_REGEX = /([A-Za-z0-9+/]+={0,2})(?!\w)/g;
	// 样式常量
	const STYLES = {
		GLOBAL: `
            /* 基础内容样式 */
            .decoded-text {
                cursor: pointer;
                transition: all 0.2s;
                padding: 1px 3px;
                border-radius: 3px;
                background-color: #fff3cd !important;
                color: #664d03 !important;
            }
            .decoded-text:hover {
                background-color: #ffe69c !important;
            }
            /* 通知动画 */
            @keyframes slideIn {
                from {
                    transform: translateY(-20px);
                    opacity: 0;
                }
                to {
                    transform: translateY(0);
                    opacity: 1;
                }
            }
            @keyframes fadeOut {
                from { opacity: 1; }
                to { opacity: 0; }
            }
            /* 暗色模式全局样式 */
            @media (prefers-color-scheme: dark) {
                .decoded-text {
                    background-color: #332100 !important;
                    color: #ffd54f !important;
                }
                .decoded-text:hover {
                    background-color: #664d03 !important;
                }
            }
        `,
		NOTIFICATION: `
            @keyframes slideUpOut {
                0% {
                    transform: translateY(0) scale(1);
                    opacity: 1;
                }
                100% {
                    transform: translateY(-30px) scale(0.95);
                    opacity: 0;
                }
            }
            .base64-notifications-container {
                position: fixed;
                top: 20px;
                left: 50%;
                transform: translateX(-50%);
                z-index: ${Z_INDEX};
                display: flex;
                flex-direction: column;
                gap: 0;
                pointer-events: none;
                align-items: center;
                width: fit-content;
            }
            .base64-notification {
                transform-origin: top center;
                white-space: nowrap;
                padding: 12px 24px;
                border-radius: 8px;
                margin-bottom: 10px;
                animation: slideIn 0.3s ease forwards;
                font-family: system-ui, -apple-system, sans-serif;
                backdrop-filter: blur(4px);
                border: 1px solid rgba(255, 255, 255, 0.1);
                text-align: center;
                line-height: 1.5;
                background: rgba(255, 255, 255, 0.95);
                color: #2d3748;
                box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1), 0 2px 4px -1px rgba(0, 0, 0, 0.06);
                opacity: 1;
                transform: translateY(0);
                transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
                will-change: transform, opacity;
                position: relative;
                height: auto;
                max-height: 100px;
            }
            .base64-notification.fade-out {
                animation: slideUpOut 0.4s cubic-bezier(0.4, 0, 0.2, 1) forwards;
                margin-bottom: 0 !important;
                max-height: 0 !important;
                padding-top: 0 !important;
                padding-bottom: 0 !important;
                border-width: 0 !important;
            }
            .base64-notification[data-type="success"] {
                background: rgba(72, 187, 120, 0.95) !important;
                color: #f7fafc !important;
            }
            .base64-notification[data-type="error"] {
                background: rgba(245, 101, 101, 0.95) !important;
                color: #f8fafc !important;
            }
            .base64-notification[data-type="info"] {
                background: rgba(66, 153, 225, 0.95) !important;
                color: #f7fafc !important;
            }
            @media (prefers-color-scheme: dark) {
                .base64-notification {
                    background: rgba(26, 32, 44, 0.95) !important;
                    color: #e2e8f0 !important;
                    box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.3), 0 2px 4px -1px rgba(0, 0, 0, 0.2);
                    border-color: rgba(255, 255, 255, 0.05);
                }
                .base64-notification[data-type="success"] {
                    background: rgba(22, 101, 52, 0.95) !important;
                }
                .base64-notification[data-type="error"] {
                    background: rgba(155, 28, 28, 0.95) !important;
                }
                .base64-notification[data-type="info"] {
                    background: rgba(29, 78, 216, 0.95) !important;
                }
            }
        `,
		SHADOW_DOM: `
            :host {
                all: initial !important;
                position: fixed !important;
                z-index: ${Z_INDEX} !important;
                pointer-events: none !important;
            }
            .base64-helper {
                position: fixed;
                z-index: ${Z_INDEX} !important;
                transform: translateZ(100px);
                cursor: drag;
                font-family: system-ui, -apple-system, sans-serif;
                opacity: 0.5;
                transition: opacity 0.3s ease, transform 0.2s;
                pointer-events: auto !important;
                will-change: transform;
            }
            .base64-helper.dragging {
                cursor: grabbing;
            }
						.base64-helper:hover {
              opacity: 1 !important;
            }
            .main-btn {
                background: #ffffff;
                color: #000000 !important;
                padding: 8px 16px;
                border-radius: 6px;
                box-shadow: 0 2px 6px rgba(0, 0, 0, 0.15);
                font-weight: 500;
                user-select: none;
                transition: all 0.2s;
                font-size: 14px;
                cursor: drag;
                border: none !important;
            }
            .main-btn.dragging {
                cursor: grabbing;
            }
            .menu {
                position: absolute;
                background: #ffffff;
                border-radius: 6px;
                box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
                display: none;
                min-width: auto !important;
                width: max-content !important;
                overflow: hidden;
            }

            /* 菜单弹出方向 */
            .menu.popup-top {
                bottom: calc(100% + 5px);
            }
            .menu.popup-bottom {
                top: calc(100% + 5px);
            }

            /* 新增: 左对齐样式 */
            .menu.align-left {
                left: 0;
            }
            .menu.align-left .menu-item {
                text-align: left;
            }

            /* 新增: 右对齐样式 */
            .menu.align-right {
                right: 0;
            }
            .menu.align-right .menu-item {
                text-align: right;
            }
            .menu-item {
                padding: 8px 12px !important;
                color: #333 !important;
                transition: all 0.2s;
                font-size: 13px;
                cursor: pointer;
                position: relative;
                border-radius: 0 !important;
                isolation: isolate;
                white-space: nowrap !important;
                // 新增以下样式防止文本被选中
                user-select: none;
                -webkit-user-select: none;
                -moz-user-select: none;
                -ms-user-select: none;
            }
            .menu-item:hover::before {
                content: '';
                position: absolute;
                top: 0;
                left: 0;
                right: 0;
                bottom: 0;
                background: currentColor;
                opacity: 0.1;
                z-index: -1;
            }
            @media (prefers-color-scheme: dark) {
                .main-btn {
                    background: #2d2d2d;
                    color: #fff !important;
                    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.3);
                }
                .menu {
                    background: #1a1a1a;
                    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.25);
                }
                .menu-item {
                    color: #e0e0e0 !important;
                }
                .menu-item:hover::before {
                    opacity: 0.08;
                }
            }
        `,
	};

	// 样式初始化
	const initStyles = () => {
		GM_addStyle(STYLES.GLOBAL + STYLES.NOTIFICATION);
	};

	// 全局变量存储所有菜单命令ID
	let menuIds = {
		decode: null,
		encode: null,
		reset: null,
		notification: null,
		hideButton: null,
		autoDecode: null
	};

	// 更新菜单命令
	const updateMenuCommands = () => {
		// 取消注册所有菜单命令
		Object.values(menuIds).forEach(id => {
			if (id !== null) {
				try {
					GM_unregisterMenuCommand(id);
				} catch (e) {
					console.error('Failed to unregister menu command:', e);
				}
			}
		});

		// 重置菜单ID对象
		menuIds = {
			decode: null,
			encode: null,
			reset: null,
			notification: null,
			hideButton: null,
			autoDecode: null
		};

		// 检查当前状态，决定解析菜单文本
		const hasDecodedContent = document.querySelectorAll('.decoded-text').length > 0;
		const decodeMenuText = hasDecodedContent ? '恢复本页 Base64' : '解析本页 Base64';

		// 注册解析菜单命令 - 放在第一位
		try {
			menuIds.decode = GM_registerMenuCommand(decodeMenuText, () => {
				if (window.__base64HelperInstance) {
					window.__base64HelperInstance.handleDecode();
				}
			});
			console.log('Registered decode menu command with ID:', menuIds.decode);
		} catch (e) {
			console.error('Failed to register decode menu command:', e);
		}

		// 文本转 Base64
		try {
			menuIds.encode = GM_registerMenuCommand('文本转 Base64', () => {
				if (window.__base64HelperInstance) window.__base64HelperInstance.handleEncode();
			});
			console.log('Registered encode menu command with ID:', menuIds.encode);
		} catch (e) {
			console.error('Failed to register encode menu command:', e);
		}

		// 重置按钮位置
		try {
			menuIds.reset = GM_registerMenuCommand('重置按钮位置', () => {
				if (window.__base64HelperInstance) {
					// 使用 storageManager 存储按钮位置
					storageManager.set(STORAGE_KEYS.BUTTON_POSITION, {
						x: window.innerWidth - 120,
						y: window.innerHeight - 80,
					});
					window.__base64HelperInstance.initPosition();
					window.__base64HelperInstance.showNotification('按钮位置已重置', 'success');
				}
			});
			console.log('Registered reset menu command with ID:', menuIds.reset);
		} catch (e) {
			console.error('Failed to register reset menu command:', e);
		}

		// 显示解析通知开关
		const showNotificationEnabled = storageManager.get(STORAGE_KEYS.SHOW_NOTIFICATION, true);
		try {
			menuIds.notification = GM_registerMenuCommand(`${showNotificationEnabled ? '✅' : '❌'} 显示通知`, () => {
				const newValue = !showNotificationEnabled;
				storageManager.set(STORAGE_KEYS.SHOW_NOTIFICATION, newValue);
				// 使用通知提示用户设置已更改
				if (window.__base64HelperInstance) {
					window.__base64HelperInstance.showNotification(
						`显示通知已${newValue ? '开启' : '关闭'}`,
						'success'
					);
				}
				// 更新菜单文本
				setTimeout(updateMenuCommands, 100);
			});
			console.log('Registered notification menu command with ID:', menuIds.notification);
		} catch (e) {
			console.error('Failed to register notification menu command:', e);
		}

		// 隐藏按钮开关
		const hideButtonEnabled = storageManager.get(STORAGE_KEYS.HIDE_BUTTON, false);
		try {
			menuIds.hideButton = GM_registerMenuCommand(`${hideButtonEnabled ? '✅' : '❌'} 隐藏按钮`, () => {
				const newValue = !hideButtonEnabled;
				storageManager.set(STORAGE_KEYS.HIDE_BUTTON, newValue);
				// 使用通知提示用户设置已更改
				if (window.__base64HelperInstance) {
					window.__base64HelperInstance.showNotification(
						`按钮已${newValue ? '隐藏' : '显示'}`,
						'success'
					);
				}
				// 更新菜单文本
				setTimeout(updateMenuCommands, 100);
			});
			console.log('Registered hideButton menu command with ID:', menuIds.hideButton);
		} catch (e) {
			console.error('Failed to register hideButton menu command:', e);
		}

		// 自动解码开关
		const autoDecodeEnabled = storageManager.get(STORAGE_KEYS.AUTO_DECODE, false);
		try {
			menuIds.autoDecode = GM_registerMenuCommand(`${autoDecodeEnabled ? '✅' : '❌'} 自动解码`, () => {
				const newValue = !autoDecodeEnabled;
				storageManager.set(STORAGE_KEYS.AUTO_DECODE, newValue);

				// 如果启用自动解码但按钮未隐藏，提示用户
				if (newValue && !storageManager.get(STORAGE_KEYS.HIDE_BUTTON, false)) {
					if (confirm('建议同时隐藏按钮以获得更好的体验。\n\n是否同时隐藏按钮？')) {
						storageManager.set(STORAGE_KEYS.HIDE_BUTTON, true);
					}
				}

				// 使用通知提示用户设置已更改
				if (window.__base64HelperInstance) {
					window.__base64HelperInstance.showNotification(
						`自动解码已${newValue ? '开启' : '关闭'}`,
						'success'
					);
				}
				// 更新菜单文本
				setTimeout(updateMenuCommands, 100);
			});
			console.log('Registered autoDecode menu command with ID:', menuIds.autoDecode);
		} catch (e) {
			console.error('Failed to register autoDecode menu command:', e);
		}
	};

	// 菜单命令注册
	const registerMenuCommands = () => {
		// 注册所有菜单命令
		updateMenuCommands();
	};

	class Base64Helper {
		/**
		 * Base64 Helper 类的构造函数
		 * @description 初始化所有必要的状态和UI组件,仅在主窗口中创建实例
		 * @throws {Error} 当在非主窗口中实例化时抛出错误
		 */
		constructor() {
			// 确保只在主文档中创建实例
			if (window.top !== window.self) {
				throw new Error(
					'Base64Helper can only be instantiated in the main window'
				);
			}

			// 初始化配置
			this.config = {
				showNotification: storageManager.get(STORAGE_KEYS.SHOW_NOTIFICATION, true),
				hideButton: storageManager.get(STORAGE_KEYS.HIDE_BUTTON, false),
				autoDecode: storageManager.get(STORAGE_KEYS.AUTO_DECODE, false)
			};

			this.originalContents = new Map();
			this.isDragging = false;
			this.hasMoved = false;
			this.startX = 0;
			this.startY = 0;
			this.initialX = 0;
			this.initialY = 0;
			this.startTime = 0;
			this.menuVisible = false;
			this.resizeTimer = null;
			this.notifications = [];
			this.notificationContainer = null;
			this.notificationEventListeners = [];
			this.eventListeners = [];

			// 添加缓存对象
			this.base64Cache = new Map();
			this.MAX_CACHE_SIZE = 1000; // 最大缓存条目数
			this.MAX_TEXT_LENGTH = 10000; // 最大文本长度限制

			// 初始化配置监听器
			this.configListeners = {
				showNotification: null,
				hideButton: null,
				autoDecode: null,
				buttonPosition: null
			};

			// 添加配置监听
			this.setupConfigListeners();

			// 初始化UI
			this.initUI();
			this.initEventListeners();
			this.addRouteListeners();

			// 如果启用了自动解码，则自动解析页面
			if (this.config.autoDecode) {
				// 使用延时确保页面已完全加载
				setTimeout(() => this.handleDecode(), 1000);
			}
		}

		/**
		 * 设置配置监听器
		 * @description 为各个配置项添加监听器，实现配置变更的实时响应
		 */
		setupConfigListeners() {
			// 清理现有监听器
			Object.values(this.configListeners).forEach(listenerId => {
				if (listenerId) {
					storageManager.removeChangeListener(listenerId);
				}
			});

			// 监听显示通知设置变更
			this.configListeners.showNotification = storageManager.addChangeListener(
				STORAGE_KEYS.SHOW_NOTIFICATION,
				(newValue) => {
					console.log('显示通知设置已更改:', newValue);
					this.config.showNotification = newValue;
				}
			);

			// 监听隐藏按钮设置变更
			this.configListeners.hideButton = storageManager.addChangeListener(
				STORAGE_KEYS.HIDE_BUTTON,
				(newValue) => {
					console.log('隐藏按钮设置已更改:', newValue);
					this.config.hideButton = newValue;

					// 实时更新UI显示状态
					const ui = this.shadowRoot?.querySelector('.base64-helper');
					if (ui) {
						ui.style.display = newValue ? 'none' : 'block';
					}
				}
			);

			// 监听自动解码设置变更
			this.configListeners.autoDecode = storageManager.addChangeListener(
				STORAGE_KEYS.AUTO_DECODE,
				(newValue) => {
					console.log('自动解码设置已更改:', newValue);
					this.config.autoDecode = newValue;

					// 如果启用了自动解码，立即解析页面
					if (newValue) {
						setTimeout(() => this.handleDecode(), 100);
					}
				}
			);

			// 监听按钮位置变更
			this.configListeners.buttonPosition = storageManager.addChangeListener(
				STORAGE_KEYS.BUTTON_POSITION,
				(newValue) => {
					console.log('按钮位置已更改:', newValue);
					// 更新按钮位置
					this.initPosition();
				}
			);
		}

		// 添加正则常量
		static URL_PATTERNS = {
			URL: /^(?:(?:https?|ftp):\/\/)?(?:(?:[\w-]+\.)+[a-z]{2,}|localhost)(?::\d+)?(?:\/[^\s]*)?$/i,
			EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
			DOMAIN_PATTERNS: {
				POPULAR_SITES:
					/(?:google|youtube|facebook|twitter|instagram|linkedin|github|gitlab|bitbucket|stackoverflow|reddit|discord|twitch|tiktok|snapchat|pinterest|netflix|amazon|microsoft|apple|adobe)/i,
				VIDEO_SITES:
					/(?:bilibili|youku|iqiyi|douyin|kuaishou|nicovideo|vimeo|dailymotion)/i,
				CN_SITES:
					/(?:baidu|weibo|zhihu|taobao|tmall|jd|qq|163|sina|sohu|csdn|aliyun|tencent)/i,
				TLD: /\.(?:com|net|org|edu|gov|mil|biz|info|io|cn|me|tv|cc|uk|jp|ru|eu|au|de|fr)(?:\/|\?|#|$)/i,
			},
		};

		// UI 初始化
		initUI() {
			if (
				window.top !== window.self ||
				document.getElementById('base64-helper-root')
			) {
				return;
			}

			this.container = document.createElement('div');
			this.container.id = 'base64-helper-root';
			document.body.append(this.container);

			this.shadowRoot = this.container.attachShadow({ mode: 'open' });
			this.shadowRoot.appendChild(this.createShadowStyles());

			// 创建 UI 容器
			const uiContainer = document.createElement('div');
			uiContainer.className = 'base64-helper';
			uiContainer.style.cursor = 'grab';

			// 创建按钮和菜单
			this.mainBtn = this.createButton('Base64', 'main-btn');
			this.menu = this.createMenu();
			this.decodeBtn = this.menu.querySelector('[data-mode="decode"]');
			this.encodeBtn = this.menu.querySelector('.menu-item:not([data-mode])');

			// 添加到 UI 容器
			uiContainer.append(this.mainBtn, this.menu);
			this.shadowRoot.appendChild(uiContainer);

			// 初始化位置
			this.initPosition();

			// 如果配置为隐藏按钮，则设置为不可见
			if (this.config.hideButton) {
				uiContainer.style.display = 'none';
			}
		}

		createShadowStyles() {
			const style = document.createElement('style');
			style.textContent = STYLES.SHADOW_DOM;
			return style;
		}

		// 不再需要 createMainUI 方法，因为我们直接在 initUI 中创建 UI

		createButton(text, className) {
			const btn = document.createElement('button');
			btn.className = className;
			btn.textContent = text;
			return btn;
		}

		createMenu() {
			const menu = document.createElement('div');
			menu.className = 'menu';

			this.decodeBtn = this.createMenuItem('解析本页 Base64', 'decode');
			this.encodeBtn = this.createMenuItem('文本转 Base64');

			menu.append(this.decodeBtn, this.encodeBtn);
			return menu;
		}

		createMenuItem(text, mode) {
			const item = document.createElement('div');
			item.className = 'menu-item';
			item.textContent = text;
			if (mode) item.dataset.mode = mode;
			return item;
		}

		// 位置管理
		initPosition() {
			const pos = this.positionManager.get() || {
				x: window.innerWidth - 120,
				y: window.innerHeight - 80,
			};

			const ui = this.shadowRoot.querySelector('.base64-helper');
			ui.style.left = `${pos.x}px`;
			ui.style.top = `${pos.y}px`;

			// 新增: 初始化时更新菜单对齐
			this.updateMenuAlignment();
		}
		updateMenuAlignment() {
			const ui = this.shadowRoot.querySelector('.base64-helper');
			const menu = this.menu;
			const windowWidth = window.innerWidth;
			const windowHeight = window.innerHeight;
			const uiRect = ui.getBoundingClientRect();
			const centerX = uiRect.left + uiRect.width / 2;
			const centerY = uiRect.top + uiRect.height / 2;

			// 判断按钮是在页面左半边还是右半边
			if (centerX < windowWidth / 2) {
				// 左对齐
				menu.classList.remove('align-right');
				menu.classList.add('align-left');
			} else {
				// 右对齐
				menu.classList.remove('align-left');
				menu.classList.add('align-right');
			}

			// 判断按钮是在页面上半部分还是下半部分
			if (centerY < windowHeight / 2) {
				// 在页面上方，菜单向下弹出
				menu.classList.remove('popup-top');
				menu.classList.add('popup-bottom');
			} else {
				// 在页面下方，菜单向上弹出
				menu.classList.remove('popup-bottom');
				menu.classList.add('popup-top');
			}
		}
		get positionManager() {
			return {
				get: () => {
					// 使用 storageManager 获取按钮位置
					const saved = storageManager.get(STORAGE_KEYS.BUTTON_POSITION, null);
					if (!saved) return null;

					const ui = this.shadowRoot.querySelector('.base64-helper');
					const maxX = window.innerWidth - ui.offsetWidth - 20;
					const maxY = window.innerHeight - ui.offsetHeight - 20;

					return {
						x: Math.min(Math.max(saved.x, 20), maxX),
						y: Math.min(Math.max(saved.y, 20), maxY),
					};
				},
				set: (x, y) => {
					const ui = this.shadowRoot.querySelector('.base64-helper');
					const pos = {
						x: Math.max(
							20,
							Math.min(x, window.innerWidth - ui.offsetWidth - 20)
						),
						y: Math.max(
							20,
							Math.min(y, window.innerHeight - ui.offsetHeight - 20)
						),
					};

					// 使用 storageManager 存储按钮位置
					storageManager.set(STORAGE_KEYS.BUTTON_POSITION, pos);
					return pos;
				},
			};
		}

		// 初始化事件监听器
		initEventListeners() {
			this.addUnifiedEventListeners();
			this.addGlobalClickListeners();

			// 核心编解码事件监听
			const commonListeners = [
				{
					element: this.decodeBtn,
					events: [
						{
							name: 'click',
							handler: (e) => {
								e.preventDefault();
								e.stopPropagation();
								this.handleDecode();
							},
						},
					],
				},
				{
					element: this.encodeBtn,
					events: [
						{
							name: 'click',
							handler: (e) => {
								e.preventDefault();
								e.stopPropagation();
								this.handleEncode();
							},
						},
					],
				},
			];

			commonListeners.forEach(({ element, events }) => {
				events.forEach(({ name, handler }) => {
					element.addEventListener(name, handler, { passive: false });
					this.eventListeners.push({ element, event: name, handler });
				});
			});
		}

		addUnifiedEventListeners() {
			const ui = this.shadowRoot.querySelector('.base64-helper');
			const btn = this.mainBtn;

			// 统一的开始事件处理
			const startHandler = (e) => {
				e.preventDefault();
				e.stopPropagation();
				const point = e.touches ? e.touches[0] : e;
				this.isDragging = true;
				this.hasMoved = false;
				this.startX = point.clientX;
				this.startY = point.clientY;
				const rect = ui.getBoundingClientRect();
				this.initialX = rect.left;
				this.initialY = rect.top;
				this.startTime = Date.now();
				ui.style.transition = 'none';
				ui.classList.add('dragging');
				btn.style.cursor = 'grabbing';
			};

			// 统一的移动事件处理
			const moveHandler = (e) => {
				if (!this.isDragging) return;
				e.preventDefault();
				e.stopPropagation();

				const point = e.touches ? e.touches[0] : e;
				const moveX = Math.abs(point.clientX - this.startX);
				const moveY = Math.abs(point.clientY - this.startY);

				if (moveX > 5 || moveY > 5) {
					this.hasMoved = true;
					const dx = point.clientX - this.startX;
					const dy = point.clientY - this.startY;
					const newX = Math.min(
						Math.max(20, this.initialX + dx),
						window.innerWidth - ui.offsetWidth - 20
					);
					const newY = Math.min(
						Math.max(20, this.initialY + dy),
						window.innerHeight - ui.offsetHeight - 20
					);
					ui.style.left = `${newX}px`;
					ui.style.top = `${newY}px`;
				}
			};

			// 统一的结束事件处理
			const endHandler = (e) => {
				if (!this.isDragging) return;
				e.preventDefault();
				e.stopPropagation();

				this.isDragging = false;
				ui.classList.remove('dragging');
				btn.style.cursor = 'grab';
				ui.style.transition = 'opacity 0.3s ease';

				const duration = Date.now() - this.startTime;
				if (duration < 200 && !this.hasMoved) {
					this.toggleMenu(e);
				} else if (this.hasMoved) {
					const rect = ui.getBoundingClientRect();
					const pos = this.positionManager.set(rect.left, rect.top);
					ui.style.left = `${pos.x}px`;
					ui.style.top = `${pos.y}px`;
					// 新增: 拖动结束后更新菜单对齐
					this.updateMenuAlignment();
				}
			};

			// 统一收集所有事件监听器
			const listeners = [
				{
					element: ui,
					event: 'touchstart',
					handler: startHandler,
					options: { passive: false },
				},
				{
					element: ui,
					event: 'touchmove',
					handler: moveHandler,
					options: { passive: false },
				},
				{
					element: ui,
					event: 'touchend',
					handler: endHandler,
					options: { passive: false },
				},
				{ element: ui, event: 'mousedown', handler: startHandler },
				{ element: document, event: 'mousemove', handler: moveHandler },
				{ element: document, event: 'mouseup', handler: endHandler },
				{
					element: this.menu,
					event: 'touchstart',
					handler: (e) => e.stopPropagation(),
					options: { passive: false },
				},
				{
					element: this.menu,
					event: 'mousedown',
					handler: (e) => e.stopPropagation(),
				},
				{
					element: window,
					event: 'resize',
					handler: () => this.handleResize(),
				},
			];

			// 注册事件并保存引用
			listeners.forEach(({ element, event, handler, options }) => {
				element.addEventListener(event, handler, options);
				this.eventListeners.push({ element, event, handler, options });
			});
		}

		toggleMenu(e) {
			e?.preventDefault();
			e?.stopPropagation();

			// 如果正在拖动或已移动，不处理菜单切换
			if (this.isDragging || this.hasMoved) return;

			this.menuVisible = !this.menuVisible;
			if (this.menuVisible) {
				// 在显示菜单前更新位置
				this.updateMenuAlignment();
			}
			this.menu.style.display = this.menuVisible ? 'block' : 'none';

			// 重置状态
			this.hasMoved = false;
		}

		addGlobalClickListeners() {
			const handleOutsideClick = (e) => {
				const ui = this.shadowRoot.querySelector('.base64-helper');
				const path = e.composedPath();
				if (!path.includes(ui) && this.menuVisible) {
					this.menuVisible = false;
					this.menu.style.display = 'none';
				}
			};

			// 将全局点击事件添加到 eventListeners 数组
			const globalListeners = [
				{
					element: document,
					event: 'click',
					handler: handleOutsideClick,
					options: true,
				},
				{
					element: document,
					event: 'touchstart',
					handler: handleOutsideClick,
					options: { passive: false },
				},
			];

			globalListeners.forEach(({ element, event, handler, options }) => {
				element.addEventListener(event, handler, options);
				this.eventListeners.push({ element, event, handler, options });
			});
		}

		// 路由监听
		addRouteListeners() {
			this.handleRouteChange = () => {
				clearTimeout(this.routeTimer);
				this.routeTimer = setTimeout(() => this.resetState(), 100);
			};

			// 添加路由相关事件到 eventListeners 数组
			const routeListeners = [
				{ element: window, event: 'popstate', handler: this.handleRouteChange },
				{
					element: window,
					event: 'hashchange',
					handler: this.handleRouteChange,
				},
				{
					element: window,
					event: 'DOMContentLoaded',
					handler: this.handleRouteChange,
				},
			];

			routeListeners.forEach(({ element, event, handler }) => {
				element.addEventListener(event, handler);
				this.eventListeners.push({ element, event, handler });
			});

			// 修改 history 方法
			this.originalPushState = history.pushState;
			this.originalReplaceState = history.replaceState;
			history.pushState = (...args) => {
				this.originalPushState.apply(history, args);
				this.handleRouteChange();
			};
			history.replaceState = (...args) => {
				this.originalReplaceState.apply(history, args);
				this.handleRouteChange();
			};
		}

		/**
		 * 处理页面中的Base64解码操作
		 * @description 根据当前模式执行解码或恢复操作
		 * 如果当前模式是restore则恢复原始内容,否则查找并解码页面中的Base64内容
		 * @fires showNotification 显示操作结果通知
		 */
		handleDecode() {
			// 存储当前模式的变量
			let currentMode = 'decode';

			// 如果按钮存在，使用按钮的模式
			if (this.decodeBtn && this.decodeBtn.dataset.mode === 'restore') {
				currentMode = 'restore';
			}

			// 如果是恢复模式
			if (currentMode === 'restore') {
				this.restoreContent();
				return;
			}

			try {
				// 隐藏菜单
				if (this.menu && this.menu.style.display !== 'none') {
					this.menu.style.display = 'none';
					this.menuVisible = false;
				}

				// 使用 setTimeout 延迟执行以避免界面冻结
				setTimeout(() => {
					try {
						const { nodesToReplace, validDecodedCount } = this.processTextNodes();

						if (validDecodedCount === 0) {
							this.showNotification('本页未发现有效 Base64 内容', 'info');
							this.menuVisible = false;
							this.menu.style.display = 'none';
							return;
						}

						// 分批处理节点替换，避免大量 DOM 操作导致界面冻结
						const BATCH_SIZE = 50; // 每批处理的节点数
						const processNodesBatch = (startIndex) => {
							const endIndex = Math.min(startIndex + BATCH_SIZE, nodesToReplace.length);
							const batch = nodesToReplace.slice(startIndex, endIndex);

							this.replaceNodes(batch);

							if (endIndex < nodesToReplace.length) {
								// 还有更多节点需要处理，安排下一批
								setTimeout(() => processNodesBatch(endIndex), 0);
							} else {
								// 所有节点处理完成，添加点击监听器
								this.addClickListenersToDecodedText();

								this.decodeBtn.textContent = '恢复本页 Base64';
								this.decodeBtn.dataset.mode = 'restore';
								this.showNotification(
									`解析完成，共找到 ${validDecodedCount} 个 Base64 内容`,
									'success'
								);

								// 操作完成后更新菜单命令
								setTimeout(updateMenuCommands, 100);
							}
						};

						// 开始分批处理
						processNodesBatch(0);
					} catch (innerError) {
						console.error('Base64 decode processing error:', innerError);
						this.showNotification(`解析失败: ${innerError.message}`, 'error');
						this.menuVisible = false;
						this.menu.style.display = 'none';
					}
				}, 50); // 给浏览器一点时间渲染通知
			} catch (e) {
				console.error('Base64 decode error:', e);
				this.showNotification(`解析失败: ${e.message}`, 'error');
				this.menuVisible = false;
				this.menu.style.display = 'none';
			}
		}

		/**
		 * 处理文本节点中的Base64内容
		 * @description 遍历文档中的文本节点,查找并处理其中的Base64内容
		 * 注意: 此方法包含性能优化措施，如超时检测和节点过滤
		 * @returns {Object} 处理结果
		 * @property {Array} nodesToReplace - 需要替换的节点数组
		 * @property {number} validDecodedCount - 有效的Base64解码数量
		 */
		processTextNodes() {
			const startTime = Date.now();
			const TIMEOUT = 5000;

			const excludeTags = new Set([
				'script',
				'style',
				'noscript',
				'iframe',
				'img',
				'input',
				'textarea',
				'svg',
				'canvas',
				'template',
				'pre',
				'code',
				'button',
				'meta',
				'link',
				'head',
				'title',
				'select',
				'form',
				'object',
				'embed',
				'video',
				'audio',
				'source',
				'track',
				'map',
				'area',
				'math',
				'figure',
				'picture',
				'portal',
				'slot',
				'data',
				'a',
				'base', // 包含href属性的base标签
				'param', // object的参数
				'applet', // 旧版Java小程序
				'frame', // 框架
				'frameset', // 框架集
				'marquee', // 滚动文本
				'time', // 时间标签
				'wbr', // 可能的换行符
				'bdo', // 文字方向
				'dialog', // 对话框
				'details', // 详情
				'summary', // 摘要
				'menu', // 菜单
				'menuitem', // 菜单项
				'[hidden]', // 隐藏元素
				'[aria-hidden="true"]', // 可访问性隐藏
				'.base64', // 自定义class
				'.encoded', // 自定义class
			]);

			const excludeAttrs = new Set([
				'src',
				'data-src',
				'href',
				'data-url',
				'content',
				'background',
				'poster',
				'data-image',
				'srcset',
				'data-background', // 背景图片
				'data-thumbnail', // 缩略图
				'data-original', // 原始图片
				'data-lazy', // 懒加载
				'data-defer', // 延迟加载
				'data-fallback', // 后备图片
				'data-preview', // 预览图
				'data-avatar', // 头像
				'data-icon', // 图标
				'data-base64', // 显式标记的base64
				'style', // 内联样式可能包含base64
				'integrity', // SRI完整性校验
				'crossorigin', // 跨域属性
				'rel', // 关系属性
				'alt', // 替代文本
				'title', // 标题属性
			]);

			const walker = document.createTreeWalker(
				document.body,
				NodeFilter.SHOW_TEXT,
				{
					acceptNode: (node) => {
						const isExcludedTag = (parent) => {
							const tagName = parent.tagName?.toLowerCase();
							return excludeTags.has(tagName);
						};

						const isHiddenElement = (parent) => {
							if (!(parent instanceof HTMLElement)) return false;
							const style = window.getComputedStyle(parent);
							return (
								style.display === 'none' ||
								style.visibility === 'hidden' ||
								style.opacity === '0' ||
								style.clipPath === 'inset(100%)' ||
								(style.height === '0px' && style.overflow === 'hidden')
							);
						};

						const isOutOfViewport = (parent) => {
							if (!(parent instanceof HTMLElement)) return false;
							const rect = parent.getBoundingClientRect();
							return rect.width === 0 || rect.height === 0;
						};

						const hasBase64Attributes = (parent) => {
							if (!parent.hasAttributes()) return false;
							for (const attr of parent.attributes) {
								if (excludeAttrs.has(attr.name)) {
									const value = attr.value.toLowerCase();
									if (
										value.includes('base64') ||
										value.match(/^[a-z0-9+/=]+$/i)
									) {
										return true;
									}
								}
							}
							return false;
						};

						let parent = node.parentNode;
						while (parent && parent !== document.body) {
							if (
								isExcludedTag(parent) ||
								isHiddenElement(parent) ||
								isOutOfViewport(parent) ||
								hasBase64Attributes(parent)
							) {
								return NodeFilter.FILTER_REJECT;
							}
							parent = parent.parentNode;
						}

						const text = node.textContent?.trim();
						if (!text) {
							return NodeFilter.FILTER_SKIP;
						}

						return /[A-Za-z0-9+/]+/.exec(text)
							? NodeFilter.FILTER_ACCEPT
							: NodeFilter.FILTER_SKIP;
					},
				},
				false
			);

			let nodesToReplace = [];
			let processedMatches = new Set();
			let validDecodedCount = 0;

			while (walker.nextNode()) {
				if (Date.now() - startTime > TIMEOUT) {
					console.warn('Base64 processing timeout');
					break;
				}

				const node = walker.currentNode;
				const { modified, newHtml, count } = this.processMatches(
					node.nodeValue,
					processedMatches
				);
				if (modified) {
					nodesToReplace.push({ node, newHtml });
					validDecodedCount += count;
				}
			}

			return { nodesToReplace, validDecodedCount };
		}

		/**
		 * 处理文本中的Base64匹配项
		 * @description 查找并处理文本中的Base64编码内容
		 * @param {string} text - 要处理的文本内容
		 * @param {Set} processedMatches - 已处理过的匹配项集合
		 * @returns {Object} 处理结果
		 * @property {boolean} modified - 文本是否被修改
		 * @property {string} newHtml - 处理后的HTML内容
		 * @property {number} count - 处理的Base64数量
		 */
		processMatches(text, processedMatches) {
			const matches = Array.from(text.matchAll(BASE64_REGEX));
			if (!matches.length) return { modified: false, newHtml: text, count: 0 };

			let modified = false;
			let newHtml = text;
			let count = 0;

			for (const match of matches.reverse()) {
				const original = match[0];

				// 使用 validateBase64 进行验证
				if (!this.validateBase64(original)) {
					console.log('Skipped: invalid Base64 string');
					continue;
				}

				try {
					const decoded = this.decodeBase64(original);
					console.log('Decoded:', decoded);

					if (!decoded) {
						console.log('Skipped: decode failed');
						continue;
					}

					// 将原始Base64和位置信息添加到已处理集合中，防止重复处理
					const matchKey = `${original}-${match.index}`;
					processedMatches.add(matchKey);

					// 构建新的HTML内容:
					// 1. 保留匹配位置之前的内容
					const beforeMatch = newHtml.substring(0, match.index);
					// 2. 插入解码后的内容，包装在span标签中
					const decodedSpan = `<span class="decoded-text"
						title="点击复制"
						data-original="${original}">${decoded}</span>`;
					// 3. 保留匹配位置之后的内容
					const afterMatch = newHtml.substring(match.index + original.length);

					// 组合新的HTML
					newHtml = beforeMatch + decodedSpan + afterMatch;

					// 标记内容已被修改
					modified = true;
					// 增加成功解码计数
					count++;

					// 记录日志
					console.log('成功解码: 发现有意义的文本或中文字符');
				} catch (e) {
					console.error('Error processing:', e);
					continue;
				}
			}

			return { modified, newHtml, count };
		}

		/**
		 * 判断文本是否有意义
		 * @description 通过一系列规则判断解码后的文本是否具有实际意义
		 * @param {string} text - 要验证的文本
		 * @returns {boolean} 如果文本有意义返回true,否则返回false
		 */
		isMeaningfulText(text) {
			// 1. 基本字符检查
			if (!text || typeof text !== 'string') return false;

			// 2. 长度检查
			if (text.length < 2 || text.length > 10000) return false;

			// 3. 文本质量检查
			const stats = {
				printable: 0, // 可打印字符
				control: 0, // 控制字符
				chinese: 0, // 中文字符
				letters: 0, // 英文字母
				numbers: 0, // 数字
				punctuation: 0, // 标点符号
				spaces: 0, // 空格
				other: 0, // 其他字符
			};

			// 统计字符分布
			for (let i = 0; i < text.length; i++) {
				const char = text.charAt(i);
				const code = text.charCodeAt(i);

				if (/[\u4E00-\u9FFF]/.test(char)) {
					stats.chinese++;
					stats.printable++;
				} else if (/[a-zA-Z]/.test(char)) {
					stats.letters++;
					stats.printable++;
				} else if (/[0-9]/.test(char)) {
					stats.numbers++;
					stats.printable++;
				} else if (/[\s]/.test(char)) {
					stats.spaces++;
					stats.printable++;
				} else if (/[!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]/.test(char)) {
					stats.punctuation++;
					stats.printable++;
				} else if (code < 32 || code === 127) {
					stats.control++;
				} else {
					stats.other++;
				}
			}

			// 4. 质量评估规则
			const totalChars = text.length;
			const printableRatio = stats.printable / totalChars;
			const controlRatio = stats.control / totalChars;
			const meaningfulRatio =
				(stats.chinese + stats.letters + stats.numbers) / totalChars;

			// 判断条件：
			// 1. 可打印字符比例必须大于90%
			// 2. 控制字符比例必须小于5%
			// 3. 有意义字符(中文、英文、数字)比例必须大于30%
			// 4. 空格比例不能过高(小于50%)
			// 5. 其他字符比例必须很低(小于10%)
			return (
				printableRatio > 0.9 &&
				controlRatio < 0.05 &&
				meaningfulRatio > 0.3 &&
				stats.spaces / totalChars < 0.5 &&
				stats.other / totalChars < 0.1
			);
		}

		/**
		 * 替换页面中的节点
		 * @description 使用新的HTML内容替换原有节点
		 * @param {Array} nodesToReplace - 需要替换的节点数组
		 * @param {Node} nodesToReplace[].node - 原始节点
		 * @param {string} nodesToReplace[].newHtml - 新的HTML内容
		 */
		replaceNodes(nodesToReplace) {
			nodesToReplace.forEach(({ node, newHtml }) => {
				const span = document.createElement('span');
				span.innerHTML = newHtml;
				node.parentNode.replaceChild(span, node);
			});
		}

		/**
		 * 为解码后的文本添加点击复制功能
		 * @description 为所有解码后的文本元素添加点击事件监听器
		 * @fires copyToClipboard 点击时触发复制操作
		 * @fires showNotification 显示复制结果通知
		 */
		addClickListenersToDecodedText() {
			document.querySelectorAll('.decoded-text').forEach((el) => {
				el.addEventListener('click', async (e) => {
					const success = await this.copyToClipboard(e.target.textContent);
					this.showNotification(
						success ? '已复制文本内容' : '复制失败，请手动复制',
						success ? 'success' : 'error'
					);
					e.stopPropagation();
				});
			});
		}

		/**
		 * 处理文本编码为Base64
		 * @description 提示用户输入文本并转换为Base64格式
		 * @async
		 * @fires showNotification 显示编码结果通知
		 * @fires copyToClipboard 复制编码结果到剪贴板
		 */
		async handleEncode() {
			// 隐藏菜单
			if (this.menu && this.menu.style.display !== 'none') {
				this.menu.style.display = 'none';
				this.menuVisible = false;
			}

			const text = prompt('请输入要编码的文本：');
			if (text === null) return; // 用户点击取消

			// 添加空输入检查
			if (!text.trim()) {
				this.showNotification('请输入有效的文本内容', 'error');
				return;
			}

			try {
				// 处理输入文本：去除首尾空格和多余的换行符
				const processedText = text.trim().replace(/[\r\n]+/g, '\n');
				const encoded = this.encodeBase64(processedText);
				const success = await this.copyToClipboard(encoded);
				this.showNotification(
					success
						? 'Base64 已复制'
						: '编码成功但复制失败，请手动复制：' + encoded,
					success ? 'success' : 'info'
				);
			} catch (e) {
				this.showNotification('编码失败: ' + e.message, 'error');
			}
		}

		/**
		 * 验证Base64字符串
		 * @description 检查字符串是否为有效的Base64格式
		 * @param {string} str - 要验证的字符串
		 * @returns {boolean} 如果是有效的Base64返回true,否则返回false
		 * @example
		 * validateBase64('SGVsbG8gV29ybGQ=') // returns true
		 * validateBase64('Invalid-Base64') // returns false
		 */
		validateBase64(str) {
			if (!str) return false;

			// 使用缓存避免重复验证
			if (this.base64Cache.has(str)) {
				return this.base64Cache.get(str);
			}

			// 检查缓存大小并在必要时清理
			if (this.base64Cache.size >= this.MAX_CACHE_SIZE) {
				// 删除最早添加的缓存项
				const oldestKey = this.base64Cache.keys().next().value;
				this.base64Cache.delete(oldestKey);
			}

			// 1. 基本格式检查
			// - 长度必须是4的倍数
			// - 只允许包含合法的Base64字符
			// - =号只能出现在末尾，且最多2个
			if (
				!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(
					str
				)
			) {
				this.base64Cache.set(str, false);
				return false;
			}

			// 2. 长度检查
			// 过滤掉太短的字符串(至少8个字符)和过长的字符串(最多10000个字符)
			if (str.length < 8 || str.length > 10000) {
				this.base64Cache.set(str, false);
				return false;
			}

			// 3. 特征检查
			// 过滤掉可能是图片、视频等二进制数据的Base64
			if (/^(?:data:|iVBOR|R0lGO|\/9j\/4|PD94bW|JVBER)/.test(str)) {
				this.base64Cache.set(str, false);
				return false;
			}

			// 添加到 validateBase64 方法中
			const commonPatterns = {
				// 常见的二进制数据头部特征
				binaryHeaders:
					/^(?:data:|iVBOR|R0lGO|\/9j\/4|PD94bW|JVBER|UEsDB|H4sIA|77u\/|0M8R4)/,

				// 常见的文件类型标识
				fileSignatures: /^(?:UEs|PK|%PDF|GIF8|RIFF|OggS|ID3|ÿØÿ|8BPS)/,

				// 常见的编码标识
				encodingMarkers:
					/^(?:utf-8|utf-16|base64|quoted-printable|7bit|8bit|binary)/i,

				// 可疑的URL模式
				urlPatterns: /^(?:https?:|ftp:|data:|blob:|file:|ws:|wss:)/i,

				// 常见的压缩文件头部
				compressedHeaders: /^(?:eJw|H4s|Qk1Q|UEsD|N3q8|KLUv)/,
			};

			// 在验证时使用这些模式
			if (
				commonPatterns.binaryHeaders.test(str) ||
				commonPatterns.fileSignatures.test(str) ||
				commonPatterns.encodingMarkers.test(str) ||
				commonPatterns.urlPatterns.test(str) ||
				commonPatterns.compressedHeaders.test(str)
			) {
				this.base64Cache.set(str, false);
				return false;
			}

			try {
				const decoded = this.decodeBase64(str);
				if (!decoded) {
					this.base64Cache.set(str, false);
					return false;
				}

				// 4. 解码后的文本验证
				// 检查解码后的文本是否有意义
				if (!this.isMeaningfulText(decoded)) {
					this.base64Cache.set(str, false);
					return false;
				}

				this.base64Cache.set(str, true);
				return true;
			} catch (e) {
				console.error('Base64 validation error:', e);
				this.base64Cache.set(str, false);
				return false;
			}
		}

		/**
		 * Base64解码
		 * @description 将Base64字符串解码为普通文本
		 * @param {string} str - 要解码的Base64字符串
		 * @returns {string|null} 解码后的文本,解码失败时返回null
		 * @example
		 * decodeBase64('SGVsbG8gV29ybGQ=') // returns 'Hello World'
		 */
		decodeBase64(str) {
			try {
				// 优化解码过程
				const binaryStr = atob(str);
				const bytes = new Uint8Array(binaryStr.length);
				for (let i = 0; i < binaryStr.length; i++) {
					bytes[i] = binaryStr.charCodeAt(i);
				}
				return new TextDecoder().decode(bytes);
			} catch (e) {
				console.error('Base64 decode error:', e);
				return null;
			}
		}

		/**
		 * Base64编码
		 * @description 将普通文本编码为Base64格式
		 * @param {string} str - 要编码的文本
		 * @returns {string|null} Base64编码后的字符串,编码失败时返回null
		 * @example
		 * encodeBase64('Hello World') // returns 'SGVsbG8gV29ybGQ='
		 */
		encodeBase64(str) {
			try {
				// 优化编码过程
				const bytes = new TextEncoder().encode(str);
				let binaryStr = '';
				for (let i = 0; i < bytes.length; i++) {
					binaryStr += String.fromCharCode(bytes[i]);
				}
				return btoa(binaryStr);
			} catch (e) {
				console.error('Base64 encode error:', e);
				return null;
			}
		}

		/**
		 * 复制文本到剪贴板
		 * @description 尝试使用现代API或降级方案将文本复制到剪贴板
		 * @param {string} text - 要复制的文本
		 * @returns {Promise<boolean>} 复制是否成功
		 * @example
		 * await copyToClipboard('Hello World') // returns true
		 */
		async copyToClipboard(text) {
			if (navigator.clipboard && window.isSecureContext) {
				try {
					await navigator.clipboard.writeText(text);
					return true;
				} catch (e) {
					return this.fallbackCopy(text);
				}
			}

			return this.fallbackCopy(text);
		}

		/**
		 * 降级复制方案
		 * @description 当现代复制API不可用时的备选复制方案
		 * @param {string} text - 要复制的文本
		 * @returns {boolean} 复制是否成功
		 * @private
		 */
		fallbackCopy(text) {
			if (typeof GM_setClipboard !== 'undefined') {
				try {
					GM_setClipboard(text);
					return true;
				} catch (e) {
					console.debug('GM_setClipboard failed:', e);
				}
			}

			try {
				// 注意: execCommand 已经被废弃，但作为降级方案仍然有用
				const textarea = document.createElement('textarea');
				textarea.value = text;
				textarea.style.cssText = 'position:fixed;opacity:0;';
				document.body.appendChild(textarea);

				if (navigator.userAgent.match(/ipad|iphone/i)) {
					textarea.contentEditable = true;
					textarea.readOnly = false;

					const range = document.createRange();
					range.selectNodeContents(textarea);

					const selection = window.getSelection();
					selection.removeAllRanges();
					selection.addRange(range);
					textarea.setSelectionRange(0, 999999);
				} else {
					textarea.select();
				}

				// 使用 try-catch 包裹 execCommand 调用，以防将来完全移除
				let success = false;
				try {
					// @ts-ignore - 忽略废弃警告
					success = document.execCommand('copy');
				} catch (copyError) {
					console.debug('execCommand copy operation failed:', copyError);
				}

				document.body.removeChild(textarea);
				return success;
			} catch (e) {
				console.debug('Fallback copy method failed:', e);
				return false;
			}
		}

		/**
		 * 恢复原始内容
		 * @description 将所有解码后的内容恢复为原始的Base64格式
		 * @fires showNotification 显示恢复结果通知
		 */
		restoreContent() {
			document.querySelectorAll('.decoded-text').forEach((el) => {
				const textNode = document.createTextNode(el.dataset.original);
				el.parentNode.replaceChild(textNode, el);
			});
			this.originalContents.clear();

			// 如果按钮存在，更新按钮状态
			if (this.decodeBtn) {
				this.decodeBtn.textContent = '解析本页 Base64';
				this.decodeBtn.dataset.mode = 'decode';
			}

			this.showNotification('已恢复原始内容', 'success');

			// 只有当按钮可见时才隐藏菜单
			if (!this.config.hideButton && this.menu) {
				this.menu.style.display = 'none';
			}

			// 操作完成后更新菜单命令
			setTimeout(updateMenuCommands, 100);
		}

		/**
		 * 重置插件状态
		 * @description 重置所有状态变量并在必要时恢复原始内容
		 * 如果启用了自动解码，则在路由变化后自动解析页面
		 * @fires restoreContent 如果当前处于restore模式则触发内容恢复
		 * @fires handleDecode 如果启用了自动解码则触发自动解码
		 */
		resetState() {
			// 检查是否需要恢复内容
			let needRestore = false;

			// 如果按钮存在，检查按钮状态
			if (this.decodeBtn && this.decodeBtn.dataset.mode === 'restore') {
				needRestore = true;
			} else {
				// 如果按钮不存在，检查页面上是否有解码后的内容
				needRestore = document.querySelectorAll('.decoded-text').length > 0;
			}

			if (needRestore) {
				this.restoreContent();
			}

			// 如果启用了自动解码，则在路由变化后自动解析页面
			if (this.config.autoDecode) {
				// 使用延时确保页面内容已更新
				setTimeout(() => this.handleDecode(), 500);
			}
		}

		/**
		 * 为通知添加动画效果
		 * @param {HTMLElement} notification - 通知元素
		 */
		animateNotification(notification) {
			const currentTransform = getComputedStyle(notification).transform;
			notification.style.transform = currentTransform;
			notification.style.transition = 'all 0.3s ease-out';
			notification.style.transform = 'translateY(-100%)';
		}

		/**
		 * 处理通知淡出效果
		 * @description 为通知添加淡出效果并处理相关动画
		 * @param {HTMLElement} notification - 要处理的通知元素
		 * @fires animateNotification 触发其他通知的位置调整动画
		 */
		handleNotificationFadeOut(notification) {
			notification.classList.add('fade-out');
			const index = this.notifications.indexOf(notification);

			this.notifications.slice(0, index).forEach((prev) => {
				if (prev.parentNode) {
					prev.style.transform = 'translateY(-100%)';
				}
			});
		}

		/**
		 * 清理通知容器
		 * @description 移除所有通知元素和相关事件监听器
		 * @fires removeEventListener 移除所有通知相关的事件监听器
		 */
		cleanupNotificationContainer() {
			// 清理通知相关的事件监听器
			this.notificationEventListeners.forEach(({ element, event, handler }) => {
				element.removeEventListener(event, handler);
			});
			this.notificationEventListeners = [];

			// 移除所有通知元素
			while (this.notificationContainer.firstChild) {
				this.notificationContainer.firstChild.remove();
			}

			this.notificationContainer.remove();
			this.notificationContainer = null;
		}

		/**
		 * 处理通知过渡结束事件
		 * @description 处理通知元素的过渡动画结束后的清理工作
		 * @param {TransitionEvent} e - 过渡事件对象
		 * @fires animateNotification 触发其他通知的位置调整
		 */
		handleNotificationTransitionEnd(e) {
			if (
				e.propertyName === 'opacity' &&
				e.target.classList.contains('fade-out')
			) {
				const notification = e.target;
				const index = this.notifications.indexOf(notification);

				this.notifications.forEach((notif, i) => {
					if (i > index && notif.parentNode) {
						this.animateNotification(notif);
					}
				});

				if (index > -1) {
					this.notifications.splice(index, 1);
					notification.remove();
				}

				if (this.notifications.length === 0) {
					this.cleanupNotificationContainer();
				}
			}
		}

		/**
		 * 显示通知消息
		 * @description 创建并显示一个通知消息,包含自动消失功能
		 * @param {string} text - 通知文本内容
		 * @param {string} type - 通知类型 ('success'|'error'|'info')
		 * @fires handleNotificationFadeOut 触发通知淡出效果
		 * @example
		 * showNotification('操作成功', 'success')
		 */
		showNotification(text, type) {
			// 如果禁用了通知，则不显示
			if (this.config && !this.config.showNotification) {
				console.log(`[Base64 Helper] ${type}: ${text}`);
				return;
			}

			if (!this.notificationContainer) {
				this.notificationContainer = document.createElement('div');
				this.notificationContainer.className = 'base64-notifications-container';
				document.body.appendChild(this.notificationContainer);

				const handler = (e) => this.handleNotificationTransitionEnd(e);
				this.notificationContainer.addEventListener('transitionend', handler);
				this.notificationEventListeners.push({
					element: this.notificationContainer,
					event: 'transitionend',
					handler,
				});
			}

			const notification = document.createElement('div');
			notification.className = 'base64-notification';
			notification.setAttribute('data-type', type);
			notification.textContent = text;

			this.notifications.push(notification);
			this.notificationContainer.appendChild(notification);

			setTimeout(() => {
				if (notification.parentNode) {
					this.handleNotificationFadeOut(notification);
				}
			}, 2000);
		}

		/**
		 * 销毁插件实例
		 * @description 清理所有资源,移除事件监听器,恢复原始状态
		 * @fires restoreContent 如果需要则恢复原始内容
		 * @fires removeEventListener 移除所有事件监听器
		 */
		destroy() {
			// 清理所有事件监听器
			this.eventListeners.forEach(({ element, event, handler, options }) => {
				element.removeEventListener(event, handler, options);
			});
			this.eventListeners = [];

			// 清理配置监听器
			if (this.configListeners) {
				Object.values(this.configListeners).forEach(listenerId => {
					if (listenerId) {
						storageManager.removeChangeListener(listenerId);
					}
				});
				// 重置配置监听器
				this.configListeners = {
					showNotification: null,
					hideButton: null,
					autoDecode: null,
					buttonPosition: null
				};
			}

			// 清理定时器
			if (this.resizeTimer) clearTimeout(this.resizeTimer);
			if (this.routeTimer) clearTimeout(this.routeTimer);

			// 清理通知相关资源
			if (this.notificationContainer) {
				this.cleanupNotificationContainer();
			}
			this.notifications = [];

			// 恢复原始的 history 方法
			if (this.originalPushState) history.pushState = this.originalPushState;
			if (this.originalReplaceState)
				history.replaceState = this.originalReplaceState;

			// 恢复原始状态
			if (this.decodeBtn?.dataset.mode === 'restore') {
				this.restoreContent();
			}

			// 移除 DOM 元素
			if (this.container) {
				this.container.remove();
			}

			// 清理缓存
			if (this.base64Cache) {
				this.base64Cache.clear();
			}

			// 清理引用
			this.shadowRoot = null;
			this.mainBtn = null;
			this.menu = null;
			this.decodeBtn = null;
			this.encodeBtn = null;
			this.container = null;
			this.originalContents.clear();
			this.originalContents = null;
			this.isDragging = false;
			this.hasMoved = false;
			this.menuVisible = false;
			this.base64Cache = null;
			this.configListeners = null;
		}
	}

	// 确保只初始化一次
	if (window.__base64HelperInstance) {
		return;
	}

	// 只在主窗口中初始化
	if (window.top === window.self) {
		initStyles();
		window.__base64HelperInstance = new Base64Helper();

		// 注册油猴菜单命令
		registerMenuCommands();
	}

	// 使用 { once: true } 确保事件监听器只添加一次
	window.addEventListener(
		'unload',
		() => {
			if (window.__base64HelperInstance) {
				window.__base64HelperInstance.destroy();
				delete window.__base64HelperInstance;
			}
		},
		{ once: true }
	);
})();