import { Hono } from 'hono';
import { handleTusRequest, cleanupExpiredUploads, getStorageInfo } from '../services/tus';
import {
	getResourceByFileId,
	deleteResource,
	updateResource,
	migrateResourcesStorageType,
} from '../database/operations';
import { StorageManager, validateStorageConfig } from '../core/adapter';
import { StorageType, type StorageConfig } from '../types';

/**
 * 创建存储相关的 Hono 路由
 * @param basePath 基础路径，默认为 '/api/storage'
 * @returns Hono 应用实例
 */
export function createStorageRoutes(basePath: string = '/api/storage') {
	const app = new Hono();

	// 获取文件资源信息
	app.get('/resource/:fileId', async (c) => {
		const encodedFileId = c.req.param('fileId');
		const fileId = decodeURIComponent(encodedFileId);
		console.log('API request - Encoded fileId:', encodedFileId);
		console.log('API request - Decoded fileId:', fileId);
		const result = await getResourceByFileId(fileId);
		return c.json(result);
	});

	// 删除资源
	app.delete('/resource/:id', async (c) => {
		const id = c.req.param('id');
		const result = await deleteResource(id);
		return c.json(result);
	});

	// 更新资源
	app.patch('/resource/:id', async (c) => {
		const id = c.req.param('id');
		const data = await c.req.json();
		const result = await updateResource(id, data);
		return c.json(result);
	});

	// 迁移资源存储类型（批量更新数据库中的存储类型标记）
	app.post('/migrate-storage', async (c) => {
		try {
			const { from, to } = await c.req.json();
			const result = await migrateResourcesStorageType(from as StorageType, to as StorageType);
			return c.json({
				success: true,
				message: `Migrated ${result.count} resources from ${from} to ${to}`,
				count: result.count,
			});
		} catch (error) {
			console.error('Failed to migrate storage type:', error);
			return c.json(
				{
					success: false,
					error: error instanceof Error ? error.message : 'Unknown error',
				},
				400,
			);
		}
	});

	// 清理过期上传
	app.post('/cleanup', async (c) => {
		const result = await cleanupExpiredUploads();
		return c.json(result);
	});

	// 获取存储信息
	app.get('/storage/info', async (c) => {
		const storageInfo = getStorageInfo();
		return c.json(storageInfo);
	});

	// 切换存储类型（需要重启应用）
	app.post('/storage/switch', async (c) => {
		try {
			const newConfig = (await c.req.json()) as StorageConfig;
			const storageManager = StorageManager.getInstance();
			await storageManager.switchStorage(newConfig);

			return c.json({
				success: true,
				message: 'Storage configuration updated. Please restart the application for changes to take effect.',
				newType: newConfig.type,
			});
		} catch (error) {
			console.error('Failed to switch storage:', error);
			return c.json(
				{
					success: false,
					error: error instanceof Error ? error.message : 'Unknown error',
				},
				400,
			);
		}
	});

	// 验证存储配置
	app.post('/storage/validate', async (c) => {
		try {
			const config = (await c.req.json()) as StorageConfig;
			const errors = validateStorageConfig(config);

			if (errors.length > 0) {
				return c.json({ valid: false, errors }, 400);
			}

			return c.json({ valid: true, message: 'Storage configuration is valid' });
		} catch (error) {
			return c.json(
				{
					valid: false,
					errors: [error instanceof Error ? error.message : 'Invalid JSON'],
				},
				400,
			);
		}
	});

	return app;
}

/**
 * 创建TUS上传处理路由
 * @param uploadPath 上传路径，默认为 '/upload'
 * @returns Hono 应用实例
 */
export function createTusUploadRoutes(uploadPath: string = '/upload') {
	const app = new Hono();

	// TUS 协议处理 - 使用通用处理器
	app.all('/*', async (c) => {
		try {
			// 创建适配的请求和响应对象
			const adaptedReq = createNodeRequestAdapter(c);
			const adaptedRes = createNodeResponseAdapter(c);

			await handleTusRequest(adaptedReq, adaptedRes);
			return adaptedRes.getResponse();
		} catch (error) {
			console.error('TUS request error:', error);
			return c.json({ error: 'Upload request failed' }, 500);
		}
	});

	return app;
}

// Node.js 请求适配器
function createNodeRequestAdapter(c: any) {
	const honoReq = c.req;
	const url = new URL(honoReq.url);

	// 导入Node.js模块
	const { Readable } = require('stream');
	const { EventEmitter } = require('events');

	// 创建一个继承自Readable的适配器类
	class TusRequestAdapter extends Readable {
		method: string;
		url: string;
		headers: Record<string, string>;
		httpVersion: string;
		complete: boolean;
		private reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
		private _reading: boolean = false;

		constructor() {
			super();
			this.method = honoReq.method;
			this.url = url.pathname + url.search;
			this.headers = honoReq.header() || {};
			this.httpVersion = '1.1';
			this.complete = false;

			// 如果有请求体，获取reader
			if (honoReq.method !== 'GET' && honoReq.method !== 'HEAD' && honoReq.raw.body) {
				this.reader = honoReq.raw.body.getReader();
			}
		}

		_read() {
			if (this._reading || !this.reader) {
				return;
			}

			this._reading = true;

			this.reader
				.read()
				.then(({ done, value }) => {
					this._reading = false;
					if (done) {
						this.push(null); // 结束流
						this.complete = true;
					} else {
						// 确保我们推送的是正确的二进制数据
						const buffer = Buffer.from(value);
						this.push(buffer);
					}
				})
				.catch((error) => {
					this._reading = false;
					this.destroy(error);
				});
		}

		// 模拟IncomingMessage的destroy方法
		destroy(error?: Error) {
			if (this.reader) {
				this.reader.cancel().catch(() => {
					// 忽略取消错误
				});
				this.reader = null;
			}
			super.destroy(error);
		}
	}

	return new TusRequestAdapter();
}

// Node.js 响应适配器
function createNodeResponseAdapter(c: any) {
	let statusCode = 200;
	let headers: Record<string, string> = {};
	let body: any = null;

	const adapter = {
		statusCode,
		setHeader: (name: string, value: string) => {
			headers[name] = value;
		},
		getHeader: (name: string) => {
			return headers[name];
		},
		writeHead: (code: number, reasonOrHeaders?: any, headersObj?: any) => {
			statusCode = code;
			if (typeof reasonOrHeaders === 'object') {
				Object.assign(headers, reasonOrHeaders);
			}
			if (headersObj) {
				Object.assign(headers, headersObj);
			}
		},
		write: (chunk: any) => {
			if (body === null) {
				body = chunk;
			} else if (typeof body === 'string' && typeof chunk === 'string') {
				body += chunk;
			} else {
				// 处理 Buffer 或其他类型
				body = chunk;
			}
		},
		end: (data?: any) => {
			if (data !== undefined) {
				body = data;
			}
		},
		// 添加事件方法
		on: (event: string, handler: Function) => {
			// 简单的空实现
		},
		emit: (event: string, ...args: any[]) => {
			// 简单的空实现
		},
		// 获取最终的 Response 对象
		getResponse: () => {
			if (body === null || body === undefined) {
				return new Response(null, {
					status: statusCode,
					headers: headers,
				});
			}

			return new Response(body, {
				status: statusCode,
				headers: headers,
			});
		},
	};

	return adapter;
}

/**
 * 创建文件下载路由（支持所有存储类型）
 * @param downloadPath 下载路径，默认为 '/download'
 * @returns Hono 应用实例
 */
export function createFileDownloadRoutes(downloadPath: string = '/download') {
	const app = new Hono();

	// 通过文件ID下载文件
	app.get('/:fileId', async (c) => {
		try {
			// 获取并解码fileId
			const encodedFileId = c.req.param('fileId');
			const fileId = decodeURIComponent(encodedFileId);

			console.log('=== DOWNLOAD DEBUG START ===');
			console.log('Download request - Encoded fileId:', encodedFileId);
			console.log('Download request - Decoded fileId:', fileId);

			const storageManager = StorageManager.getInstance();
			const storageType = storageManager.getStorageType();

			// 从数据库获取文件信息
			const { status, resource } = await getResourceByFileId(fileId);
			if (status !== 'UPLOADED' || !resource) {
				console.log('Download - File not found, status:', status);
				return c.json({ error: `File not found or not ready. Status: ${status}, FileId: ${fileId}` }, 404);
			}

			// 详细记录资源信息
			console.log('Download - Full resource object:', JSON.stringify(resource, null, 2));
			console.log('Download - Resource title:', resource.title);
			console.log('Download - Resource type:', resource.type);
			console.log('Download - Resource fileId:', resource.fileId);

			// 使用resource.title作为下载文件名，如果没有则使用默认名称
			let downloadFileName = resource.title || 'download';

			// 确保文件名有正确的扩展名
			if (downloadFileName && !downloadFileName.includes('.') && resource.type) {
				// 如果没有扩展名，尝试从MIME类型推断
				const mimeTypeToExt: Record<string, string> = {
					// Microsoft Office
					'application/vnd.openxmlformats-officedocument.wordprocessingml.document': '.docx',
					'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': '.xlsx',
					'application/vnd.openxmlformats-officedocument.presentationml.presentation': '.pptx',
					'application/msword': '.doc',
					'application/vnd.ms-excel': '.xls',
					'application/vnd.ms-powerpoint': '.ppt',

					// WPS Office
					'application/wps-office.docx': '.docx',
					'application/wps-office.xlsx': '.xlsx',
					'application/wps-office.pptx': '.pptx',
					'application/wps-office.doc': '.doc',
					'application/wps-office.xls': '.xls',
					'application/wps-office.ppt': '.ppt',

					// 其他文档格式
					'application/pdf': '.pdf',
					'application/rtf': '.rtf',
					'text/plain': '.txt',
					'text/csv': '.csv',
					'application/json': '.json',
					'application/xml': '.xml',
					'text/xml': '.xml',

					// 图片格式
					'image/jpeg': '.jpg',
					'image/jpg': '.jpg',
					'image/png': '.png',
					'image/gif': '.gif',
					'image/bmp': '.bmp',
					'image/webp': '.webp',
					'image/svg+xml': '.svg',
					'image/tiff': '.tiff',

					// 音频格式
					'audio/mpeg': '.mp3',
					'audio/wav': '.wav',
					'audio/ogg': '.ogg',
					'audio/aac': '.aac',
					'audio/flac': '.flac',

					// 视频格式
					'video/mp4': '.mp4',
					'video/avi': '.avi',
					'video/quicktime': '.mov',
					'video/x-msvideo': '.avi',
					'video/webm': '.webm',

					// 压缩文件
					'application/zip': '.zip',
					'application/x-rar-compressed': '.rar',
					'application/x-7z-compressed': '.7z',
					'application/gzip': '.gz',
					'application/x-tar': '.tar',

					// 其他常见格式
					'application/octet-stream': '',
				};

				const extension = mimeTypeToExt[resource.type];
				if (extension) {
					downloadFileName += extension;
					console.log('Download - Added extension from MIME type:', extension);
				}
			}

			console.log('Download - Final download filename:', downloadFileName);

			if (storageType === StorageType.LOCAL) {
				// 本地存储：直接读取文件
				const config = storageManager.getStorageConfig();
				const uploadDir = config.local?.directory || './uploads';

				// fileId 是目录路径格式，直接使用
				const fileDir = `${uploadDir}/${fileId}`;

				try {
					// 使用 Node.js fs 而不是 Bun.file
					const fs = await import('fs');
					const path = await import('path');

					// 检查目录是否存在
					if (!fs.existsSync(fileDir)) {
						console.log('Download - Directory not found:', fileDir);
						return c.json({ error: `File directory not found: ${fileDir}` }, 404);
					}

					// 读取目录内容，找到实际的文件（排除 .json 文件）
					const files = fs.readdirSync(fileDir).filter((f) => !f.endsWith('.json'));
					console.log('Download - Files in directory:', files);

					if (files.length === 0) {
						return c.json({ error: `No file found in directory: ${fileDir}` }, 404);
					}

					// 通常只有一个文件，取第一个
					const actualFileName = files[0];
					if (!actualFileName) {
						return c.json({ error: 'No valid file found' }, 404);
					}
					const filePath = path.join(fileDir, actualFileName);

					console.log('Download - Actual file in directory:', actualFileName);
					console.log('Download - Full file path:', filePath);

					// 获取文件统计信息
					const stats = fs.statSync(filePath);
					const fileSize = stats.size;

					// 强制设置正确的MIME类型
					let contentType = resource.type || 'application/octet-stream';
					if (downloadFileName.endsWith('.docx')) {
						contentType = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
					} else if (downloadFileName.endsWith('.xlsx')) {
						contentType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
					} else if (downloadFileName.endsWith('.pdf')) {
						contentType = 'application/pdf';
					}

					console.log('Download - Final Content-Type:', contentType);

					// 处理中文文件名 - 现在使用正确的RFC 2231格式
					let contentDisposition: string;
					const hasNonAscii = !/^[\x00-\x7F]*$/.test(downloadFileName);

					if (hasNonAscii) {
						// 包含中文字符，使用RFC 2231标准
						const encodedFileName = encodeURIComponent(downloadFileName);
						// 同时提供fallback和UTF-8编码版本
						const fallbackName = downloadFileName.replace(/[^\x00-\x7F]/g, '_');
						contentDisposition = `attachment; filename="${fallbackName}"; filename*=UTF-8''${encodedFileName}`;

						console.log('Download - Original filename:', downloadFileName);
						console.log('Download - Encoded filename:', encodedFileName);
						console.log('Download - Fallback filename:', fallbackName);
					} else {
						// ASCII文件名，使用简单格式
						contentDisposition = `attachment; filename="${downloadFileName}"`;
					}

					// 设置所有必要的响应头
					c.header('Content-Type', contentType);
					c.header('Content-Length', fileSize.toString());
					c.header('Content-Disposition', contentDisposition);

					// 添加额外的头部以确保浏览器正确处理
					c.header('Cache-Control', 'no-cache, no-store, must-revalidate');
					c.header('Pragma', 'no-cache');
					c.header('Expires', '0');

					console.log('Download - Content-Disposition:', contentDisposition);
					console.log('=== DOWNLOAD DEBUG END ===');

					// 返回文件流 - 使用Hono的正确方式
					const fileStream = fs.createReadStream(filePath);

					// 将Node.js ReadStream转换为Web Stream
					const readableStream = new ReadableStream({
						start(controller) {
							fileStream.on('data', (chunk) => {
								controller.enqueue(chunk);
							});
							fileStream.on('end', () => {
								controller.close();
							});
							fileStream.on('error', (error) => {
								controller.error(error);
							});
						},
					});

					return new Response(readableStream, {
						status: 200,
						headers: {
							'Content-Type': contentType,
							'Content-Length': fileSize.toString(),
							'Content-Disposition': contentDisposition,
							'Cache-Control': 'no-cache, no-store, must-revalidate',
							Pragma: 'no-cache',
							Expires: '0',
						},
					});
				} catch (error) {
					console.error('Error reading local file:', error);
					return c.json({ error: 'Failed to read file' }, 500);
				}
			} else if (storageType === StorageType.S3) {
				// S3 存储：简单重定向，让S3处理文件名
				const config = storageManager.getStorageConfig();
				const s3Config = config.s3!;

				// 构建S3 key - 使用fileId和原始文件名
				const fileName = resource.title || 'file';
				const fullS3Key = `${fileId}/${fileName}`;

				console.log('Download - S3 Key:', fullS3Key);

				// 生成 S3 URL
				let s3Url: string;
				if (s3Config.endpoint && s3Config.endpoint !== 'https://s3.amazonaws.com') {
					// 自定义 S3 兼容服务
					s3Url = `${s3Config.endpoint}/${s3Config.bucket}/${fullS3Key}`;
				} else {
					// AWS S3
					s3Url = `https://${s3Config.bucket}.s3.${s3Config.region}.amazonaws.com/${fullS3Key}`;
				}

				console.log(`Redirecting to S3 URL: ${s3Url}`);
				console.log('=== DOWNLOAD DEBUG END ===');
				// 重定向到 S3 URL
				return c.redirect(s3Url, 302);
			}

			return c.json({ error: 'Unsupported storage type' }, 500);
		} catch (error) {
			console.error('Download error:', error);
			return c.json({ error: 'Internal server error' }, 500);
		}
	});

	return app;
}

/**
 * 创建完整的存储应用，包含API和上传功能
 * @param options 配置选项
 * @returns Hono 应用实例
 */
export function createStorageApp(
	options: {
		apiBasePath?: string;
		uploadPath?: string;
		downloadPath?: string;
	} = {},
) {
	const { apiBasePath = '/api/storage', uploadPath = '/upload', downloadPath = '/download' } = options;

	const app = new Hono();

	// 添加存储API路由
	app.route(apiBasePath, createStorageRoutes());

	// 添加TUS上传路由
	app.route(uploadPath, createTusUploadRoutes());

	// 添加文件下载路由
	app.route(downloadPath, createFileDownloadRoutes());

	return app;
}