const http = require('http');
const https = require('https');
const url = require('url');
const querystring = require('querystring');
const fs = require('fs');
const pathModule = require('path');
const crypto = require('crypto');

const CACHE_DIR_NAME = '.cache';
const DEFAULT_PORT = 9001;
const DEFAULT_API_ENDPOINT = 'http://183.6.121.121:9519/';

// 创建缓存目录结构
const cacheDir = pathModule.join(__dirname, CACHE_DIR_NAME);
if (!fs.existsSync(cacheDir)) {
    fs.mkdirSync(cacheDir, { recursive: true });
    console.log(`Cache directory created: ${cacheDir}`);
}

// 根据缓存键创建子目录，避免单个目录文件过多
function getCacheSubDir(cacheKey) {
    // 使用缓存键的前两个字符作为子目录名
    const subDir = cacheKey.substring(0, 2);
    const fullPath = pathModule.join(cacheDir, subDir);
    if (!fs.existsSync(fullPath)) {
        fs.mkdirSync(fullPath, { recursive: true });
    }
    return fullPath;
}

// 缓存配置
const META_CACHE_EXPIRY_MS = 30 * 60 * 1000; // 30分钟
const metaCache = {}; // 存储meta信息的内存缓存
const contentCache = {}; // 存储内容的内存索引

// 下载任务管理和并发控制
const MAX_CONCURRENT_DOWNLOADS = 5; // 最大并发下载数
const MAX_QUEUE_SIZE = 50; // 最大队列长度
const MAX_CLIENTS_PER_TASK = 10; // 每个任务最大客户端数
const REQUEST_TIMEOUT = 30000; // 请求超时时间（30秒）
const downloadTasks = new Map(); // 下载任务管理器
const downloadQueue = []; // 下载队列
let activeDownloads = 0; // 当前活跃下载数



// 服务器启动时间
const serverStartTime = Date.now();

// 下载任务状态
const DOWNLOAD_STATUS = {
    PENDING: 'pending',
    DOWNLOADING: 'downloading',
    COMPLETED: 'completed',
    FAILED: 'failed',
    PAUSED: 'paused'
};

// 下载任务类
class DownloadTask {
    constructor(url, cacheKey, metaCacheFile, contentCacheFile) {
        this.id = `${cacheKey}_${Date.now()}`;
        this.url = url;
        this.cacheKey = cacheKey;
        this.metaCacheFile = metaCacheFile;
        this.contentCacheFile = contentCacheFile;
        this.status = DOWNLOAD_STATUS.PENDING;
        this.waitingClients = [];
        this.error = null;
        this.createdAt = Date.now();
        
        // 进度跟踪
        this.progress = {
            totalSize: 0,
            downloadedSize: 0,
            percentage: 0,
            speed: 0, // bytes/second
            eta: 0, // estimated time remaining in seconds
            startTime: null,
            lastUpdateTime: null,
            lastDownloadedSize: 0
        };
        
        // 状态管理
        this.retryCount = 0;
        this.maxRetries = 3;
        this.lastError = null;
        this.pauseRequested = false;
    }
    
    addClient(res, rangeHeader) {
        this.waitingClients.push({ res, rangeHeader, addedAt: Date.now() });
    }
    
    removeClient(res) {
        this.waitingClients = this.waitingClients.filter(client => client.res !== res);
    }
    
    hasClients() {
        return this.waitingClients.length > 0;
    }
    
    // 更新下载进度
    updateProgress(downloadedBytes, totalBytes) {
        const now = Date.now();
        
        if (!this.progress.startTime) {
            this.progress.startTime = now;
        }
        
        this.progress.totalSize = totalBytes;
        this.progress.downloadedSize = downloadedBytes;
        this.progress.percentage = totalBytes > 0 ? (downloadedBytes / totalBytes) * 100 : 0;
        
        // 计算下载速度
        if (this.progress.lastUpdateTime) {
            const timeDiff = (now - this.progress.lastUpdateTime) / 1000; // seconds
            const sizeDiff = downloadedBytes - this.progress.lastDownloadedSize;
            
            if (timeDiff > 0) {
                this.progress.speed = sizeDiff / timeDiff;
                
                // 计算预计剩余时间
                const remainingBytes = totalBytes - downloadedBytes;
                this.progress.eta = this.progress.speed > 0 ? remainingBytes / this.progress.speed : 0;
            }
        }
        
        this.progress.lastUpdateTime = now;
        this.progress.lastDownloadedSize = downloadedBytes;
    }
    
    // 获取进度信息
    getProgressInfo() {
        return {
            id: this.id,
            url: this.url,
            status: this.status,
            progress: { ...this.progress },
            clientCount: this.waitingClients.length,
            retryCount: this.retryCount,
            error: this.lastError,
            createdAt: this.createdAt
        };
    }
    
    // 设置错误状态
    setError(error) {
        this.lastError = error;
        this.error = error;
        this.status = DOWNLOAD_STATUS.FAILED;
    }
    
    // 请求暂停
    requestPause() {
        this.pauseRequested = true;
    }
    
    // 检查是否应该重试
    shouldRetry() {
        return this.retryCount < this.maxRetries && this.status === DOWNLOAD_STATUS.FAILED;
    }
    
    // 增加重试次数
     incrementRetry() {
         this.retryCount++;
     }
}

// 下载任务管理器函数
function getOrCreateDownloadTask(url, cacheKey, metaCacheFile, contentCacheFile) {
    let task = downloadTasks.get(cacheKey);
    if (!task) {
        task = new DownloadTask(url, cacheKey, metaCacheFile, contentCacheFile);
        downloadTasks.set(cacheKey, task);
    }
    return task;
}

function startNextDownload() {
    if (activeDownloads >= MAX_CONCURRENT_DOWNLOADS || downloadQueue.length === 0) {
        return;
    }
    
    const task = downloadQueue.shift();
    if (task && task.status === DOWNLOAD_STATUS.PENDING) {
        activeDownloads++;
        task.status = DOWNLOAD_STATUS.DOWNLOADING;
        console.log(`Starting download: ${task.url} (${activeDownloads}/${MAX_CONCURRENT_DOWNLOADS})`);
        executeDownload(task);
    }
}

function completeDownload(task, success = true) {
    activeDownloads = Math.max(0, activeDownloads - 1);
    task.status = success ? DOWNLOAD_STATUS.COMPLETED : DOWNLOAD_STATUS.FAILED;
    
    if (!success) {
        // 清理失败的下载任务
        downloadTasks.delete(task.cacheKey);
    }
    
    console.log(`Download ${success ? 'completed' : 'failed'}: ${task.url} (${activeDownloads}/${MAX_CONCURRENT_DOWNLOADS})`);
    
    // 启动下一个下载任务
    setTimeout(startNextDownload, 100);
}

function cleanupExpiredTasks() {
    const now = Date.now();
    const expiredTasks = [];
    
    downloadTasks.forEach((task, key) => {
        // 清理超过1小时且没有客户端的已完成任务
        if (task.status === DOWNLOAD_STATUS.COMPLETED && 
            !task.hasClients() && 
            (now - task.startTime) > 3600000) {
            expiredTasks.push(key);
        }
        // 清理超过10分钟的失败任务
        else if (task.status === DOWNLOAD_STATUS.FAILED && 
                 (now - task.startTime) > 600000) {
            expiredTasks.push(key);
        }
    });
    
    expiredTasks.forEach(key => {
        downloadTasks.delete(key);
    });
    
    if (expiredTasks.length > 0) {
        console.log(`Cleaned up ${expiredTasks.length} expired download tasks`);
    }
}

// 定期清理过期任务
setInterval(cleanupExpiredTasks, 300000); // 每5分钟清理一次

// 创建HTTP服务器
const server = http.createServer(async (req, res) => {
    const parsedUrl = url.parse(req.url, true);
    const path = parsedUrl.pathname;
    const clientIP = req.connection.remoteAddress || req.socket.remoteAddress || '127.0.0.1';
    
    // 处理favicon请求
    if (path === '/favicon.ico') {
        res.writeHead(204);
        res.end();
        return;
    }
    
    // 处理状态查询请求
    if (path === '/status') {
        const tasks = Array.from(downloadTasks.values()).map(task => task.getProgressInfo());
        const status = {
            activeDownloads,
            queueLength: downloadQueue.length,
            totalTasks: downloadTasks.size,
            tasks: tasks.slice(0, 20), // 只返回前20个任务
            serverInfo: {
                maxConcurrentDownloads: MAX_CONCURRENT_DOWNLOADS,
                maxQueueSize: MAX_QUEUE_SIZE,
                maxClientsPerTask: MAX_CLIENTS_PER_TASK,
                requestTimeout: REQUEST_TIMEOUT,
                uptime: Date.now() - serverStartTime
            }
        };
        
        res.writeHead(200, { 
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        });
        res.end(JSON.stringify(status, null, 2));
        return;
    }
    
    // 处理任务控制请求
    if (path.startsWith('/control/')) {
        const action = path.split('/')[2]; // pause, resume, cancel
        const taskId = parsedUrl.query.taskId;
        
        if (!taskId) {
            res.writeHead(400, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Missing taskId parameter' }));
            return;
        }
        
        const task = downloadTasks.get(taskId);
        if (!task) {
            res.writeHead(404, { 'Content-Type': 'application/json' });
            res.end(JSON.stringify({ error: 'Task not found' }));
            return;
        }
        
        let result = { success: false, message: '' };
        
        switch (action) {
            case 'pause':
                if (task.status === DOWNLOAD_STATUS.DOWNLOADING) {
                    task.requestPause();
                    result = { success: true, message: 'Pause requested' };
                } else {
                    result = { success: false, message: 'Task is not downloading' };
                }
                break;
                
            case 'resume':
                if (task.status === DOWNLOAD_STATUS.PAUSED || task.status === DOWNLOAD_STATUS.FAILED) {
                    task.status = DOWNLOAD_STATUS.PENDING;
                    task.pauseRequested = false;
                    if (!downloadQueue.includes(task)) {
                        downloadQueue.push(task);
                    }
                    startNextDownload();
                    result = { success: true, message: 'Resume requested' };
                } else {
                    result = { success: false, message: 'Task cannot be resumed' };
                }
                break;
                
            case 'cancel':
                task.requestPause();
                task.status = DOWNLOAD_STATUS.FAILED;
                task.setError('Cancelled by user');
                // 通知所有等待的客户端
                task.waitingClients.forEach(({ res: clientRes }) => {
                    if (!clientRes.headersSent && !clientRes.destroyed) {
                        clientRes.writeHead(499, { 'Content-Type': 'text/plain' });
                        clientRes.end('Download cancelled');
                    }
                });
                task.waitingClients = [];
                result = { success: true, message: 'Task cancelled' };
                break;
                
            default:
                result = { success: false, message: 'Invalid action' };
        }
        
        res.writeHead(200, { 
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        });
        res.end(JSON.stringify(result));
        return;
    }
    

    
    // 设置请求超时
    const timeout = setTimeout(() => {
        if (!res.headersSent) {
            res.writeHead(408, { 'Content-Type': 'text/plain' });
            res.end('Request Timeout');
        }
    }, REQUEST_TIMEOUT);
    
    // 设置CORS头，自动获取Origin
    const origin = req.headers.origin || req.headers.referer || '*';
    res.setHeader('Access-Control-Allow-Origin', origin);
    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS, HEAD');
    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-Requested-With, Accept, Origin');
    res.setHeader('Access-Control-Allow-Credentials', 'true');
    res.setHeader('Access-Control-Max-Age', '86400');
    
    // 处理预检请求
    if (req.method === 'OPTIONS') {
        res.writeHead(200);
        res.end();
        return;
    }
    
    // 生成缓存键并创建分层目录结构
    const cacheKey = crypto.createHash('md5').update(req.url).digest('hex');
    const cacheSubDir = getCacheSubDir(cacheKey);
    const metaCacheFile = pathModule.join(cacheSubDir, `${cacheKey}.meta`);
    const contentCacheFile = pathModule.join(cacheSubDir, `${cacheKey}.content`);
    
    // 检查meta缓存是否有效
    const now = Date.now();
    let metaInfo = metaCache[cacheKey];
    let metaExpired = !metaInfo || (now - metaInfo.timestamp > META_CACHE_EXPIRY_MS);
    
    // 如果meta缓存过期，尝试从文件读取
    if (metaExpired && fs.existsSync(metaCacheFile)) {
        try {
            const metaData = JSON.parse(fs.readFileSync(metaCacheFile, 'utf8'));
            if (now - metaData.timestamp <= META_CACHE_EXPIRY_MS) {
                metaInfo = metaData;
                metaCache[cacheKey] = metaInfo;
                metaExpired = false;
                console.log(`Meta cache loaded from file for: ${req.url}`);
            }
        } catch (err) {
            console.error(`Error reading meta cache file: ${err.message}`);
        }
    }
    
    // 如果meta缓存有效且内容缓存存在，直接返回缓存内容
    if (!metaExpired && fs.existsSync(contentCacheFile)) {
        console.log(`Serving from cache: ${req.url}`);
        const rangeHeader = req.headers.range;
        
        // 检查是否可以从完整缓存文件提供Range请求
        if (rangeHeader && fs.existsSync(contentCacheFile)) {
            try {
                const stat = fs.statSync(contentCacheFile);
                const expectedSize = parseInt(metaInfo.headers['content-length'] || '0', 10);
                
                if (stat.size === expectedSize) {
                    const ranges = parseRange(rangeHeader, expectedSize);
                    if (ranges) {
                        console.log(`Serving range request from complete cache: ${contentCacheFile}`);
                        serveFromCache(res, metaInfo, contentCacheFile, rangeHeader, req);
                        return;
                    }
                } else if (stat.size > 0 && stat.size < expectedSize) {
                    // 部分下载的文件，检查是否可以提供请求的范围
                    const ranges = parseRange(rangeHeader, expectedSize);
                    if (ranges && !Array.isArray(ranges)) {
                        const { start, end } = ranges;
                        if (end < stat.size) {
                            // 请求的范围在已下载的部分内
                            console.log(`Serving range request from partial cache: ${contentCacheFile}`);
                            serveFromCache(res, metaInfo, contentCacheFile, rangeHeader);
                            return;
                        }
                    }
                }
            } catch (err) {
                console.error(`Error checking cached file for range request: ${err.message}`);
            }
        }
        
        serveFromCache(res, metaInfo, contentCacheFile, rangeHeader, req);
        return;
    }
    
    // 需要请求原始API - 使用下载任务管理器
    console.log(`Fetching from API: ${req.url}`);
    const rangeHeader = req.headers.range;
    
    // 获取或创建下载任务
    const task = getOrCreateDownloadTask(req.url, cacheKey, metaCacheFile, contentCacheFile);
    
    // 检查队列是否已满
    if (downloadQueue.length >= MAX_QUEUE_SIZE && task.status === DOWNLOAD_STATUS.PENDING) {
        console.log(`Download queue full, rejecting request: ${req.url}`);
        clearTimeout(timeout);
        res.writeHead(503, { 'Content-Type': 'text/plain' });
        res.end('Service Unavailable - Queue Full');
        return;
    }
    
    // 检查任务客户端数量限制
    if (task.waitingClients.length >= MAX_CLIENTS_PER_TASK) {
        console.log(`Too many clients for task, rejecting: ${req.url}`);
        clearTimeout(timeout);
        res.writeHead(503, { 'Content-Type': 'text/plain' });
        res.end('Service Unavailable - Too Many Clients');
        return;
    }
    
    // 添加客户端到等待列表
    task.addClient(res, rangeHeader);
    
    // 处理客户端断开连接
    res.on('close', () => {
        clearTimeout(timeout);
        task.removeClient(res);
        console.log(`Client disconnected from task: ${task.id}`);
    });
    
    // 处理响应完成
    res.on('finish', () => {
        clearTimeout(timeout);
    });
    
    if (task.status === DOWNLOAD_STATUS.COMPLETED) {
        // 任务已完成，直接从缓存提供内容
        console.log(`Serving completed download from cache: ${req.url}`);
        serveFromCache(res, metaCache[cacheKey], contentCacheFile, rangeHeader, req);
        task.removeClient(res);
    } else if (task.status === DOWNLOAD_STATUS.DOWNLOADING) {
        // 任务正在下载中，客户端等待
        console.log(`Client waiting for ongoing download: ${req.url}`);
    } else if (task.status === DOWNLOAD_STATUS.PENDING) {
        // 将任务加入下载队列
        if (!downloadQueue.includes(task)) {
            downloadQueue.push(task);
            console.log(`Added to download queue: ${req.url}`);
        }
        startNextDownload();
    } else if (task.status === DOWNLOAD_STATUS.FAILED) {
        // 任务失败，重新尝试
        task.status = DOWNLOAD_STATUS.PENDING;
        task.error = null;
        if (!downloadQueue.includes(task)) {
            downloadQueue.push(task);
        }
        startNextDownload();
    }
});

// 从缓存提供内容，支持多段Range和HTTP缓存
function serveFromCache(res, metaInfo, contentCacheFile, rangeHeader, req) {
    // 设置响应头，保持CORS头
    const headers = { ...metaInfo.headers };
    // 确保CORS头不被覆盖
    if (!headers['access-control-allow-origin']) {
        headers['access-control-allow-origin'] = res.getHeader('access-control-allow-origin') || '*';
    }
    
    // 确保Content-Type正确设置，特别是对于视频文件
    if (!headers['content-type']) {
        const ext = pathModule.extname(contentCacheFile).toLowerCase();
        const mimeTypes = {
            '.mp4': 'video/mp4',
            '.webm': 'video/webm',
            '.ogg': 'video/ogg',
            '.avi': 'video/x-msvideo',
            '.mov': 'video/quicktime',
            '.wmv': 'video/x-ms-wmv',
            '.flv': 'video/x-flv',
            '.mkv': 'video/x-matroska',
            '.m4v': 'video/mp4',
            '.3gp': 'video/3gpp',
            '.ts': 'video/mp2t'
        };
        headers['content-type'] = mimeTypes[ext] || 'application/octet-stream';
    }
    
    // 确保Accept-Ranges头存在，这对视频播放很重要
    headers['accept-ranges'] = 'bytes';
    
    // 处理Range请求
    if (rangeHeader && fs.existsSync(contentCacheFile)) {
        const stat = fs.statSync(contentCacheFile);
        const fileSize = stat.size;
        
        // 生成ETag和Last-Modified
        const etag = `"${stat.mtime.getTime()}-${fileSize}"`;
        const lastModified = stat.mtime.toUTCString();
        
        // 设置缓存相关头
     headers['etag'] = etag;
     headers['last-modified'] = lastModified;
     headers['cache-control'] = 'public, max-age=3600, must-revalidate'; // 1小时缓存，必须重新验证
     headers['vary'] = 'Accept-Encoding, Range'; // 根据编码和范围请求变化
        
        // 检查条件请求
        const ifNoneMatch = req && req.headers['if-none-match'];
        const ifModifiedSince = req && req.headers['if-modified-since'];
        
        // 304 Not Modified 检查
        if ((ifNoneMatch && ifNoneMatch === etag) || 
            (ifModifiedSince && new Date(ifModifiedSince) >= stat.mtime)) {
            res.writeHead(304, headers);
            res.end();
            return;
        }
        
        // 解析Range头
        const ranges = parseRange(rangeHeader, fileSize);
        if (ranges) {
            // 单段Range请求
            if (!Array.isArray(ranges)) {
                const { start, end } = ranges;
                const chunkSize = (end - start) + 1;
                
                // 设置206 Partial Content响应头
                headers['content-range'] = `bytes ${start}-${end}/${fileSize}`;
                headers['accept-ranges'] = 'bytes';
                headers['content-length'] = chunkSize;
                
                res.writeHead(206, headers);
                
                // 创建范围读取流
                const fileStream = fs.createReadStream(contentCacheFile, { start, end });
                fileStream.pipe(res);
                
                fileStream.on('error', (err) => {
                    console.error(`Error reading cache file: ${err.message}`);
                    res.statusCode = 500;
                    res.end('Internal Server Error');
                });
                
                return;
            }
            
            // 多段Range请求 - 暂时不支持，返回完整文件
            console.log('Multi-range request detected, serving full file instead');
        }
    }
    
    // 普通请求或Range解析失败
    const stat = fs.statSync(contentCacheFile);
    
    // 生成ETag和Last-Modified
    const etag = `"${stat.mtime.getTime()}-${stat.size}"`;
    const lastModified = stat.mtime.toUTCString();
    
    // 设置缓存相关头
    headers['etag'] = etag;
    headers['last-modified'] = lastModified;
    headers['cache-control'] = 'public, max-age=3600, must-revalidate'; // 1小时缓存，必须重新验证
    headers['vary'] = 'Accept-Encoding, Range'; // 根据编码和范围请求变化
    
    // 检查条件请求
    const ifNoneMatch = req && req.headers['if-none-match'];
    const ifModifiedSince = req && req.headers['if-modified-since'];
    
    // 304 Not Modified 检查
    if ((ifNoneMatch && ifNoneMatch === etag) || 
        (ifModifiedSince && new Date(ifModifiedSince) >= stat.mtime)) {
        res.writeHead(304, headers);
        res.end();
        return;
    }
    
    res.writeHead(200, headers);
    
    // 创建文件读取流并直接管道到响应
    const fileStream = fs.createReadStream(contentCacheFile);
    fileStream.pipe(res);
    
    // 处理错误
    fileStream.on('error', (err) => {
        console.error(`Error reading cache file: ${err.message}`);
        res.statusCode = 500;
        res.end('Internal Server Error');
    });
}

// 获取Content-Type
function getContentType(url) {
    const ext = pathModule.extname(url).toLowerCase();
    const mimeTypes = {
        '.mp4': 'video/mp4',
        '.webm': 'video/webm',
        '.ogg': 'video/ogg',
        '.avi': 'video/x-msvideo',
        '.mov': 'video/quicktime',
        '.wmv': 'video/x-ms-wmv',
        '.flv': 'video/x-flv',
        '.mkv': 'video/x-matroska',
        '.m4v': 'video/mp4',
        '.3gp': 'video/3gpp',
        '.ts': 'video/mp2t'
    };
    return mimeTypes[ext] || 'application/octet-stream';
}

// 解析Range头，支持多段Range
function parseRange(rangeHeader, fileSize) {
    if (!rangeHeader || !rangeHeader.startsWith('bytes=')) {
        return null;
    }
    
    const rangeSpec = rangeHeader.substring(6);
    const ranges = [];
    
    // 支持多个范围，如 bytes=0-499,1000-1499
    const rangeParts = rangeSpec.split(',');
    
    for (const part of rangeParts) {
        const trimmed = part.trim();
        const [start, end] = trimmed.split('-').map(s => s ? parseInt(s, 10) : undefined);
        
        let rangeStart, rangeEnd;
        
        if (start !== undefined && end !== undefined) {
            // 完整范围: 0-499
            rangeStart = start;
            rangeEnd = end;
        } else if (start !== undefined && end === undefined) {
            // 从某位置到结尾: 500-
            rangeStart = start;
            rangeEnd = fileSize - 1;
        } else if (start === undefined && end !== undefined) {
            // 最后几个字节: -500
            rangeStart = Math.max(0, fileSize - end);
            rangeEnd = fileSize - 1;
        } else {
            continue; // 无效范围
        }
        
        // 验证范围有效性
        if (rangeStart >= fileSize || rangeEnd >= fileSize || rangeStart > rangeEnd || rangeStart < 0) {
            continue;
        }
        
        ranges.push({ start: rangeStart, end: rangeEnd });
    }
    
    return ranges.length > 0 ? (ranges.length === 1 ? ranges[0] : ranges) : null;
}

// 执行下载任务
function executeDownload(task) {
    const targetUrl = new URL(task.url, DEFAULT_API_ENDPOINT);
    const protocol = targetUrl.protocol === 'https:' ? https : http;
    
    const options = {
        method: 'GET',
        headers: {
            'User-Agent': 'Mozilla/5.0 (compatible; AlistProxy/1.0)'
        }
    };
    
    // 检查是否有缓存文件，如果有则添加条件请求头
    if (fs.existsSync(task.contentCacheFile)) {
        try {
            const stat = fs.statSync(task.contentCacheFile);
            const etag = `"${stat.mtime.getTime()}-${stat.size}"`;
            const lastModified = stat.mtime.toUTCString();
            
            // 添加条件请求头，让上游服务器判断是否需要重新下载
            options.headers['if-none-match'] = etag;
            options.headers['if-modified-since'] = lastModified;
        } catch (err) {
            console.log(`Error reading cache file stats: ${err.message}`);
        }
    }
    
    const proxyReq = protocol.request(targetUrl, options, (proxyRes) => {
        console.log(`Response status: ${proxyRes.statusCode} for ${task.url}`);
        
        // 处理304 Not Modified响应
        if (proxyRes.statusCode === 304) {
            console.log(`304 Not Modified, serving from cache: ${task.url}`);
            
            // 从缓存提供内容
            if (fs.existsSync(task.contentCacheFile) && fs.existsSync(task.metaCacheFile)) {
                try {
                    const cachedMeta = JSON.parse(fs.readFileSync(task.metaCacheFile, 'utf8'));
                    
                    // 为所有等待的客户端提供缓存内容
                    task.waitingClients.forEach(({ res: clientRes, rangeHeader }) => {
                        if (!clientRes.headersSent && !clientRes.destroyed) {
                            serveFromCache(clientRes, cachedMeta, task.contentCacheFile, rangeHeader, null);
                        }
                    });
                    
                    task.status = DOWNLOAD_STATUS.COMPLETED;
                    completeDownload(task, true);
                    return;
                } catch (err) {
                    console.error(`Error serving 304 from cache: ${err.message}`);
                }
            }
            
            // 如果缓存文件不存在，继续正常下载
            console.log(`Cache file missing for 304 response, continuing download`);
        }
        
        const metaInfo = {
            timestamp: Date.now(),
            headers: proxyRes.headers,
            statusCode: proxyRes.statusCode
        };
        
        // 更新内存缓存
        metaCache[task.cacheKey] = metaInfo;
        
        // 写入meta缓存文件
        fs.writeFile(task.metaCacheFile, JSON.stringify(metaInfo), (err) => {
            if (err) console.error(`Error writing meta cache: ${err.message}`);
        });
        
        if (proxyRes.statusCode >= 200 && proxyRes.statusCode < 300) {
            const contentLength = parseInt(proxyRes.headers['content-length'] || '0', 10);
            task.updateProgress(0, contentLength);
            
            // 创建临时文件用于断点续传
            const tempFile = `${task.contentCacheFile}.tmp`;
            const fileStream = fs.createWriteStream(tempFile);
            let downloadedBytes = 0;
            
            // 进度跟踪变量
            let lastLoggedSize = 0;
            let lastLogTime = Date.now();
            
            // 监听数据流
            proxyRes.on('data', (chunk) => {
                downloadedBytes += chunk.length;
                task.updateProgress(downloadedBytes, contentLength);
                
                // 每1MB或每5秒输出一次进度日志
                const now = Date.now();
                if (downloadedBytes - lastLoggedSize >= 1024 * 1024 || now - lastLogTime >= 5000) {
                    const progress = task.getProgressInfo();
                    console.log(`Download progress [${task.id}]: ${progress.progress.percentage.toFixed(1)}% ` +
                               `(${formatBytes(progress.progress.downloadedSize)}/${formatBytes(progress.progress.totalSize)}) ` +
                               `Speed: ${formatBytes(progress.progress.speed)}/s ` +
                               `ETA: ${formatTime(progress.progress.eta)}`);
                    lastLoggedSize = downloadedBytes;
                    lastLogTime = now;
                }
                
                // 检查是否请求暂停
                 if (task.pauseRequested) {
                     console.log(`Download paused for task: ${task.id}`);
                     task.status = DOWNLOAD_STATUS.PAUSED;
                     proxyRes.destroy();
                     if (fileStream && !fileStream.destroyed) {
                         fileStream.end();
                     }
                     return;
                 }
                
                // 检查等待的Range请求客户端
                const clientsToServe = [];
                task.waitingClients.forEach((client, index) => {
                    if (client.res.destroyed) {
                        return;
                    }
                    
                    if (client.rangeHeader) {
                        const range = parseRange(client.rangeHeader, contentLength);
                        if (range && !Array.isArray(range)) {
                            const { start, end } = range;
                            // 检查请求的范围是否已经下载完成
                            if (downloadedBytes > end) {
                                console.log(`Serving range to waiting client: ${start}-${end} (downloaded: ${downloadedBytes})`);
                                clientsToServe.push({ client, range, index });
                            }
                        }
                    }
                });
                
                // 为可以服务的客户端提供Range响应
                clientsToServe.forEach(({ client, range, index }) => {
                    try {
                        const { start, end } = range;
                        const chunkSize = (end - start) + 1;
                        
                        // 设置响应头
                        const headers = {
                            'content-type': getContentType(task.url),
                            'accept-ranges': 'bytes',
                            'content-range': `bytes ${start}-${end}/${contentLength}`,
                            'content-length': chunkSize,
                            'access-control-allow-origin': '*',
                            'cache-control': 'public, max-age=3600'
                        };
                        
                        client.res.writeHead(206, headers);
                        
                        // 直接从临时文件读取指定范围的数据
                        const rangeStream = fs.createReadStream(tempFile, { start, end });
                        rangeStream.pipe(client.res);
                        
                        rangeStream.on('error', (err) => {
                            console.error(`Error reading range from temp file: ${err.message}`);
                            if (!client.res.headersSent) {
                                client.res.writeHead(500);
                                client.res.end('Internal Server Error');
                            }
                        });
                        
                        // 从等待列表中移除该客户端
                        task.waitingClients.splice(index, 1);
                        console.log(`Served range ${start}-${end} from temp file to waiting client`);
                    } catch (err) {
                        console.error(`Error serving range to client: ${err.message}`);
                    }
                });
                
                // 向非Range请求的等待客户端发送数据
                task.waitingClients.forEach(client => {
                    if (!client.res.destroyed && !client.rangeHeader) {
                        // 设置响应头（仅第一次）
                        if (!client.headersSent) {
                            const headers = { ...proxyRes.headers };
                            if (!headers['access-control-allow-origin']) {
                                headers['access-control-allow-origin'] = client.res.getHeader('access-control-allow-origin') || '*';
                            }
                            headers['accept-ranges'] = 'bytes';
                            client.res.writeHead(200, headers);
                            client.headersSent = true;
                        }
                        
                        // 发送数据块
                        try {
                            client.res.write(chunk);
                        } catch (err) {
                            console.error(`Error writing to client: ${err.message}`);
                            task.removeClient(client.res);
                        }
                    }
                });
            });
            
            // 将数据写入文件
            proxyRes.pipe(fileStream);
            
            proxyRes.on('end', () => {
                // 结束所有客户端响应
                task.waitingClients.forEach(client => {
                    if (!client.res.destroyed) {
                        try {
                            client.res.end();
                        } catch (err) {
                            console.error(`Error ending client response: ${err.message}`);
                        }
                    }
                });
                task.waitingClients = [];
                
                // 完成文件写入
                fileStream.end();
            });
            
            fileStream.on('finish', () => {
                fs.rename(tempFile, task.contentCacheFile, (err) => {
                    if (err) {
                        console.error(`Error saving cache file: ${err.message}`);
                        completeDownload(task, false);
                    } else {
                        console.log(`Cache saved for: ${task.url}`);
                        completeDownload(task, true);
                    }
                });
            });
            
            fileStream.on('error', (err) => {
                console.error(`Error writing cache file: ${err.message}`);
                fs.unlink(tempFile, () => {});
                completeDownload(task, false);
            });
            
        } else {
            // 非成功响应
            task.waitingClients.forEach(client => {
                if (!client.res.destroyed) {
                    const headers = { ...proxyRes.headers };
                    if (!headers['access-control-allow-origin']) {
                        headers['access-control-allow-origin'] = client.res.getHeader('access-control-allow-origin') || '*';
                    }
                    client.res.writeHead(proxyRes.statusCode, headers);
                    proxyRes.pipe(client.res);
                }
            });
            completeDownload(task, false);
        }
    });
    
    proxyReq.on('error', (err) => {
        console.error(`Download request error: ${err.message}`);
        task.error = err.message;
        
        // 向所有等待的客户端发送错误响应
        task.waitingClients.forEach(client => {
            if (!client.res.destroyed) {
                client.res.statusCode = 502;
                client.res.end('Bad Gateway');
            }
        });
        task.waitingClients = [];
        
        completeDownload(task, false);
    });
    
    proxyReq.end();
}

// 从API获取内容（保留用于非大文件请求）
function fetchFromApi(req, res, cacheKey, metaCacheFile, contentCacheFile, rangeHeader) {
    // 构建目标URL
    const targetUrl = new URL(req.url, DEFAULT_API_ENDPOINT);
    
    // 选择合适的协议模块
    const protocol = targetUrl.protocol === 'https:' ? https : http;
    
    // 准备请求选项
    const options = {
        method: req.method,
        headers: { ...req.headers }
    };
    
    // 删除可能导致问题的头信息
    delete options.headers.host;
    
    // 检查是否有缓存文件，如果有则添加条件请求头
    if (fs.existsSync(contentCacheFile)) {
        try {
            const stat = fs.statSync(contentCacheFile);
            const etag = `"${stat.mtime.getTime()}-${stat.size}"`;
            const lastModified = stat.mtime.toUTCString();
            
            // 添加条件请求头，让上游服务器判断是否需要重新下载
            options.headers['if-none-match'] = etag;
            options.headers['if-modified-since'] = lastModified;
        } catch (err) {
            console.log(`Error reading cache file stats: ${err.message}`);
        }
    }
    
    // 检查是否有正在进行的下载任务
    const existingTask = downloadTasks.get(cacheKey);
    if (existingTask && rangeHeader) {
        const range = parseRange(rangeHeader, existingTask.totalSize || Number.MAX_SAFE_INTEGER);
        if (range && !Array.isArray(range)) {
            const { start, end } = range;
            
            // 检查请求的范围是否已经下载
            if (fs.existsSync(contentCacheFile)) {
                const stat = fs.statSync(contentCacheFile);
                if (stat.size > end) {
                    // 请求的范围已经下载完成，从部分文件提供内容
                    console.log(`Serving range from partial download: ${req.url} (${start}-${end}, downloaded: ${stat.size})`);
                    
                    // 创建临时的meta信息
                    const tempMeta = {
                        headers: {
                            'content-type': getContentType(req.url),
                            'accept-ranges': 'bytes',
                            'access-control-allow-origin': '*'
                        },
                        statusCode: 200
                    };
                    
                    serveFromCache(res, tempMeta, contentCacheFile, rangeHeader, req);
                    return;
                }
            }
            
            // 如果请求的范围还没下载完，将客户端添加到等待列表
            console.log(`Adding client to waiting list for ongoing download: ${req.url}`);
            existingTask.addClient(res, rangeHeader);
            return;
        }
    }
    
    // 如果是Range请求且缓存文件已存在，检查是否可以从缓存提供部分内容
    if (rangeHeader && fs.existsSync(contentCacheFile)) {
        const stat = fs.statSync(contentCacheFile);
        const range = parseRange(rangeHeader, stat.size);
        if (range) {
            // 尝试从缓存读取meta信息来验证文件完整性
            try {
                const metaData = JSON.parse(fs.readFileSync(metaCacheFile, 'utf8'));
                if (metaData.headers && metaData.headers['content-length']) {
                    const expectedSize = parseInt(metaData.headers['content-length'], 10);
                    if (stat.size === expectedSize) {
                        // 缓存文件完整，直接提供Range响应
                        console.log(`Serving range from complete cache: ${req.url}`);
                        serveFromCache(res, metaData, contentCacheFile, rangeHeader, req);
                        return;
                    }
                }
            } catch (err) {
                // 忽略meta文件读取错误，继续正常流程
            }
        }
    }
    
    // 创建请求
    const proxyReq = protocol.request(targetUrl, options, (proxyRes) => {
        // 处理304 Not Modified响应
        if (proxyRes.statusCode === 304) {
            console.log(`304 Not Modified, serving from cache: ${req.url}`);
            
            // 从缓存提供内容
            if (fs.existsSync(contentCacheFile) && fs.existsSync(metaCacheFile)) {
                try {
                    const cachedMeta = JSON.parse(fs.readFileSync(metaCacheFile, 'utf8'));
                    serveFromCache(res, cachedMeta, contentCacheFile, rangeHeader, req);
                    return;
                } catch (err) {
                    console.error(`Error serving 304 from cache: ${err.message}`);
                }
            }
            
            // 如果缓存文件不存在，返回304给客户端
            res.writeHead(304, {
                'Access-Control-Allow-Origin': res.getHeader('access-control-allow-origin') || '*',
                'Cache-Control': 'public, max-age=3600'
            });
            res.end();
            return;
        }
        
        // 记录meta信息
        const metaInfo = {
            timestamp: Date.now(),
            headers: proxyRes.headers,
            statusCode: proxyRes.statusCode
        };
        
        // 更新内存缓存
        metaCache[cacheKey] = metaInfo;
        
        // 写入meta缓存文件
        fs.writeFile(metaCacheFile, JSON.stringify(metaInfo), (err) => {
            if (err) console.error(`Error writing meta cache: ${err.message}`);
        });
        
        // 设置响应头，保持CORS头
        const responseHeaders = { ...proxyRes.headers };
        // 确保CORS头不被覆盖
        if (!responseHeaders['access-control-allow-origin']) {
            responseHeaders['access-control-allow-origin'] = res.getHeader('access-control-allow-origin') || '*';
        }
        
        // 确保Content-Type正确设置，特别是对于视频文件
        if (!responseHeaders['content-type']) {
            const ext = pathModule.extname(req.url).toLowerCase();
            const mimeTypes = {
                '.mp4': 'video/mp4',
                '.webm': 'video/webm',
                '.ogg': 'video/ogg',
                '.avi': 'video/x-msvideo',
                '.mov': 'video/quicktime',
                '.wmv': 'video/x-ms-wmv',
                '.flv': 'video/x-flv',
                '.mkv': 'video/x-matroska',
                '.m4v': 'video/mp4',
                '.3gp': 'video/3gpp',
                '.ts': 'video/mp2t'
            };
            responseHeaders['content-type'] = mimeTypes[ext] || 'application/octet-stream';
        }
        
        // 确保Accept-Ranges头存在
        responseHeaders['accept-ranges'] = 'bytes';
        
        res.writeHead(proxyRes.statusCode, responseHeaders);
        
        // 如果是成功的响应，缓存内容
        if (proxyRes.statusCode >= 200 && proxyRes.statusCode < 300) {
            // 对于Range请求的206响应，不进行缓存，直接转发
            if (proxyRes.statusCode === 206 || rangeHeader) {
                console.log(`Streaming range response: ${req.url}`);
                proxyRes.pipe(res);
            } else {
                // 完整内容响应，进行缓存
                const tempFile = `${contentCacheFile}.tmp`;
                const fileStream = fs.createWriteStream(tempFile);
                
                // 将响应写入文件并同时发送给客户端
                proxyRes.pipe(fileStream);
                proxyRes.pipe(res);
                
                // 完成后重命名临时文件
                fileStream.on('finish', () => {
                    fs.rename(tempFile, contentCacheFile, (err) => {
                        if (err) console.error(`Error saving cache file: ${err.message}`);
                        else console.log(`Cache saved for: ${req.url}`);
                    });
                });
                
                // 处理错误
                fileStream.on('error', (err) => {
                    console.error(`Error writing cache file: ${err.message}`);
                    fs.unlink(tempFile, () => {}); // 删除临时文件
                });
            }
        } else {
            // 非成功响应直接转发，不缓存内容
            proxyRes.pipe(res);
        }
    });
    
    // 处理请求错误
    proxyReq.on('error', (err) => {
        console.error(`Proxy request error: ${err.message}`);
        res.statusCode = 502;
        res.end('Bad Gateway');
    });
    
    // 如果原始请求有body，转发它
    if (['POST', 'PUT', 'PATCH'].includes(req.method)) {
        req.pipe(proxyReq);
    } else {
        proxyReq.end();
    }
}

// 格式化字节数
function formatBytes(bytes) {
    if (bytes === 0) return '0 B';
    const k = 1024;
    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
    const i = Math.floor(Math.log(bytes) / Math.log(k));
    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
}

// 格式化时间（秒）
function formatTime(seconds) {
    if (!seconds || seconds === Infinity) return 'Unknown';
    const hours = Math.floor(seconds / 3600);
    const minutes = Math.floor((seconds % 3600) / 60);
    const secs = Math.floor(seconds % 60);
    
    if (hours > 0) {
        return `${hours}h ${minutes}m ${secs}s`;
    } else if (minutes > 0) {
        return `${minutes}m ${secs}s`;
    } else {
        return `${secs}s`;
    }
}

// 启动服务器
server.listen(DEFAULT_PORT, () => {
    console.log(`Proxy server running at http://localhost:${DEFAULT_PORT}/`);
    console.log(`Proxying requests to: ${DEFAULT_API_ENDPOINT}`);
    console.log(`Cache directory: ${cacheDir}`);
    console.log(`Meta cache expiry: ${META_CACHE_EXPIRY_MS / 60000} minutes`);
});