import { invoke } from '@tauri-apps/api/core';

/**
 * VEO3 角色定义消息接口
 */
export interface Veo3ActorDefineMessage {
  content: string;
  attachments?: string[];
}

/**
 * VEO3 角色定义响应接口
 */
export interface Veo3ActorDefineResponse {
  success: boolean;
  content: string;
  error?: string;
  conversation_history?: string[];
}

/**
 * VEO3 角色定义会话状态接口
 */
export interface Veo3ActorDefineSession {
  session_id: string;
  conversation_history: string[];
  created_at: string;
  last_updated: string;
}

/**
 * 创建角色文件请求接口
 */
export interface CreateActorFileRequest {
  session_id: string;
  file_path: string;
  file_name?: string;
}

/**
 * 创建角色文件响应接口
 */
export interface CreateActorFileResponse {
  success: boolean;
  file_path?: string;
  extracted_json?: any;
  error?: string;
}

/**
 * VEO3 角色定义服务类
 * 封装与 Rust 后端 veo3-scene-writer crate 的通信逻辑
 */
export class Veo3ActorDefineService {
  private static instance: Veo3ActorDefineService;
  private sessionId: string;

  private constructor() {
    this.sessionId = `veo3-actor-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
  }

  /**
   * 获取服务实例（单例模式）
   */
  public static getInstance(): Veo3ActorDefineService {
    if (!Veo3ActorDefineService.instance) {
      Veo3ActorDefineService.instance = new Veo3ActorDefineService();
    }
    return Veo3ActorDefineService.instance;
  }

  /**
   * 发送文本消息到 VEO3 角色定义工具
   */
  public async sendMessage(message: string): Promise<Veo3ActorDefineResponse> {
    try {
      const response = await invoke<Veo3ActorDefineResponse>('veo3_actor_define_send_message', {
        sessionId: this.sessionId,
        message: message
      });

      return response;
    } catch (error) {
      console.error('VEO3 角色定义消息发送失败:', error);
      return {
        success: false,
        content: '',
        error: error instanceof Error ? error.message : '未知错误'
      };
    }
  }

  /**
   * 发送带附件的消息到 VEO3 角色定义工具
   */
  public async sendMessageWithAttachments(
    message: string, 
    attachmentPaths: string[]
  ): Promise<Veo3ActorDefineResponse> {
    try {
      const response = await invoke<Veo3ActorDefineResponse>('veo3_actor_define_send_message_with_attachments', {
        sessionId: this.sessionId,
        message: message,
        attachmentPaths: attachmentPaths
      });

      return response;
    } catch (error) {
      console.error('VEO3 角色定义带附件消息发送失败:', error);
      return {
        success: false,
        content: '',
        error: error instanceof Error ? error.message : '未知错误'
      };
    }
  }

  /**
   * 获取会话历史记录
   */
  public async getConversationHistory(): Promise<string[]> {
    try {
      const history = await invoke<string[]>('veo3_actor_define_get_conversation_history', {
        sessionId: this.sessionId
      });

      return history;
    } catch (error) {
      console.error('获取 VEO3 角色定义会话历史失败:', error);
      return [];
    }
  }

  /**
   * 清除会话历史记录
   */
  public async clearConversation(): Promise<boolean> {
    try {
      await invoke('veo3_actor_define_clear_conversation', {
        sessionId: this.sessionId
      });

      return true;
    } catch (error) {
      console.error('清除 VEO3 角色定义会话历史失败:', error);
      return false;
    }
  }

  /**
   * 获取当前会话ID
   */
  public getSessionId(): string {
    return this.sessionId;
  }

  /**
   * 重置会话（生成新的会话ID）
   */
  public resetSession(): void {
    this.sessionId = `veo3-actor-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
  }

  /**
   * 检查服务是否可用
   */
  public async checkServiceAvailability(): Promise<boolean> {
    try {
      await invoke('veo3_actor_define_check_availability');
      return true;
    } catch (error) {
      console.error('VEO3 角色定义服务不可用:', error);
      return false;
    }
  }

  /**
   * 创建角色文件 - 从最近一次对话中提取JSON并保存
   */
  public async createActorFile(
    filePath: string,
    fileName?: string
  ): Promise<CreateActorFileResponse> {
    try {
      const response = await invoke<CreateActorFileResponse>('veo3_actor_define_create_actor_file', {
        request: {
          session_id: this.sessionId,
          file_path: filePath,
          file_name: fileName
        }
      });

      return response;
    } catch (error) {
      console.error('创建角色文件失败:', error);
      return {
        success: false,
        error: error instanceof Error ? error.message : '未知错误'
      };
    }
  }
}

/**
 * 导出服务实例
 */
export const veo3ActorDefineService = Veo3ActorDefineService.getInstance();

/**
 * 便捷函数：发送消息
 */
export const sendVeo3ActorDefineMessage = (message: string): Promise<Veo3ActorDefineResponse> => {
  return veo3ActorDefineService.sendMessage(message);
};

/**
 * 便捷函数：发送带附件的消息
 */
export const sendVeo3ActorDefineMessageWithAttachments = (
  message: string, 
  attachmentPaths: string[]
): Promise<Veo3ActorDefineResponse> => {
  return veo3ActorDefineService.sendMessageWithAttachments(message, attachmentPaths);
};

/**
 * 便捷函数：获取会话历史
 */
export const getVeo3ActorDefineConversationHistory = (): Promise<string[]> => {
  return veo3ActorDefineService.getConversationHistory();
};

/**
 * 便捷函数：清除会话
 */
export const clearVeo3ActorDefineConversation = (): Promise<boolean> => {
  return veo3ActorDefineService.clearConversation();
};

/**
 * 便捷函数：创建角色文件
 */
export const createVeo3ActorFile = (
  filePath: string,
  fileName?: string
): Promise<CreateActorFileResponse> => {
  return veo3ActorDefineService.createActorFile(filePath, fileName);
};
