background.js

/**
 * 书签清理助手 - 后台服务脚本
 */

// 监听插件安装事件
chrome.runtime.onInstalled.addListener((details) => {
    console.log('书签清理助手已安装:', details.reason);
});

// 监听插件图标点击事件
chrome.action.onClicked.addListener(async (tab) => {
    console.log('插件图标被点击，当前标签页:', tab);
    
    try {
        // 检查当前标签页是否支持内容脚本注入
        const isSupportedUrl = tab.url && (tab.url.startsWith('http://') || tab.url.startsWith('https://'));
        
        if (isSupportedUrl) {
            console.log('当前页面支持内容脚本注入');
            
            // 尝试发送消息给内容脚本
            try {
                const response = await chrome.tabs.sendMessage(tab.id, { action: 'openSidebar' });
                console.log('收到响应:', response);
            } catch (error) {
                console.log('内容脚本未加载，尝试注入');
                
                // 检查是否已经注入过
                try {
                    const checkResponse = await chrome.scripting.executeScript({
                        target: { tabId: tab.id },
                        func: () => window.bookmarkSidebarInstance ? true : false
                    });
                    
                    if (checkResponse[0].result) {
                        console.log('检测到已存在的实例，直接发送消息');
                        const response = await chrome.tabs.sendMessage(tab.id, { action: 'openSidebar' });
                        console.log('收到响应:', response);
                        return;
                    }
                } catch (checkError) {
                    console.log('检查实例失败，继续注入:', checkError);
                }
                
                // 注入内容脚本
                await chrome.scripting.executeScript({
                    target: { tabId: tab.id },
                    files: ['content.js']
                });
                
                // 等待后发送消息
                setTimeout(async () => {
                    try {
                        const response = await chrome.tabs.sendMessage(tab.id, { action: 'openSidebar' });
                        console.log('注入后收到响应:', response);
                    } catch (e) {
                        console.error('注入后仍无法打开侧边栏:', e);
                    }
                }, 500);
            }
        } else {
            // 如果当前页面不支持内容脚本，打开一个普通网页
            console.log('当前页面不支持内容脚本，打开新标签页');
            const newTab = await chrome.tabs.create({ 
                url: 'https://www.google.com',
                active: true 
            });
            
            // 等待新标签页加载完成
            setTimeout(async () => {
                try {
                    await chrome.scripting.executeScript({
                        target: { tabId: newTab.id },
                        files: ['content.js']
                    });
                    
                    setTimeout(() => {
                        chrome.tabs.sendMessage(newTab.id, { action: 'openSidebar' });
                    }, 500);
                } catch (error) {
                    console.error('在新标签页注入脚本失败:', error);
                }
            }, 1000);
        }
    } catch (error) {
        console.error('处理插件点击事件时出错:', error);
        
        // 如果出错，尝试打开新标签页作为备选方案
        try {
            console.log('尝试打开新标签页作为备选方案');
            const newTab = await chrome.tabs.create({ 
                url: 'https://www.google.com',
                active: true 
            });
            
            setTimeout(async () => {
                try {
                    await chrome.scripting.executeScript({
                        target: { tabId: newTab.id },
                        files: ['content.js']
                    });
                    
                    setTimeout(() => {
                        chrome.tabs.sendMessage(newTab.id, { action: 'openSidebar' });
                    }, 500);
                } catch (error) {
                    console.error('备选方案也失败了:', error);
                }
            }, 1000);
        } catch (fallbackError) {
            console.error('备选方案失败:', fallbackError);
        }
    }
});

// 监听来自content script的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
    switch (request.action) {
        case 'getBookmarks':
            handleGetBookmarks(sendResponse);
            return true;
            
        case 'getBookmarkFolders':
            handleGetBookmarkFolders(sendResponse);
            return true;
            
        case 'getBookmarksByFolder':
            handleGetBookmarksByFolder(request.folderId, sendResponse);
            return true;
            
        case 'checkBookmarkValidity':
            handleCheckBookmarkValidity(request.url, request.timeout, sendResponse);
            return true;
            
        case 'deleteBookmark':
            handleDeleteBookmark(request.bookmarkId, sendResponse);
            return true;
            
        case 'moveToInvalidFolder':
            handleMoveToInvalidFolder(request.bookmarkIds, sendResponse);
            return true;
            
        default:
            sendResponse({ error: '未知操作' });
    }
});

function handleGetBookmarks(sendResponse) {
    chrome.bookmarks.getTree((bookmarkTreeNodes) => {
        const bookmarks = [];
        
        const extractBookmarks = (nodes) => {
            for (const node of nodes) {
                if (node.url) {
                    bookmarks.push({
                        id: node.id,
                        title: node.title,
                        url: node.url,
                        parentId: node.parentId,
                        dateAdded: node.dateAdded
                    });
                } else if (node.children) {
                    extractBookmarks(node.children);
                }
            }
        };
        
        extractBookmarks(bookmarkTreeNodes);
        sendResponse({ success: true, bookmarks });
    });
}

function handleGetBookmarkFolders(sendResponse) {
    chrome.bookmarks.getTree((bookmarkTreeNodes) => {
        const folders = [];
        
        const extractFolders = (nodes, level = 0, parentPath = '') => {
            for (const node of nodes) {
                if (!node.url && node.children) {
                    const currentPath = parentPath ? `${parentPath} > ${node.title}` : node.title;
                    
                    // 检查是否包含书签（递归检查）
                    const hasBookmarks = checkHasBookmarks(node);
                    
                    folders.push({
                        id: node.id,
                        title: node.title,
                        level: level,
                        parentId: node.parentId,
                        childrenCount: node.children.length,
                        path: currentPath,
                        hasBookmarks: hasBookmarks,
                        hasSubFolders: node.children.some(child => !child.url && child.children)
                    });
                    
                    // 递归处理子文件夹
                    extractFolders(node.children, level + 1, currentPath);
                }
            }
        };
        
        // 递归检查文件夹是否包含书签
        function checkHasBookmarks(node) {
            if (node.url) return true;
            if (node.children) {
                return node.children.some(child => checkHasBookmarks(child));
            }
            return false;
        }
        
        extractFolders(bookmarkTreeNodes);
        console.log('获取到的文件夹:', folders);
        sendResponse({ success: true, folders });
    });
}

function handleGetBookmarksByFolder(folderId, sendResponse) {
    chrome.bookmarks.getSubTree(folderId, (bookmarkTreeNodes) => {
        const bookmarks = [];
        
        const extractBookmarks = (nodes) => {
            for (const node of nodes) {
                if (node.url) {
                    bookmarks.push({
                        id: node.id,
                        title: node.title,
                        url: node.url,
                        parentId: node.parentId,
                        dateAdded: node.dateAdded
                    });
                } else if (node.children) {
                    // 递归获取子文件夹中的书签
                    extractBookmarks(node.children);
                }
            }
        };
        
        if (bookmarkTreeNodes && bookmarkTreeNodes.length > 0) {
            extractBookmarks(bookmarkTreeNodes);
        }
        
        console.log(`获取文件夹 ${folderId} 的书签，共 ${bookmarks.length} 个`);
        sendResponse({ success: true, bookmarks });
    });
}

function handleMoveToInvalidFolder(bookmarkIds, sendResponse) {
    // 首先检查是否存在"失效书签"文件夹
    chrome.bookmarks.getTree((bookmarkTreeNodes) => {
        let invalidFolderId = null;
        
        const findInvalidFolder = (nodes) => {
            for (const node of nodes) {
                if (!node.url && node.title === '失效书签') {
                    invalidFolderId = node.id;
                    return;
                } else if (node.children) {
                    findInvalidFolder(node.children);
                }
            }
        };
        
        findInvalidFolder(bookmarkTreeNodes);
        
        if (!invalidFolderId) {
            // 创建"失效书签"文件夹
            chrome.bookmarks.create({
                title: '失效书签',
                parentId: '1' // 书签栏
            }, (folder) => {
                invalidFolderId = folder.id;
                moveBookmarks(bookmarkIds, invalidFolderId, sendResponse);
            });
        } else {
            moveBookmarks(bookmarkIds, invalidFolderId, sendResponse);
        }
    });
}

function moveBookmarks(bookmarkIds, folderId, sendResponse) {
    let movedCount = 0;
    let errorCount = 0;
    
    const moveNext = (index) => {
        if (index >= bookmarkIds.length) {
            sendResponse({ 
                success: true, 
                movedCount: movedCount, 
                errorCount: errorCount 
            });
            return;
        }
        
        chrome.bookmarks.move(bookmarkIds[index], {
            parentId: folderId
        }, (bookmark) => {
            if (chrome.runtime.lastError) {
                errorCount++;
                console.error('移动书签失败:', chrome.runtime.lastError);
            } else {
                movedCount++;
            }
            moveNext(index + 1);
        });
    };
    
    moveNext(0);
}

async function handleCheckBookmarkValidity(url, timeout, sendResponse) {
    try {
        const urlObj = new URL(url);
        const hostname = urlObj.hostname;
        
        if (isPrivateIP(hostname)) {
            sendResponse({ success: true, isValid: true, isPrivate: true });
            return;
        }
        
        if (isSpecialProtocol(urlObj.protocol)) {
            sendResponse({ success: true, isValid: true, isPrivate: false });
            return;
        }
        
        const isValid = await checkNetworkAccess(url, timeout);
        sendResponse({ success: true, isValid, isPrivate: false });
        
    } catch (error) {
        sendResponse({ success: false, error: error.message, isValid: false });
    }
}

function handleDeleteBookmark(bookmarkId, sendResponse) {
    chrome.bookmarks.remove(bookmarkId, () => {
        if (chrome.runtime.lastError) {
            sendResponse({ success: false, error: chrome.runtime.lastError.message });
        } else {
            sendResponse({ success: true });
        }
    });
}

function isPrivateIP(hostname) {
    const ipRegex = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
    const match = hostname.match(ipRegex);
    
    if (!match) return false;
    
    const [, a, b] = match.map(Number);
    
    return (
        (a === 127) ||
        (a === 10) ||
        (a === 172 && b >= 16 && b <= 31) ||
        (a === 192 && b === 168) ||
        (a === 169 && b === 254) ||
        (a >= 224)
    );
}

function isSpecialProtocol(protocol) {
    const specialProtocols = ['chrome:', 'chrome-extension:', 'moz-extension:', 'file:', 'data:', 'about:'];
    return specialProtocols.includes(protocol);
}

async function checkNetworkAccess(url, timeoutMs = 15000) {
    return new Promise((resolve) => {
        const timeout = setTimeout(() => resolve(false), timeoutMs);
        
        fetch(url, { method: 'HEAD', mode: 'no-cors' })
            .then(() => {
                clearTimeout(timeout);
                resolve(true);
            })
            .catch(() => {
                clearTimeout(timeout);
                resolve(false);
            });
    });
}