Primeiro Commit

src/services/chat.ts

@@ -0,0 +1,481 @@
+import { apiService } from './api';
+
+/**
+ * Interface para a resposta da API de chat
+ */
+export interface ChatResponse {
+  success: boolean;
+  response: string; // Mensagem da IA
+  chat_id: string; // ID do chat retornado pela API (importante para manter contexto)
+}
+
+/**
+ * Interface para os dados necessários para enviar mensagem
+ */
+export interface ChatMessageRequest {
+  chatId: string;
+  message: string;
+  modelId: string;
+  personalidade?: string;
+  anexos?: File[]; // Array de até 5 arquivos
+  userEmail?: string;
+  estabelecimentoId?: number;
+}
+
+/**
+ * Interface para armazenamento local de conversas
+ * Preparando para futura integração com banco de dados
+ */
+export interface StoredChat {
+  id: string;
+  title: string;
+  createdAt: Date;
+  updatedAt: Date;
+  model: string;
+  systemPrompt: string;
+  messages: Array<{
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    model?: string;
+    timestamp: Date;
+    attachments?: Array<{
+      name: string;
+      type: string;
+      size: number;
+    }>;
+  }>;
+}
+
+/**
+ * Interface para armazenamento de pastas
+ * Preparando para futura integração com banco de dados
+ */
+export interface StoredFolder {
+  id: string;
+  name: string;
+  createdAt: Date;
+  chatIds: string[];
+}
+
+/**
+ * Serviço de chat com IA
+ */
+class ChatService {
+  private readonly CHAT_ENDPOINT = '/webhook/codex/message';
+  private readonly STORAGE_KEY_CHATS = 'hgtx_chats';
+  private readonly STORAGE_KEY_FOLDERS = 'hgtx_folders';
+
+  // Formatos de arquivo permitidos (atualmente)
+  private readonly ALLOWED_FILE_TYPES = {
+    // Formatos ativos
+    'application/pdf': { ext: '.pdf', label: 'PDF' },
+    'image/png': { ext: '.png', label: 'PNG' },
+    'image/jpeg': { ext: '.jpg, .jpeg', label: 'JPEG' },
+    'image/webp': { ext: '.webp', label: 'WebP' },
+
+    // Formatos futuros (desabilitados por enquanto)
+    // 'text/csv': { ext: '.csv', label: 'CSV' },
+    // 'text/plain': { ext: '.txt', label: 'TXT' },
+    // 'application/json': { ext: '.json', label: 'JSON' },
+    // 'application/vnd.ms-excel': { ext: '.xls', label: 'XLS' },
+    // 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': { ext: '.xlsx', label: 'XLSX' },
+  };
+
+  // Número máximo de anexos permitidos
+  private readonly MAX_ATTACHMENTS = 5;
+
+  /**
+   * Gera um chat_id único e seguro usando hash
+   * Formato: timestamp + random + hash
+   *
+   * NOTA: Esta função está mantida para compatibilidade e uso no localStorage,
+   * mas para comunicação com a API, o fluxo correto é:
+   * 1. Enviar chat_id: "0" na primeira mensagem
+   * 2. API retorna o chat_id real
+   * 3. Usar o chat_id retornado nas próximas mensagens
+   *
+   * @returns string - ID único para o chat (uso local)
+   */
+  generateChatId(): string {
+    const timestamp = Date.now().toString(36);
+    const randomPart = Math.random().toString(36).substring(2, 15);
+    const randomPart2 = Math.random().toString(36).substring(2, 15);
+
+    // Combina timestamp e partes aleatórias para criar ID único
+    const chatId = `chat_${timestamp}_${randomPart}${randomPart2}`;
+
+    return chatId;
+  }
+
+  /**
+   * Envia mensagem para a API de chat
+   *
+   * @param request - Dados da requisição (mensagem, modelo, anexos, etc)
+   * @returns Promise com a resposta da API
+   */
+  async sendMessage(request: ChatMessageRequest): Promise<ChatResponse> {
+    const {
+      chatId,
+      message,
+      modelId,
+      personalidade,
+      anexos,
+      userEmail,
+      estabelecimentoId
+    } = request;
+
+    // Usa valores do .env se não forem fornecidos
+    const email = userEmail || import.meta.env.VITE_USER_EMAIL || '';
+    const estabId = estabelecimentoId || import.meta.env.VITE_ESTABELECIMENTO_ID || '';
+
+    // Validações
+    if (!chatId) {
+      throw {
+        success: false,
+        message: 'ID do chat é obrigatório',
+      };
+    }
+
+    if (!message || message.trim().length === 0) {
+      throw {
+        success: false,
+        message: 'A mensagem não pode estar vazia',
+      };
+    }
+
+    if (!modelId) {
+      throw {
+        success: false,
+        message: 'Modelo da IA é obrigatório',
+      };
+    }
+
+    // Valida número de anexos
+    if (anexos && anexos.length > 5) {
+      throw {
+        success: false,
+        message: 'Máximo de 5 arquivos anexos permitidos',
+      };
+    }
+
+    // Cria FormData para envio multipart
+    const formData = new FormData();
+    formData.append('estabelecimento_id', estabId.toString());
+    formData.append('chat_id', chatId);
+    formData.append('user_email', email);
+    formData.append('model_id', modelId);
+    formData.append('message', message);
+
+    // Adiciona personalidade se fornecida
+    if (personalidade && personalidade.trim().length > 0) {
+      formData.append('personalidade', personalidade);
+    }
+
+    // Adiciona anexos (máximo 5)
+    if (anexos && anexos.length > 0) {
+      anexos.forEach((file, index) => {
+        if (index < 5) {
+          formData.append(`anexo${index + 1}`, file);
+        }
+      });
+    }
+
+    // Log para debug (remover em produção se necessário)
+    console.log('Enviando mensagem:', {
+      chatId,
+      messageLength: message.length,
+      modelId,
+      hasPersonalidade: !!personalidade,
+      attachmentsCount: anexos?.length || 0,
+      userEmail: email,
+      estabelecimentoId: estabId,
+    });
+
+    try {
+      // Faz a requisição usando o serviço de API
+      const response = await apiService.postFormData<ChatResponse>(
+        this.CHAT_ENDPOINT,
+        formData
+      );
+
+      return response.data;
+    } catch (error: any) {
+      // Trata erros específicos
+      console.error('Erro ao enviar mensagem:', error);
+
+      throw {
+        success: false,
+        message: error.message || 'Erro ao comunicar com a IA',
+        status: error.status,
+      };
+    }
+  }
+
+  /**
+   * Salva ou atualiza um chat no localStorage
+   * Preparado para futura migração para banco de dados
+   *
+   * @param chat - Chat a ser salvo
+   */
+  saveChat(chat: StoredChat): void {
+    try {
+      const chats = this.getAllChats();
+      const existingIndex = chats.findIndex(c => c.id === chat.id);
+
+      if (existingIndex >= 0) {
+        chats[existingIndex] = {
+          ...chat,
+          updatedAt: new Date(),
+        };
+      } else {
+        chats.push(chat);
+      }
+
+      localStorage.setItem(this.STORAGE_KEY_CHATS, JSON.stringify(chats));
+    } catch (error) {
+      console.error('Erro ao salvar chat:', error);
+      throw new Error('Não foi possível salvar o chat');
+    }
+  }
+
+  /**
+   * Busca um chat específico por ID
+   *
+   * @param chatId - ID do chat
+   * @returns Chat encontrado ou undefined
+   */
+  getChat(chatId: string): StoredChat | undefined {
+    const chats = this.getAllChats();
+    return chats.find(c => c.id === chatId);
+  }
+
+  /**
+   * Retorna todos os chats salvos
+   *
+   * @returns Array de chats
+   */
+  getAllChats(): StoredChat[] {
+    try {
+      const chatsJson = localStorage.getItem(this.STORAGE_KEY_CHATS);
+      if (!chatsJson) return [];
+
+      const chats = JSON.parse(chatsJson);
+
+      // Converte strings de data para objetos Date
+      return chats.map((chat: any) => ({
+        ...chat,
+        createdAt: new Date(chat.createdAt),
+        updatedAt: new Date(chat.updatedAt),
+        messages: chat.messages.map((msg: any) => ({
+          ...msg,
+          timestamp: new Date(msg.timestamp),
+        })),
+      }));
+    } catch (error) {
+      console.error('Erro ao carregar chats:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Deleta um chat
+   *
+   * @param chatId - ID do chat a ser deletado
+   */
+  deleteChat(chatId: string): void {
+    try {
+      const chats = this.getAllChats();
+      const filteredChats = chats.filter(c => c.id !== chatId);
+      localStorage.setItem(this.STORAGE_KEY_CHATS, JSON.stringify(filteredChats));
+    } catch (error) {
+      console.error('Erro ao deletar chat:', error);
+      throw new Error('Não foi possível deletar o chat');
+    }
+  }
+
+  /**
+   * Salva uma pasta no localStorage
+   *
+   * @param folder - Pasta a ser salva
+   */
+  saveFolder(folder: StoredFolder): void {
+    try {
+      const folders = this.getAllFolders();
+      const existingIndex = folders.findIndex(f => f.id === folder.id);
+
+      if (existingIndex >= 0) {
+        folders[existingIndex] = folder;
+      } else {
+        folders.push(folder);
+      }
+
+      localStorage.setItem(this.STORAGE_KEY_FOLDERS, JSON.stringify(folders));
+    } catch (error) {
+      console.error('Erro ao salvar pasta:', error);
+      throw new Error('Não foi possível salvar a pasta');
+    }
+  }
+
+  /**
+   * Retorna todas as pastas salvas
+   *
+   * @returns Array de pastas
+   */
+  getAllFolders(): StoredFolder[] {
+    try {
+      const foldersJson = localStorage.getItem(this.STORAGE_KEY_FOLDERS);
+      if (!foldersJson) return [];
+
+      const folders = JSON.parse(foldersJson);
+
+      // Converte strings de data para objetos Date
+      return folders.map((folder: any) => ({
+        ...folder,
+        createdAt: new Date(folder.createdAt),
+      }));
+    } catch (error) {
+      console.error('Erro ao carregar pastas:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Deleta uma pasta
+   *
+   * @param folderId - ID da pasta a ser deletada
+   */
+  deleteFolder(folderId: string): void {
+    try {
+      const folders = this.getAllFolders();
+      const filteredFolders = folders.filter(f => f.id !== folderId);
+      localStorage.setItem(this.STORAGE_KEY_FOLDERS, JSON.stringify(filteredFolders));
+    } catch (error) {
+      console.error('Erro ao deletar pasta:', error);
+      throw new Error('Não foi possível deletar a pasta');
+    }
+  }
+
+  /**
+   * Gera título automático para o chat baseado na primeira mensagem
+   *
+   * @param message - Primeira mensagem do usuário
+   * @param maxLength - Comprimento máximo do título
+   * @returns Título gerado
+   */
+  generateChatTitle(message: string, maxLength: number = 50): string {
+    if (!message || message.trim().length === 0) {
+      return 'Nova Conversa';
+    }
+
+    const trimmed = message.trim();
+    if (trimmed.length <= maxLength) {
+      return trimmed;
+    }
+
+    return trimmed.substring(0, maxLength) + '...';
+  }
+
+  /**
+   * Limpa todas as conversas (usar com cuidado)
+   */
+  clearAllChats(): void {
+    localStorage.removeItem(this.STORAGE_KEY_CHATS);
+  }
+
+  /**
+   * Limpa todas as pastas (usar com cuidado)
+   */
+  clearAllFolders(): void {
+    localStorage.removeItem(this.STORAGE_KEY_FOLDERS);
+  }
+
+  /**
+   * Valida anexos antes de enviar para a API
+   *
+   * @param files - Array de arquivos a serem validados
+   * @returns Objeto com resultado da validação
+   */
+  validateAttachments(files: File[]): { valid: boolean; error?: string } {
+    // Valida número de anexos
+    if (files.length > this.MAX_ATTACHMENTS) {
+      return {
+        valid: false,
+        error: `Máximo de ${this.MAX_ATTACHMENTS} anexos permitidos. Você selecionou ${files.length}.`,
+      };
+    }
+
+    // Valida cada arquivo
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      const fileType = file.type;
+      const fileName = file.name;
+
+      // Verifica se o tipo MIME é permitido
+      if (!this.ALLOWED_FILE_TYPES[fileType as keyof typeof this.ALLOWED_FILE_TYPES]) {
+        // Tenta validar pela extensão também
+        const extension = fileName.toLowerCase().substring(fileName.lastIndexOf('.'));
+        const isExtensionValid = Object.values(this.ALLOWED_FILE_TYPES).some(
+          type => type.ext.includes(extension)
+        );
+
+        if (!isExtensionValid) {
+          const allowedFormats = Object.values(this.ALLOWED_FILE_TYPES)
+            .map(t => t.label)
+            .join(', ');
+
+          return {
+            valid: false,
+            error: `Arquivo "${fileName}" não é permitido. Formatos aceitos: ${allowedFormats}`,
+          };
+        }
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Retorna lista de formatos de arquivo permitidos
+   *
+   * @returns Array com informações dos formatos
+   */
+  getAllowedFileTypes() {
+    return Object.entries(this.ALLOWED_FILE_TYPES).map(([mimeType, info]) => ({
+      mimeType,
+      ...info,
+    }));
+  }
+
+  /**
+   * Retorna string formatada com formatos permitidos (para exibição)
+   *
+   * @returns String formatada (ex: "PDF, PNG, JPEG, WebP")
+   */
+  getAllowedFileTypesLabel(): string {
+    return Object.values(this.ALLOWED_FILE_TYPES)
+      .map(t => t.label)
+      .join(', ');
+  }
+
+  /**
+   * Retorna string com extensões para usar no input file accept
+   *
+   * @returns String formatada (ex: ".pdf,.png,.jpg,.jpeg,.webp")
+   */
+  getAllowedFileExtensions(): string {
+    return Object.values(this.ALLOWED_FILE_TYPES)
+      .map(t => t.ext)
+      .join(',');
+  }
+
+  /**
+   * Retorna número máximo de anexos permitidos
+   */
+  getMaxAttachments(): number {
+    return this.MAX_ATTACHMENTS;
+  }
+}
+
+// Exporta instância única (Singleton)
+export const chatService = new ChatService();