script.js

// 测试的节点列表（固定）
const testDomains = [
    "https://blockhaity.github.io",
    "https://blockhaity.vercel.app",
    "https://blockhaity.netlify.app",
    "https://blockhaity.pages.dev",
    "https://blog-vercel.blockhaity.dpdns.org",
    "https://blog-edgeone.blockhaity.qzz.io"
];

// 存储测试结果
const testResults = [];
let fastestDomain = null;
let countdown = 3;
let countdownInterval;
let targetPath = "/"; // 默认路径为根目录

// 背景图片缓存状态
const cacheStatus = document.getElementById('cache-status');

// 缓存背景图片
async function cacheBackgroundImage() {
    const imageUrl = 'https://api.blockhaity.qzz.io/images';
    const cacheName = 'banner-cache-v1';

    try {
        // 检查浏览器是否支持Cache API
        if (!('caches' in window)) {
            cacheStatus.textContent = '缓存API不支持';
            return;
        }

        // 打开缓存
        const cache = await caches.open(cacheName);

        // 检查图片是否已在缓存中
        const cachedResponse = await cache.match(imageUrl);
        if (cachedResponse) {
            cacheStatus.textContent = '背景缓存: 已加载';
            return;
        }

        // 如果不在缓存中，则获取并缓存
        const response = await fetch(imageUrl);
        if (response.ok) {
            await cache.put(imageUrl, response.clone());
            cacheStatus.textContent = '背景缓存: 已加载';
        } else {
            cacheStatus.textContent = '背景缓存: 加载失败';
        }
    } catch (error) {
        console.error('缓存背景图片失败:', error);
        cacheStatus.textContent = '背景缓存: 失败';
    }
}

// 从URL参数获取目标路径
function getTargetPathFromUrl() {
    const params = new URLSearchParams(window.location.search);
    const pathParam = params.get('target');

    // 确保路径以斜杠开头
    if (pathParam) {
        return pathParam.startsWith('/') ? pathParam : '/' + pathParam;
    }
    return "/"; // 未提供参数时默认使用根路径
}

// 初始化节点列表
function initDomainList() {
    targetPath = getTargetPathFromUrl();
    document.getElementById('path-display').textContent = targetPath;

    const urlList = document.getElementById('url-list');
    urlList.innerHTML = '';

    testDomains.forEach((domain, index) => {
        const urlItem = document.createElement('div');
        urlItem.className = 'url-item loading';
        urlItem.id = `domain-${index}`;
        urlItem.innerHTML = `
                    <div class="url-icon">
                        <i class="fas fa-globe"></i>
                    </div>
                    <div class="url-details">
                        <div class="url-name">${domain}</div>
                        <div class="url-status">
                            <div class="ping-value">-</div>
                            <div class="status-text">测试中...</div>
                        </div>
                    </div>
                `;
        urlList.appendChild(urlItem);
    });
}

// 测试单个节点的速度
function testDomainSpeed(domain, index) {
    return new Promise((resolve) => {
        const startTime = performance.now();
        const timeout = 5000; // 5秒超时
        const controller = new AbortController();
        const timeoutId = setTimeout(() => {
            controller.abort();
            resolve({ domain, time: Infinity, status: 'timeout' });
        }, timeout);

        // 测试节点根路径
        const testUrl = domain + '/';

        fetch(testUrl, {
            method: 'HEAD',
            mode: 'no-cors',
            signal: controller.signal
        })
            .then(() => {
                clearTimeout(timeoutId);
                const time = performance.now() - startTime;
                resolve({ domain, time, status: 'success' });
            })
            .catch(() => {
                clearTimeout(timeoutId);
                resolve({ domain, time: Infinity, status: 'error' });
            });
    });
}

// 更新UI显示测试结果
function updateDomainResult(index, result) {
    const domainItem = document.getElementById(`domain-${index}`);
    if (!domainItem) return;

    const pingValue = domainItem.querySelector('.ping-value');
    const statusText = domainItem.querySelector('.status-text');

    // 更新类名
    domainItem.classList.remove('loading');
    if (result.status === 'success') {
        domainItem.classList.add('success');
        statusText.textContent = '成功';
        statusText.style.color = '#2ecc71';
        pingValue.textContent = `${Math.round(result.time)}ms`;
        pingValue.style.color = '#feb47b';

        // 更新最快结果
        if (!fastestDomain || result.time < fastestDomain.time) {
            fastestDomain = result;
            document.getElementById('fastest-ping').textContent = `${Math.round(result.time)}ms`;
        }
    } else {
        domainItem.classList.add('error');
        statusText.textContent = result.status === 'timeout' ? '超时' : '错误';
        statusText.style.color = '#e74c3c';
        pingValue.textContent = '失败';
        pingValue.style.color = '#e74c3c';
    }

    // 更新已测试计数
    const testedCount = document.querySelectorAll('.url-item:not(.loading)').length;
    document.getElementById('tested-count').textContent = testedCount;

    return testedCount;
}

// 显示结果并开始倒计时
function showResults() {
    const resultContainer = document.getElementById('result-container');
    const fullRedirectElement = document.getElementById('full-redirect-url');
    const loadingOverlay = document.getElementById('loading-overlay');

    // 隐藏加载层
    loadingOverlay.style.display = 'none';

    // 如果没有找到可用节点，使用第一个作为后备
    if (!fastestDomain || fastestDomain.time === Infinity) {
        fastestDomain = { domain: testDomains[0] };
    }

    // 显示完整重定向URL
    const fullUrl = fastestDomain.domain + targetPath;
    fullRedirectElement.textContent = fullUrl;

    // 显示结果区域
    resultContainer.style.display = 'block';

    // 开始倒计时重定向
    startCountdown();
}

// 开始倒计时重定向
function startCountdown() {
    const countdownElement = document.getElementById('countdown');
    const progressBar = document.getElementById('progress-bar');
    let width = 0;

    countdownInterval = setInterval(() => {
        countdown--;
        countdownElement.textContent = countdown;

        // 更新进度条
        width = 100 - (countdown / 3 * 100);
        progressBar.style.width = `${width}%`;

        if (countdown <= 0) {
            clearInterval(countdownInterval);
            // 重定向到完整URL（节点+目标路径）
            window.location.href = fastestDomain.domain + targetPath;
        }
    }, 1000);
}

// 开始测试所有节点
async function startTesting() {
    initDomainList();

    // 同时测试所有节点
    const testPromises = testDomains.map((domain, index) =>
        testDomainSpeed(domain, index).then(result => {
            const testedCount = updateDomainResult(index, result);

            // 如果是最后一个完成的测试，显示结果
            if (testedCount === testDomains.length) {
                setTimeout(showResults, 400); // 延迟一点显示结果
            }

            return result;
        })
    );

    // 等待所有测试完成
    await Promise.all(testPromises);
}

// 页面加载完成后开始测试
document.addEventListener('DOMContentLoaded', () => {
    // 缓存背景图片
    cacheBackgroundImage();

    // 添加立即跳转按钮事件
    document.getElementById('redirect-btn').addEventListener('click', () => {
        clearInterval(countdownInterval);
        // 重定向到完整URL（节点+目标路径）
        window.location.href = fastestDomain.domain + targetPath;
    });

    // 开始测试
    startTesting();
});