/**
 * 文件上传服务
 * 遵循 Tauri 开发规范的前端服务设计原则
 */

import { invoke } from '@tauri-apps/api/core';
import { open } from '@tauri-apps/plugin-dialog';
import type { FileUploadResult } from '../types/comfyui';

/**
 * 文件上传请求参数
 */
export interface FileUploadRequest {
  /** 文件路径 */
  filePath: string;
  /** 远程存储键名（可选） */
  remoteKey?: string;
}

/**
 * 云端上传响应
 */
export interface CloudUploadResponse {
  /** 是否成功 */
  success: boolean;
  /** 远程URL */
  remote_url?: string;
  /** URN */
  urn?: string;
  /** 错误信息 */
  error_message?: string;
  /** 文件大小 */
  file_size: number;
}

/**
 * 文件上传响应（使用现有的类型）
 */
export interface FileUploadResponse {
  status: boolean;
  msg: string;
  data?: string;
}

/**
 * 文件上传服务类
 */
class FileUploadService {
  /**
   * 选择本地图片文件
   */
  async selectImageFile(): Promise<string | null> {
    try {
      const selected = await open({
        multiple: false,
        filters: [
          {
            name: '图像文件',
            extensions: ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'],
          },
        ],
      });

      if (selected && typeof selected === 'string') {
        return selected;
      }
      return null;
    } catch (error) {
      console.error('选择文件失败:', error);
      throw new Error('文件选择失败');
    }
  }

  /**
   * 选择多个图片文件
   */
  async selectImageFiles(): Promise<string[]> {
    try {
      const selected = await open({
        multiple: true,
        filters: [
          {
            name: '图像文件',
            extensions: ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'],
          },
        ],
      });

      if (selected && Array.isArray(selected)) {
        return selected;
      }
      return [];
    } catch (error) {
      console.error('选择文件失败:', error);
      throw new Error('文件选择失败');
    }
  }

  /**
   * 上传文件到云端（使用现有的upload_file_to_cloud命令）
   */
  async uploadFileToCloud(
    filePath: string,
    _remoteKey?: string,
    onProgress?: (progress: number) => void
  ): Promise<FileUploadResult> {
    try {
      onProgress?.(10); // 开始上传

      // 使用现有的upload_file_to_cloud命令
      const response = await invoke<FileUploadResponse>('upload_file_to_cloud', {
        filePath: filePath,
      });

      onProgress?.(90); // 上传完成

      if (response.status && response.data) {
        onProgress?.(100); // 完成
        return {
          status: 'success',
          url: response.data,
          progress: 100,
        };
      } else {
        return {
          status: 'error',
          error: response.msg || '上传失败',
          progress: 0,
        };
      }
    } catch (error) {
      console.error('上传文件失败:', error);
      return {
        status: 'error',
        error: error instanceof Error ? error.message : '上传失败',
        progress: 0,
      };
    }
  }

  /**
   * 选择并上传图片文件
   */
  async selectAndUploadImage(
    onProgress?: (progress: number) => void
  ): Promise<FileUploadResult> {
    try {
      // 1. 选择文件
      const filePath = await this.selectImageFile();
      if (!filePath) {
        return {
          status: 'error',
          error: '未选择文件',
          progress: 0,
        };
      }

      // 2. 上传文件
      onProgress?.(10); // 选择完成，开始上传
      
      const result = await this.uploadFileToCloud(filePath, undefined, (progress) => {
        // 将上传进度映射到 10-100 范围
        onProgress?.(10 + (progress * 0.9));
      });

      return result;
    } catch (error) {
      console.error('选择并上传图片失败:', error);
      return {
        status: 'error',
        error: error instanceof Error ? error.message : '操作失败',
        progress: 0,
      };
    }
  }

  /**
   * 批量选择并上传图片文件
   */
  async selectAndUploadImages(
    onProgress?: (current: number, total: number, currentProgress: number) => void
  ): Promise<FileUploadResult[]> {
    try {
      // 1. 选择文件
      const filePaths = await this.selectImageFiles();
      if (filePaths.length === 0) {
        return [];
      }

      // 2. 批量上传
      const results: FileUploadResult[] = [];
      const total = filePaths.length;

      for (let i = 0; i < filePaths.length; i++) {
        const filePath = filePaths[i];
        
        const result = await this.uploadFileToCloud(filePath, undefined, (progress) => {
          onProgress?.(i + 1, total, progress);
        });
        
        results.push(result);
      }

      return results;
    } catch (error) {
      console.error('批量上传图片失败:', error);
      throw new Error(error instanceof Error ? error.message : '批量上传失败');
    }
  }

  /**
   * 验证文件是否为支持的图片格式
   */
  isValidImageFile(filePath: string): boolean {
    const supportedExtensions = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'];
    const extension = filePath.split('.').pop()?.toLowerCase();
    return extension ? supportedExtensions.includes(extension) : false;
  }

  /**
   * 获取文件名（不含路径）
   */
  getFileName(filePath: string): string {
    return filePath.split(/[/\\]/).pop() || filePath;
  }

  /**
   * 生成远程存储键名
   */
  generateRemoteKey(filePath: string, prefix?: string): string {
    const fileName = this.getFileName(filePath);
    const timestamp = Date.now();
    const randomSuffix = Math.random().toString(36).substring(2, 8);
    
    const key = `${timestamp}_${randomSuffix}_${fileName}`;
    return prefix ? `${prefix}/${key}` : key;
  }
}

// 导出单例实例
export default new FileUploadService();
