// ===== MÓDULOS PARA CLIENTES, ANÁLISES E TRANSCRIÇÕES =====
// Este arquivo contém os módulos que estendem o JaniceApp

(function() {
  'use strict';
  
  // Aguardar que o JaniceApp esteja disponível
  if (typeof window.JaniceApp === 'undefined') {
    console.error('JaniceApp não encontrado! Este script deve ser carregado após script.js');
    return;
  }
  
  // ===== MÓDULO DE CLIENTES =====
  
  JaniceApp.modules.clients = {
    init: function() {
      console.log('🔄 Inicializando módulo de Clientes...');
      
      // Carregar clientes
      this.loadClients();
      
      // Configurar abas
      this.setupClientTabs();
      
      // Configurar logos clicáveis
      this.setupClickableLogos();
      
      // Configurar eventos
      this.setupEvents();
      
      console.log('✅ Módulo de Clientes inicializado');
    },
    
    setupEvents: function() {
      // ===== EVENTOS DO PAINEL DE CLIENTES =====
      
      // Botão para criar novo cliente
      if (JaniceApp.elements.newClientBtn) {
        JaniceApp.elements.newClientBtn.addEventListener('click', () => {
          this.setupClientForm('new');
        });
      }
      
      // Botão para cancelar formulário
      if (JaniceApp.elements.cancelClientBtn) {
        JaniceApp.elements.cancelClientBtn.addEventListener('click', () => {
          if (JaniceApp.state.currentClientId) {
            // Voltar para os detalhes do cliente atual
            JaniceApp.elements.clientFormContainer.style.display = 'none';
            JaniceApp.elements.clientDetailsContainer.style.display = 'block';
          } else {
            // Esconder formulário e mostrar tela de boas-vindas
            JaniceApp.elements.clientFormContainer.style.display = 'none';
            JaniceApp.elements.welcomeContainer.style.display = 'block';
          }
        });
      }
      
      // Submissão do formulário de cliente
      if (JaniceApp.elements.clientForm) {
        JaniceApp.elements.clientForm.addEventListener('submit', (e) => this.saveClient(e));
      }
      
      // Preview de logo ao selecionar arquivo
      if (JaniceApp.elements.clientLogoInput) {
        JaniceApp.elements.clientLogoInput.addEventListener('change', (e) => {
          if (e.target.files.length > 0) {
            const file = e.target.files[0];
            const reader = new FileReader();
            
            reader.onload = function(event) {
              JaniceApp.elements.logoPreview.innerHTML = `<img src="${event.target.result}" alt="Logo Preview">`;
              JaniceApp.elements.logoPreview.style.display = 'block';
            };
            
            reader.readAsDataURL(file);
          } else {
            JaniceApp.elements.logoPreview.style.display = 'none';
          }
        });
      }
      
      // Pesquisa de clientes
      if (JaniceApp.elements.clientSearchInput) {
        JaniceApp.elements.clientSearchInput.addEventListener('input', (e) => {
          const searchTerm = e.target.value.toLowerCase().trim();
          
          if (!searchTerm) {
            this.renderClientList(JaniceApp.state.currentClients);
            return;
          }
          
          const filteredClients = JaniceApp.state.currentClients.filter(client => 
            client.nome.toLowerCase().includes(searchTerm) || 
            client.cnpj.includes(searchTerm)
          );
          
          this.renderClientList(filteredClients);
        });
      }
      
      // Eventos do painel central
      if (JaniceApp.elements.editClientBtn) {
        JaniceApp.elements.editClientBtn.addEventListener('click', () => {
          const client = JaniceApp.state.currentClients.find(c => c._id === JaniceApp.state.currentClientId);
          if (client) {
            this.setupClientForm('edit', client);
          }
        });
      }
      
      if (JaniceApp.elements.deleteClientBtn) {
        JaniceApp.elements.deleteClientBtn.addEventListener('click', () => {
          const client = JaniceApp.state.currentClients.find(c => c._id === JaniceApp.state.currentClientId);
          if (client) {
            this.showDeleteConfirmation(client);
          }
        });
      }
      
      if (JaniceApp.elements.newAnalysisBtn) {
        JaniceApp.elements.newAnalysisBtn.addEventListener('click', () => {
          JaniceApp.modules.analysis.showAnalysisForm();
        });
      }
      
      // Eventos do modal de confirmação
      if (JaniceApp.elements.closeModalBtn) {
        JaniceApp.elements.closeModalBtn.addEventListener('click', () => {
          JaniceApp.elements.deleteConfirmModal.classList.remove('show');
        });
      }
      
      if (JaniceApp.elements.cancelDeleteBtn) {
        JaniceApp.elements.cancelDeleteBtn.addEventListener('click', () => {
          JaniceApp.elements.deleteConfirmModal.classList.remove('show');
        });
      }
      
      // Fechar modal ao clicar fora dele
      window.addEventListener('click', (e) => {
        if (e.target === JaniceApp.elements.deleteConfirmModal) {
          JaniceApp.elements.deleteConfirmModal.classList.remove('show');
        }
      });
    },
    
    // Carregar lista de clientes
    loadClients: async function() {
      try {
        const clients = await JaniceApp.utils.safeFetch('/api/clientes');
        
        // Se safeFetch retornou null (redirecionamento), não continuar
        if (clients === null) return;
        
        JaniceApp.state.currentClients = clients;
        this.renderClientList(clients);
        
      } catch (error) {
        console.error('Erro ao carregar clientes:', error);
        JaniceApp.elements.clientList.innerHTML = `
          <div class="client-list-empty">
            <i class="fas fa-exclamation-circle"></i>
            <p>Erro ao carregar clientes. Tente novamente.</p>
          </div>
        `;
      }
    },
    
    // Renderizar lista de clientes
    renderClientList: function(clients) {
      if (!clients.length) {
        JaniceApp.elements.clientList.innerHTML = `
          <div class="client-list-empty">
            <i class="fas fa-users"></i>
            <p>Nenhum cliente cadastrado</p>
          </div>
        `;
        return;
      }
      
      JaniceApp.elements.clientList.innerHTML = clients.map(client => {
        const logoHtml = client.logo 
          ? `<img src="${client.logo}" alt="Logo ${client.nome}">`
          : `<i class="fas fa-building"></i>`;
        
        const corPersonalizada = client.cor || '#6a5acd';
        
        return `
          <div class="client-item" data-id="${client._id}" style="border-left-color: ${corPersonalizada}">
            <div class="client-logo">
              ${logoHtml}
            </div>
            <div class="client-info">
              <h3>${client.nome}</h3>
              <p>CNPJ: ${JaniceApp.utils.formatCnpj(client.cnpj)}</p>
            </div>
            <div class="client-color-indicator" style="background-color: ${corPersonalizada}"></div>
          </div>
        `;
      }).join('');
      
      // Adicionar eventos de clique
      JaniceApp.elements.clientList.querySelectorAll('.client-item').forEach(item => {
        item.addEventListener('click', () => {
          const clientId = item.dataset.id;
          this.loadClientDetails(clientId);
        });
      });
    },
    
    // Carregar detalhes do cliente
    loadClientDetails: function(clientId) {
      const client = JaniceApp.state.currentClients.find(c => c._id === clientId);
      if (!client) return;
      
      // Armazenar ID do cliente atual
      JaniceApp.state.currentClientId = clientId;
      
      // Atualizar painel lateral
      JaniceApp.elements.detailClientName.textContent = client.nome;
      JaniceApp.elements.detailClientCnpj.textContent = JaniceApp.utils.formatCnpj(client.cnpj);
      
      if (client.logo) {
        JaniceApp.elements.detailClientLogo.innerHTML = `<img src="${client.logo}" alt="Logo">`;
      } else {
        JaniceApp.elements.detailClientLogo.innerHTML = '<i class="fas fa-building"></i>';
      }
      
      // Atualizar painel central
      JaniceApp.elements.centralClientName.textContent = client.nome;
      JaniceApp.elements.centralClientCnpj.textContent = JaniceApp.utils.formatCnpj(client.cnpj);
      
      if (client.logo) {
        JaniceApp.elements.centralClientLogo.innerHTML = `
          <img src="${client.logo}" alt="Logo da empresa">
          <div class="logo-upload-hint">Clique para alterar logo</div>
        `;
      } else {
        JaniceApp.elements.centralClientLogo.innerHTML = `
          <i class="fas fa-building"></i>
          <div class="logo-upload-hint">Clique para adicionar logo</div>
        `;
      }
      
      // Aplicar cor personalizada
      if (client.cor) {
        const colorWithAlpha = JaniceApp.utils.hexToRgba(client.cor, 0.1);
        JaniceApp.elements.clientDetailsPanel.style.backgroundColor = colorWithAlpha;
        JaniceApp.elements.clientDetailsPanel.style.borderColor = client.cor;
      }
      
      // Mostrar painéis
      JaniceApp.elements.clientFormContainer.style.display = 'none';
      JaniceApp.elements.clientDetailsContainer.style.display = 'block';
      JaniceApp.elements.welcomeContainer.style.display = 'none';
      JaniceApp.elements.clientDetailsPanel.style.display = 'block';
      
      // Carregar dados específicos das abas
      JaniceApp.modules.analysis.loadClientAnalyses(clientId);
      JaniceApp.modules.transcriptions.loadClientTranscriptions(clientId);
      JaniceApp.modules.actionPlans.loadClientActionPlans(clientId);
      
      // Carregar mockups e galeria
      if (JaniceApp.modules.mockups && JaniceApp.modules.mockups.loadClientMockups) {
        JaniceApp.modules.mockups.loadClientMockups(clientId);
      }
      if (JaniceApp.modules.mockups && JaniceApp.modules.mockups.loadGallery) {
        JaniceApp.modules.mockups.loadGallery();
      }
    },
    
    // Configurar abas do cliente
    setupClientTabs: function() {
      const tabButtons = document.querySelectorAll('.tab-button');
      const tabContents = document.querySelectorAll('.tab-content');
      
      tabButtons.forEach(button => {
        button.addEventListener('click', () => {
          const targetTab = button.dataset.tab;
          
          // Remover classe active de todos os botões e conteúdos
          tabButtons.forEach(btn => btn.classList.remove('active'));
          tabContents.forEach(content => content.classList.remove('active'));
          
          // Adicionar classe active ao botão clicado e conteúdo correspondente
          button.classList.add('active');
          document.getElementById(`${targetTab}-tab`).classList.add('active');
        });
      });
    },
    
    // Configurar formulário de cliente (novo ou edição)
    setupClientForm: function(mode, clientData = null) {
      // Limpar formulário
      JaniceApp.elements.clientForm.reset();
      JaniceApp.elements.logoPreview.style.display = 'none';
      JaniceApp.elements.logoPreview.innerHTML = '';
      
      if (mode === 'new') {
        JaniceApp.elements.clientFormTitle.textContent = 'Novo Cliente';
        JaniceApp.elements.clientCnpjInput.disabled = false;
        JaniceApp.elements.clientForm.dataset.mode = 'new';
        JaniceApp.elements.clientForm.dataset.id = '';
        
        // Configurar cor padrão para novo cliente
        const colorInput = document.getElementById('client-color');
        if (colorInput) {
          colorInput.value = '#6a5acd';
          this.setupColorPicker(); // Atualizar preview
        }
      } else if (mode === 'edit') {
        JaniceApp.elements.clientFormTitle.textContent = 'Editar Cliente';
        JaniceApp.elements.clientNameInput.value = clientData.nome;
        JaniceApp.elements.clientCnpjInput.value = JaniceApp.utils.formatCnpj(clientData.cnpj);
        JaniceApp.elements.clientCnpjInput.disabled = true; // Não permitir editar CNPJ
        
        if (clientData.logo) {
          JaniceApp.elements.logoPreview.innerHTML = `<img src="${clientData.logo}" alt="Logo">`;
          JaniceApp.elements.logoPreview.style.display = 'block';
        }
        
        // Carregar cor do cliente
        const colorInput = document.getElementById('client-color');
        if (colorInput) {
          colorInput.value = clientData.cor || '#6a5acd';
          this.setupColorPicker(); // Atualizar preview com a cor carregada
        }
        
        JaniceApp.elements.clientForm.dataset.mode = 'edit';
        JaniceApp.elements.clientForm.dataset.id = clientData._id;
      }
      
      // Mostrar formulário
      JaniceApp.elements.clientDetailsContainer.style.display = 'none';
      JaniceApp.elements.clientFormContainer.style.display = 'block';
      JaniceApp.elements.welcomeContainer.style.display = 'none';
    },
    
    // Salvar cliente (novo ou edição)
    saveClient: async function(event) {
      event.preventDefault();
      
      const mode = JaniceApp.elements.clientForm.dataset.mode;
      const clientId = JaniceApp.elements.clientForm.dataset.id;
      
      // Validar campos
      if (!JaniceApp.elements.clientNameInput.value.trim()) {
        alert('O nome da empresa é obrigatório');
        return;
      }
      
      if (mode === 'new' && !JaniceApp.elements.clientCnpjInput.value.trim()) {
        alert('O CNPJ é obrigatório');
        return;
      }
      
      try {
        // Preparar dados do cliente
        const formData = new FormData();
        formData.append('nome', JaniceApp.elements.clientNameInput.value.trim());
        
        if (mode === 'new') {
          formData.append('cnpj', JaniceApp.elements.clientCnpjInput.value.trim());
        }
        
        if (JaniceApp.elements.clientLogoInput.files.length > 0) {
          formData.append('logo', JaniceApp.elements.clientLogoInput.files[0]);
        }
        
        // Incluir cor personalizada
        const colorInput = document.getElementById('client-color');
        if (colorInput) {
          formData.append('cor', colorInput.value);
        }
        
        // Configurar requisição
        let url, method;
        
        if (mode === 'new') {
          url = '/api/clientes';
          method = 'POST';
        } else {
          url = `/api/clientes/${clientId}`;
          method = 'PUT';
        }
        
        // Enviar requisição
        const response = await fetch(url, {
          method,
          body: formData
        });
        
        if (!response.ok) {
          const errorData = await response.json();
          
          // Tratamento específico para diferentes tipos de erros
          if (errorData.code === 'INVALID_CNPJ') {
            throw new Error(`CNPJ inválido: ${errorData.message}`);
          }
          else if (errorData.code === 'DUPLICATE_CNPJ') {
            throw new Error(`CNPJ duplicado: ${errorData.message}`);
          }
          else if (errorData.code === 'FILE_TOO_LARGE') {
            throw new Error('Imagem muito grande: A imagem do logo deve ter no máximo 5MB.');
          }
          else if (errorData.code === 'VALIDATION_ERROR') {
            const details = errorData.details ? Object.values(errorData.details).join('\n- ') : '';
            throw new Error(`Dados inválidos:\n- ${details || errorData.message}`);
          }
          else {
            // Erro genérico, usar a mensagem fornecida pelo servidor
            throw new Error(errorData.message || 'Erro ao salvar cliente');
          }
        }
        
        // Processar resposta
        const savedClient = await response.json();
        
        // Recarregar lista de clientes
        await this.loadClients();
        
        // Mostrar detalhes do cliente salvo
        this.loadClientDetails(savedClient._id);
        
      } catch (error) {
        console.error('Erro ao salvar cliente:', error);
        
        // Usar um modal ou uma caixa de diálogo mais amigável em vez de alert
        // Por enquanto, vamos usar alert com formatação melhorada
        alert(`❌ ${error.message || 'Não foi possível salvar o cliente. Tente novamente.'}`);
      }
    },
    
    // Mostrar confirmação de exclusão
    showDeleteConfirmation: function(client) {
      // Preencher nome do cliente no modal
      JaniceApp.elements.deleteClientName.textContent = client.nome;
      
      // Configurar botão de confirmação
      JaniceApp.elements.confirmDeleteBtn.onclick = () => {
        this.deleteClient(client._id);
      };
      
      // Mostrar modal
      JaniceApp.elements.deleteConfirmModal.classList.add('show');
    },
    
    // Excluir cliente
    deleteClient: async function(clientId) {
      try {
        // Fazer requisição para excluir cliente
        const response = await fetch(`/api/clientes/${clientId}`, {
          method: 'DELETE'
        });
        
        if (!response.ok) {
          const error = await response.json();
          throw new Error(error.message || 'Erro ao excluir cliente');
        }
        
        // Fechar modal
        JaniceApp.elements.deleteConfirmModal.classList.remove('show');
        
        // Recarregar lista de clientes
        await this.loadClients();
        
        // Esconder detalhes do cliente e mostrar tela de boas-vindas
        JaniceApp.elements.clientDetailsContainer.style.display = 'none';
        JaniceApp.elements.clientDetailsPanel.style.display = 'none';
        JaniceApp.elements.welcomeContainer.style.display = 'block';
        
        // Limpar ID do cliente atual
        JaniceApp.state.currentClientId = null;
        
      } catch (error) {
        console.error('Erro ao excluir cliente:', error);
        alert(error.message || 'Não foi possível excluir o cliente. Tente novamente.');
      }
    },
    
    // Configurar seletor de cores
    setupColorPicker: function() {
      const colorInput = document.getElementById('client-color');
      const colorSample = document.getElementById('color-sample');
      const colorValue = document.getElementById('color-value');
      
      if (colorInput && colorSample && colorValue) {
        // Função para atualizar preview
        function updateColorPreview(color) {
          colorSample.style.backgroundColor = color;
          colorValue.textContent = color.toUpperCase();
        }
        
        // Atualizar preview quando a cor mudar (input para tempo real)
        colorInput.addEventListener('input', (e) => {
          updateColorPreview(e.target.value);
        });
        
        // Atualizar preview quando a cor mudar (change para compatibilidade)
        colorInput.addEventListener('change', (e) => {
          updateColorPreview(e.target.value);
        });
        
        // Inicializar com cor atual
        updateColorPreview(colorInput.value);
      }
    },
    
    // Configurar logos clicáveis
    setupClickableLogos: function() {
      // Logo do painel central
      const centralLogo = document.getElementById('central-client-logo');
      const detailLogo = document.getElementById('detail-client-logo');
      
      if (centralLogo && detailLogo) {
        // Tornar logos clicáveis
        centralLogo.classList.add('clickable');
        detailLogo.classList.add('clickable');
        
        // Eventos de clique nos logos
        centralLogo.addEventListener('click', () => {
          if (JaniceApp.state.currentClientId) {
            document.getElementById('central-logo-input').click();
          }
        });
        
        detailLogo.addEventListener('click', () => {
          if (JaniceApp.state.currentClientId) {
            document.getElementById('detail-logo-input').click();
          }
        });
        
        // Eventos de mudança nos inputs de arquivo
        const centralLogoInput = document.getElementById('central-logo-input');
        const detailLogoInput = document.getElementById('detail-logo-input');
        
        if (centralLogoInput) {
          centralLogoInput.addEventListener('change', (e) => {
            if (e.target.files.length > 0) {
              this.uploadClientLogo(e.target.files[0]);
            }
          });
        }
        
        if (detailLogoInput) {
          detailLogoInput.addEventListener('change', (e) => {
            if (e.target.files.length > 0) {
              this.uploadClientLogo(e.target.files[0]);
            }
          });
        }
      }
    },
    
    // Função para fazer upload do logo do cliente
    uploadClientLogo: async function(file) {
      if (!JaniceApp.state.currentClientId) {
        alert('Nenhum cliente selecionado');
        return;
      }
      
      // Validar tamanho do arquivo (máximo 5MB)
      if (file.size > 5 * 1024 * 1024) {
        alert('A imagem é muito grande. O tamanho máximo permitido é 5MB.');
        return;
      }
      
      // Validar tipo de arquivo
      if (!file.type.startsWith('image/')) {
        alert('Por favor, selecione apenas arquivos de imagem.');
        return;
      }
      
      try {
        // Mostrar feedback visual
        const centralLogo = document.getElementById('central-client-logo');
        const detailLogo = document.getElementById('detail-client-logo');
        
        // Adicionar classe de carregamento
        centralLogo.style.opacity = '0.5';
        detailLogo.style.opacity = '0.5';
        
        // Preparar dados do formulário
        const formData = new FormData();
        formData.append('logo', file);
        
        // Enviar requisição
        const response = await fetch(`/api/clientes/${JaniceApp.state.currentClientId}`, {
          method: 'PUT',
          body: formData
        });
        
        if (!response.ok) {
          const errorData = await response.json();
          throw new Error(errorData.message || 'Erro ao atualizar logo');
        }
        
        // Processar resposta
        const updatedClient = await response.json();
        
        // Atualizar logos na interface
        this.updateClientLogos(updatedClient.logo);
        
        // Recarregar lista de clientes para refletir mudanças
        await this.loadClients();
        
        // Feedback de sucesso
        console.log('✅ Logo atualizado com sucesso');
        
      } catch (error) {
        console.error('Erro ao atualizar logo:', error);
        alert(`Não foi possível atualizar o logo: ${error.message}`);
      } finally {
        // Restaurar opacidade
        const centralLogo = document.getElementById('central-client-logo');
        const detailLogo = document.getElementById('detail-client-logo');
        centralLogo.style.opacity = '1';
        detailLogo.style.opacity = '1';
        
        // Limpar inputs
        const centralLogoInput = document.getElementById('central-logo-input');
        const detailLogoInput = document.getElementById('detail-logo-input');
        if (centralLogoInput) centralLogoInput.value = '';
        if (detailLogoInput) detailLogoInput.value = '';
      }
    },
    
    // Função para atualizar logos na interface
    updateClientLogos: function(logoUrl) {
      const centralLogo = document.getElementById('central-client-logo');
      const detailLogo = document.getElementById('detail-client-logo');
      
      if (logoUrl) {
        // Atualizar logo central
        centralLogo.innerHTML = `
          <img src="${logoUrl}" alt="Logo da empresa">
          <div class="logo-upload-hint">Clique para alterar logo</div>
        `;
        
        // Atualizar logo lateral
        detailLogo.innerHTML = `
          <img src="${logoUrl}" alt="Logo da empresa">
          <div class="logo-upload-hint">Clique para alterar logo</div>
        `;
      } else {
        // Mostrar ícone padrão
        centralLogo.innerHTML = `
          <i class="fas fa-building"></i>
          <div class="logo-upload-hint">Clique para adicionar logo</div>
        `;
        
        detailLogo.innerHTML = `
          <i class="fas fa-building"></i>
          <div class="logo-upload-hint">Clique para adicionar logo</div>
        `;
      }
    }
  };
  
  // ===== MÓDULO DE ANÁLISES =====
  
  JaniceApp.modules.analysis = {
    init: function() {
      console.log('🔄 Inicializando módulo de Análises...');
      
      // Configurar eventos
      this.setupEvents();
      
      console.log('✅ Módulo de Análises inicializado');
    },
    
    setupEvents: function() {
      // Cancelar análise
      if (JaniceApp.elements.cancelAnalysisBtn) {
        JaniceApp.elements.cancelAnalysisBtn.addEventListener('click', () => {
          JaniceApp.elements.analysisContainer.style.display = 'none';
          
          // Voltar para os detalhes do cliente
          if (JaniceApp.state.currentClientId) {
            JaniceApp.elements.clientDetailsPanel.style.display = 'block';
          } else {
            JaniceApp.elements.welcomeContainer.style.display = 'block';
          }
        });
      }
      
      // Iniciar análise
      if (JaniceApp.elements.startAnalysisBtn) {
        JaniceApp.elements.startAnalysisBtn.addEventListener('click', () => {
          if (JaniceApp.state.currentClientId) {
            JaniceApp.elements.analysisContainer.style.display = 'none';
            this.createNewAnalysis(JaniceApp.state.currentClientId);
          }
        });
      }
      
      // Copiar relatório
      if (JaniceApp.elements.copyReportButton) {
        JaniceApp.elements.copyReportButton.addEventListener('click', () => {
          this.copyReport();
        });
      }
      
      // Exportar PDF
      if (JaniceApp.elements.exportPdfButton) {
        JaniceApp.elements.exportPdfButton.addEventListener('click', () => {
          this.exportPdf();
        });
      }
    },
    
    // Mostrar formulário de nova análise
    showAnalysisForm: function() {
      // Mostrar apenas o formulário de análise (estado exclusivo)
      JaniceApp.utils.showOnlySection('analysis-container');
      
      // Scroll automático para o formulário de análise
      JaniceApp.utils.scrollToElement('analysis-container');
    },
    
    // Criar nova análise
    createNewAnalysis: async function(clientId) {
      try {
        // Registrar processo no painel de processos ativos
        const client = JaniceApp.state.currentClients.find(c => c._id === clientId);
        const processId = JaniceApp.state.activeProcessesManager.registerProcess(
          'analise', 
          clientId, 
          `Análise de ${client ? client.nome : 'Cliente'}`
        );
        
        // Mostrar tela de carregamento
        JaniceApp.elements.welcomeContainer.style.display = 'none';
        JaniceApp.elements.errorContainer.style.display = 'none';
        JaniceApp.elements.resultContainer.style.display = 'none';
        JaniceApp.elements.loadingContainer.style.display = 'block';
        
        // Inicializar barra de progresso
        this.resetProgress();
        
        // Armazenar o ID do cliente para uso futuro
        window.currentAnalysisClientId = clientId;
        
        // Enviar solicitação para criar análise
        const response = await fetch(`/api/analises/cliente/${clientId}`, {
          method: 'POST',
          headers: {
            'Content-Type': 'application/json'
          }
        });
        
        // Verificar se a resposta foi bem-sucedida
        if (!response.ok) {
          // Fechar conexão SSE se estiver aberta
          if (window.progressEventSource) {
            window.progressEventSource.close();
            window.progressEventSource = null;
          }
          
          const errorData = await response.json();
          throw new Error(errorData.message || 'Erro ao criar análise');
        }
        
        // Processar resposta - apenas armazenar o ID da análise
        const analysis = await response.json();
        window.currentAnalysisId = analysis._id;
        
        // Recarregar histórico de análises em segundo plano
        this.loadClientAnalyses(clientId);
        
        // Iniciar atualizações de progresso via SSE
        // A visualização da análise só acontecerá quando o processo estiver concluído
        this.startProgressUpdates(clientId);
        
      } catch (error) {
        console.error('Erro:', error);
        this.showError(error.message || 'Ocorreu um erro ao criar a análise.');
      }
    },
    
    // Carregar análises do cliente
    loadClientAnalyses: async function(clientId) {
      try {
        const analyses = await JaniceApp.utils.safeFetch(`/api/analises/cliente/${clientId}`);
        
        // Se safeFetch retornou null (redirecionamento), não continuar
        if (analyses === null) return;
        
        if (!analyses.length) {
          JaniceApp.elements.analysisList.innerHTML = `
            <div class="analysis-list-empty">
              <i class="fas fa-chart-line"></i>
              <p>Nenhuma análise realizada</p>
            </div>
          `;
          return;
        }
        
        // Ordenar análises por data (mais recente primeiro)
        analyses.sort((a, b) => new Date(b.dataCriacao) - new Date(a.dataCriacao));
        
        // Renderizar lista de análises
        JaniceApp.elements.analysisList.innerHTML = analyses.map(analysis => {
          let statusClass = 'completed';
          let statusText = 'Concluído';
          
          if (analysis.emProgresso) {
            statusClass = 'in-progress';
            statusText = 'Em progresso';
          } else if (analysis.erro) {
            statusClass = 'error';
            statusText = 'Erro';
          }
          
          return `
            <div class="analysis-item ${statusClass}" data-id="${analysis._id}">
              <div class="analysis-item-content">
                <div class="analysis-date">
                  ${new Date(analysis.dataCriacao).toLocaleDateString('pt-BR', {
                    day: '2-digit',
                    month: '2-digit',
                    year: 'numeric'
                  })}
                </div>
                <div class="analysis-title">Análise de Mercado e Estratégia</div>
                <div class="analysis-meta">
                  <span class="analysis-status ${statusClass}">${statusText}</span>
                </div>
              </div>
              <div class="analysis-item-actions">
                <button class="delete-analysis-btn" data-id="${analysis._id}" title="Excluir análise">
                  <i class="fas fa-trash"></i>
                </button>
              </div>
            </div>
          `;
        }).join('');
        
        // Adicionar evento de clique para cada análise
        JaniceApp.elements.analysisList.querySelectorAll('.analysis-item').forEach(item => {
          const content = item.querySelector('.analysis-item-content');
          content.addEventListener('click', () => {
            const analysisId = item.dataset.id;
            this.viewAnalysis(analysisId);
          });
        });
        
        // Adicionar eventos para botões de delete
        JaniceApp.elements.analysisList.querySelectorAll('.delete-analysis-btn').forEach(btn => {
          btn.addEventListener('click', (e) => {
            e.stopPropagation(); // Evitar que o clique propague para o item
            const analysisId = btn.dataset.id;
            this.deleteAnalysis(analysisId);
          });
        });
        
      } catch (error) {
        console.error('Erro ao carregar análises:', error);
        JaniceApp.elements.analysisList.innerHTML = `
          <div class="analysis-list-empty">
            <i class="fas fa-exclamation-circle"></i>
            <p>Erro ao carregar análises. Tente novamente.</p>
          </div>
        `;
      }
    },
    
    // Visualizar análise específica
    viewAnalysis: async function(analysisId) {
      try {
        const response = await fetch(`/api/analises/${analysisId}`, {
          credentials: 'include',
          headers: {
            'Accept': 'application/json'
          }
        });
        if (!response.ok) {
          console.error(`❌ [FETCH-ERROR] Status: ${response.status} ${response.statusText}`);
          console.error(`❌ [FETCH-ERROR] URL: ${response.url}`);
          
          if (response.status === 502) {
            throw new Error('Erro 502: Servidor temporariamente indisponível. Tente novamente em alguns segundos.');
          } else if (response.status === 401) {
            throw new Error('Erro de autenticação. Faça login novamente.');
          } else {
            throw new Error(`Erro ${response.status}: ${response.statusText}`);
          }
        }
        
        const analysis = await response.json();
        JaniceApp.state.currentAnalysisData = analysis;
        
        // Preencher dados da análise
        JaniceApp.elements.companyNameEl.textContent = analysis.cliente.nome;
        JaniceApp.elements.resultCnpjEl.textContent = JaniceApp.utils.formatCnpj(analysis.cliente.cnpj);
        JaniceApp.elements.resultDateEl.textContent = new Date(analysis.dataCriacao).toLocaleString('pt-BR');
        
        // Limpar conteúdo anterior se existir
        const existingContent = document.querySelector('.analysis-content-container');
        if (existingContent) {
          existingContent.remove();
        }
        
        // Criar container para o conteúdo da análise
        const analysisContentContainer = document.createElement('div');
        analysisContentContainer.className = 'analysis-content-container';
        analysisContentContainer.innerHTML = `
          <div class="markdown-content">
            ${this.formatMarkdownForAnalysis(analysis.conteudo)}
          </div>
        `;
        
        // Inserir o conteúdo da análise no container de resultado
        let inserted = false;
        
        // Opção 1: Tentar inserir no resultContentContainer
        const resultContentContainer = document.querySelector('.result-content');
        if (resultContentContainer) {
          resultContentContainer.prepend(analysisContentContainer);
          inserted = true;
        } 
        
        // Opção 2: Tentar inserir usando pdfViewer como referência
        if (!inserted && JaniceApp.elements.pdfViewer && JaniceApp.elements.pdfViewer.parentNode) {
          JaniceApp.elements.pdfViewer.parentNode.insertBefore(analysisContentContainer, JaniceApp.elements.pdfViewer);
          inserted = true;
        }
        
        // Opção 3: Tentar inserir diretamente no resultContainer
        if (!inserted) {
          const resultContainer = document.getElementById('result-container');
          if (resultContainer) {
            resultContainer.prepend(analysisContentContainer);
            inserted = true;
          }
        }
        
        // Se nenhuma das opções funcionou, registrar erro
        if (!inserted) {
          console.error('Não foi possível encontrar um container para inserir o conteúdo da análise');
          throw new Error('Não foi possível exibir a análise. Container não encontrado.');
        }
        
        // Configurar PDF com verificação de nulos
        if (analysis.pdfUrl) {
          // Verificar se pdfViewer existe antes de tentar definir seu innerHTML
          if (JaniceApp.elements.pdfViewer) {
            JaniceApp.elements.pdfViewer.innerHTML = `
              <div class="pdf-ready">
                <div class="pdf-icon">
                  <i class="fas fa-file-pdf"></i>
                </div>
                <h3>Relatório PDF Pronto</h3>
                <p>Seu relatório estratégico foi gerado com sucesso e está pronto para visualização.</p>
                <button class="open-pdf-btn" onclick="window.open('/api/analises/pdf/${analysis._id}', '_blank')">
                  <i class="fas fa-external-link-alt"></i> Abrir Relatório PDF
                </button>
                <div class="pdf-info">
                  <small><i class="fas fa-info-circle"></i> O PDF será aberto em uma nova aba do navegador</small>
                </div>
              </div>
            `;
          }
          
          // Verificar se exportPdfButton existe antes de modificá-lo
          if (JaniceApp.elements.exportPdfButton) {
            JaniceApp.elements.exportPdfButton.disabled = false;
            JaniceApp.elements.exportPdfButton.innerHTML = '<i class="fas fa-file-pdf"></i> Abrir Relatório PDF';
          }
        } else {
          // Verificar se pdfViewer existe antes de tentar definir seu innerHTML
          if (JaniceApp.elements.pdfViewer) {
            JaniceApp.elements.pdfViewer.innerHTML = `
              <div class="pdf-error">
                <i class="fas fa-exclamation-triangle"></i>
                <p>PDF não disponível. Você ainda pode copiar o relatório usando o botão abaixo.</p>
              </div>
            `;
          }
          
          // Verificar se exportPdfButton existe antes de modificá-lo
          if (JaniceApp.elements.exportPdfButton) {
            JaniceApp.elements.exportPdfButton.disabled = true;
            JaniceApp.elements.exportPdfButton.innerHTML = '<i class="fas fa-file-pdf"></i> PDF Indisponível';
          }
        }
        
        // Mostrar apenas a seção de resultados (estado exclusivo)
        JaniceApp.utils.showOnlySection('result-container');
        
        // Scroll automático para a seção de resultados
        JaniceApp.utils.scrollToElement('result-container');
        
      } catch (error) {
        console.error('Erro ao visualizar análise:', error);
        alert('Não foi possível carregar a análise. Tente novamente.');
      }
    },
    
    // Deletar análise
    deleteAnalysis: async function(analysisId) {
      if (!confirm('Tem certeza que deseja excluir esta análise? Esta ação não pode ser desfeita.')) {
        return;
      }
      
      try {
        const response = await fetch(`/api/analises/${analysisId}`, {
          method: 'DELETE'
        });
        
        if (!response.ok) {
          const errorData = await response.json();
          throw new Error(errorData.message || 'Erro ao excluir análise');
        }
        
        // Recarregar lista de análises
        if (JaniceApp.state.currentClientId) {
          this.loadClientAnalyses(JaniceApp.state.currentClientId);
        }
        
        console.log('✅ Análise excluída com sucesso');
        
      } catch (error) {
        console.error('Erro ao excluir análise:', error);
        alert('Não foi possível excluir a análise. Tente novamente.');
      }
    },
    
    // Formatar markdown específico para análises
    formatMarkdownForAnalysis: function(text) {
      if (!text) return '';
      
      let formatted = text;
      
      // Converter títulos
      formatted = formatted.replace(/^# (.+)$/gm, '<h1>$1</h1>');
      formatted = formatted.replace(/^## (.+)$/gm, '<h2>$1</h2>');
      formatted = formatted.replace(/^### (.+)$/gm, '<h3>$1</h3>');
      formatted = formatted.replace(/^#### (.+)$/gm, '<h4>$1</h4>');
      
      // Converter negrito e itálico
      formatted = formatted.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
      formatted = formatted.replace(/\*([^*]+)\*/g, '<em>$1</em>');
      
      // Converter listas
      formatted = formatted.replace(/^- (.+)$/gm, '<li>$1</li>');
      formatted = formatted.replace(/^(\d+)\. (.+)$/gm, '<li>$2</li>');
      
      // Agrupar listas
      formatted = formatted.replace(/((<li>.*<\/li>\s*)+)/g, '<ul>$1</ul>');
      
      // Converter tabelas simples
      const tableRegex = /\|(.+)\|\n\|[-\s|]+\|\n((\|.+\|\n?)+)/g;
      formatted = formatted.replace(tableRegex, (match, header, separator, rows) => {
        const headerCells = header.split('|').map(cell => cell.trim()).filter(cell => cell);
        const rowsArray = rows.trim().split('\n').map(row => 
          row.split('|').map(cell => cell.trim()).filter(cell => cell)
        );
        
        let table = '<table><thead><tr>';
        headerCells.forEach(cell => {
          table += `<th>${cell}</th>`;
        });
        table += '</tr></thead><tbody>';
        
        rowsArray.forEach(row => {
          table += '<tr>';
          row.forEach(cell => {
            table += `<td>${cell}</td>`;
          });
          table += '</tr>';
        });
        
        table += '</tbody></table>';
        return table;
      });
      
      // Converter parágrafos
      formatted = formatted.replace(/\n\n/g, '</p><p>');
      formatted = `<p>${formatted}</p>`;
      
      // Limpar tags vazias
      formatted = formatted.replace(/<p><\/p>/g, '');
      formatted = formatted.replace(/<p>(<h[1-6]>)/g, '$1');
      formatted = formatted.replace(/(<\/h[1-6]>)<\/p>/g, '$1');
      formatted = formatted.replace(/<p>(<ul>)/g, '$1');
      formatted = formatted.replace(/(<\/ul>)<\/p>/g, '$1');
      formatted = formatted.replace(/<p>(<table>)/g, '$1');
      formatted = formatted.replace(/(<\/table>)<\/p>/g, '$1');
      
      return formatted;
    },
    
    // Copiar relatório
    copyReport: function() {
      if (!JaniceApp.state.currentAnalysisData) return;
      
      const reportContent = JaniceApp.state.currentAnalysisData.conteudo;
      
      navigator.clipboard.writeText(reportContent)
        .then(() => {
          const originalText = JaniceApp.elements.copyReportButton.innerHTML;
          JaniceApp.elements.copyReportButton.innerHTML = '<i class="fas fa-check"></i> Copiado!';
          
          setTimeout(() => {
            JaniceApp.elements.copyReportButton.innerHTML = originalText;
          }, 2000);
        })
        .catch(err => {
          console.error('Erro ao copiar: ', err);
        });
    },
    
    // Exportar PDF
    exportPdf: function() {
      if (!JaniceApp.state.currentAnalysisData) return;
      
      if (JaniceApp.state.currentAnalysisData.pdfUrl) {
        window.open(`/api/analises/pdf/${JaniceApp.state.currentAnalysisData._id}`, '_blank');
      } else {
        alert('PDF não disponível para esta análise.');
      }
    },
    
    // Funções de progresso
    resetProgress: function() {
      JaniceApp.elements.progressFill.style.width = '0%';
      JaniceApp.elements.progressText.textContent = '0%';
      JaniceApp.elements.loadingStatus.textContent = 'Iniciando análise...';
      
      // Resetar todos os indicadores de etapa
      for (const step of Object.values(JaniceApp.elements.progressSteps)) {
        const indicator = step.querySelector('.step-indicator');
        indicator.className = 'step-indicator pending';
        step.className = 'progress-step';
      }
    },
    
    // Iniciar atualizações de progresso via SSE
    startProgressUpdates: function(clientId) {
      // Fechar conexão anterior se existir
      if (window.progressEventSource) {
        window.progressEventSource.close();
      }
      
      // Armazenar informações sobre o processo atual
      window.currentProcessInfo = {
        type: 'analysis',
        clientId: clientId,
        startTime: new Date()
      };
      
      // Abrir nova conexão SSE
      const eventSource = new EventSource(`/api/progress/${clientId}`);
      window.progressEventSource = eventSource;
      
      // Manipular eventos de progresso
      eventSource.addEventListener('progress', (event) => {
        const data = JSON.parse(event.data);
        this.updateProgress(data);
      });
      
      // Manipular eventos de erro
      eventSource.addEventListener('error', () => {
        // Fechar conexão em caso de erro
        eventSource.close();
        window.progressEventSource = null;
      });
      
      // Manipular eventos de conclusão
      eventSource.addEventListener('complete', (event) => {
        // Atualizar para 100% e fechar conexão
        this.updateProgress({
          percentage: 100,
          message: 'Análise concluída!',
          step: 4,
          stepStatus: 'completed'
        });
        
        // Aguardar um momento para que o usuário veja que o progresso chegou a 100%
        setTimeout(() => {
          if (window.currentAnalysisId) {
            // Buscar a análise completa e exibir o resultado
            this.viewAnalysis(window.currentAnalysisId);
          }
          
          // Fechar a conexão SSE
          eventSource.close();
          window.progressEventSource = null;
        }, 2000); // Aguardar 2 segundos antes de mostrar o resultado
      });
    },
    
    // Atualizar progresso na UI
    updateProgress: function(data) {
      // Atualizar barra de progresso
      JaniceApp.elements.progressFill.style.width = `${data.percentage}%`;
      JaniceApp.elements.progressText.textContent = `${data.percentage}%`;
      
      // Atualizar mensagem de status
      if (data.message) {
        JaniceApp.elements.loadingStatus.textContent = data.message;
      }
      
      // Atualizar etapas
      if (data.step && data.stepStatus) {
        this.updateStepStatus(data.step, data.stepStatus);
      }
    },
    
    // Atualizar status de uma etapa
    updateStepStatus: function(stepNumber, status) {
      // Obter referência ao elemento da etapa
      const stepKey = `step${stepNumber}`;
      const step = JaniceApp.elements.progressSteps[stepKey];
      
      if (!step) return;
      
      // Atualizar classe do indicador
      const indicator = step.querySelector('.step-indicator');
      indicator.className = `step-indicator ${status}`;
      
      // Atualizar classe da etapa
      step.className = `progress-step ${status}`;
      
      // Atualizar etapas anteriores para 'completed' se a etapa atual estiver ativa ou concluída
      if (status === 'active' || status === 'completed') {
        for (let i = 1; i < stepNumber; i++) {
          const prevStepKey = `step${i}`;
          const prevStep = JaniceApp.elements.progressSteps[prevStepKey];
          if (prevStep) {
            const prevIndicator = prevStep.querySelector('.step-indicator');
            prevIndicator.className = 'step-indicator completed';
            prevStep.className = 'progress-step completed';
          }
        }
      }
    },
    
    // Mostrar erro
    showError: function(message) {
      JaniceApp.elements.errorMessage.textContent = message;
      JaniceApp.utils.showOnlySection('error-container');
      
      // Configurar botão de tentar novamente
      JaniceApp.elements.tryAgainButton.onclick = () => {
        if (JaniceApp.state.currentClientId) {
          JaniceApp.elements.clientDetailsPanel.style.display = 'block';
          JaniceApp.elements.errorContainer.style.display = 'none';
        } else {
          JaniceApp.elements.welcomeContainer.style.display = 'block';
          JaniceApp.elements.errorContainer.style.display = 'none';
        }
      };
    }
  };
  
  // ===== MÓDULO DE TRANSCRIÇÕES =====
  
  JaniceApp.modules.transcriptions = {
    init: function() {
      console.log('🔄 Inicializando módulo de Transcrições...');
      
      // Configurar eventos
      this.setupEvents();
      
      console.log('✅ Módulo de Transcrições inicializado');
    },
    
    setupEvents: function() {
      // Botão de nova transcrição
      if (JaniceApp.elements.newTranscriptionBtn) {
        JaniceApp.elements.newTranscriptionBtn.addEventListener('click', () => this.showTranscriptionForm());
      }
      
      // Cancelar transcrição
      if (JaniceApp.elements.cancelTranscriptionBtn) {
        JaniceApp.elements.cancelTranscriptionBtn.addEventListener('click', () => {
          JaniceApp.elements.transcriptionContainer.style.display = 'none';
          
          if (JaniceApp.state.currentClientId) {
            JaniceApp.elements.clientDetailsPanel.style.display = 'block';
          } else {
            JaniceApp.elements.welcomeContainer.style.display = 'block';
          }
        });
      }
      
      // Submeter formulário de transcrição
      if (JaniceApp.elements.transcriptionForm) {
        JaniceApp.elements.transcriptionForm.addEventListener('submit', (e) => this.submitTranscriptionForm(e));
      }
      
      // Voltar do resultado da transcrição para detalhes do cliente
      if (JaniceApp.elements.backToClientBtn) {
        JaniceApp.elements.backToClientBtn.addEventListener('click', () => {
          JaniceApp.elements.transcriptionResultContainer.style.display = 'none';
          JaniceApp.elements.clientDetailsPanel.style.display = 'block';
        });
      }
      
      // Copiar transcrição
      if (JaniceApp.elements.copyTranscriptionBtn) {
        JaniceApp.elements.copyTranscriptionBtn.addEventListener('click', () => this.copyTranscription());
      }
      
      // Exportar TXT
      if (JaniceApp.elements.exportTxtBtn) {
        JaniceApp.elements.exportTxtBtn.addEventListener('click', () => this.exportTxt());
      }
      
      // Preview de arquivo de áudio/vídeo
      if (JaniceApp.elements.transcriptionFileInput) {
        JaniceApp.elements.transcriptionFileInput.addEventListener('change', (e) => {
          if (e.target.files.length > 0) {
            const file = e.target.files[0];
            
            // Verificar se é um arquivo de áudio ou vídeo
            if (file.type.startsWith('audio/') || file.type.startsWith('video/')) {
              // Criar preview do arquivo
              let previewHTML = '';
              
              if (file.type.startsWith('audio/')) {
                previewHTML = `
                  <audio controls>
                    <source src="${URL.createObjectURL(file)}" type="${file.type}">
                    Seu navegador não suporta o elemento de áudio.
                  </audio>
                  <p>${file.name} (${(file.size / (1024 * 1024)).toFixed(2)} MB)</p>
                `;
              } else {
                previewHTML = `
                  <video controls width="100%" height="150">
                    <source src="${URL.createObjectURL(file)}" type="${file.type}">
                    Seu navegador não suporta o elemento de vídeo.
                  </video>
                  <p>${file.name} (${(file.size / (1024 * 1024)).toFixed(2)} MB)</p>
                `;
              }
              
              JaniceApp.elements.audioPreview.innerHTML = previewHTML;
              JaniceApp.elements.audioPreview.style.display = 'block';
            }
          } else {
            JaniceApp.elements.audioPreview.style.display = 'none';
          }
        });
      }
    },
    
    // Mostrar formulário de nova transcrição
    showTranscriptionForm: function() {
      // Limpar formulário
      JaniceApp.elements.transcriptionForm.reset();
      JaniceApp.elements.audioPreview.style.display = 'none';
      JaniceApp.elements.audioPreview.innerHTML = '';
      
      // Adicionar aviso sobre tempo de processamento
      const infoBox = document.createElement('div');
      infoBox.className = 'info-box';
      infoBox.innerHTML = `
        <i class="fas fa-info-circle"></i>
        <p><strong>Importante:</strong> A transcrição ocorre em tempo real, o que significa que um arquivo de 10 minutos levará aproximadamente 10 minutos para ser processado. O sistema usa Whisper para oferecer alta qualidade de transcrição.</p>
      `;
      
      // Adicionar a caixa de informação antes do formulário
      const formContainer = document.querySelector('.transcription-form-container');
      if (formContainer && !formContainer.querySelector('.info-box')) {
        formContainer.insertBefore(infoBox, formContainer.firstChild);
      }
      
      // Mostrar apenas o formulário de transcrição (estado exclusivo)
      JaniceApp.utils.showOnlySection('transcription-container');
      
      // Scroll automático para o formulário de transcrição
      JaniceApp.utils.scrollToElement('transcription-container');
    },
    
    // Submeter formulário de transcrição
    submitTranscriptionForm: async function(event) {
      event.preventDefault();
      
      // Validar campos
      if (!JaniceApp.elements.transcriptionTitleInput.value.trim()) {
        alert('O título da transcrição é obrigatório');
        return;
      }
      
      if (!JaniceApp.elements.transcriptionFileInput.files.length) {
        alert('Por favor, selecione um arquivo de áudio ou vídeo');
        return;
      }
      
      // Verificar tamanho do arquivo (máximo 2GB)
      const fileSize = JaniceApp.elements.transcriptionFileInput.files[0].size / (1024 * 1024); // tamanho em MB
      console.log('🔥 [SCRIPT_3] Função submitTranscriptionForm do script_3.js foi chamada!');
      console.log('🔥 [SCRIPT_3] Tamanho do arquivo:', fileSize.toFixed(2), 'MB');
      
      if (fileSize > 2048) { // 2GB = 2048MB
        alert('O arquivo é muito grande. O tamanho máximo permitido é 2GB (2048MB).');
        return;
      }
      
      try {
        // Estimar duração do áudio baseada no tamanho do arquivo
        const estimatedAudioMinutes = Math.max(1, Math.ceil(fileSize / 1)); // ~1MB por minuto
        
        // Registrar processo no painel de processos ativos com metadados
        const client = JaniceApp.state.currentClients.find(c => c._id === JaniceApp.state.currentClientId);
        const processMetadata = {
          duracaoAudioMinutos: estimatedAudioMinutes,
          tamanhoArquivoMB: fileSize
        };
        
        const processId = JaniceApp.state.activeProcessesManager.registerProcess(
          'transcricao', 
          JaniceApp.state.currentClientId, 
          `Transcrição: ${JaniceApp.elements.transcriptionTitleInput.value.trim()}`,
          null,
          processMetadata
        );
        
        // Mostrar tela de carregamento
        JaniceApp.elements.transcriptionContainer.style.display = 'none';
        JaniceApp.elements.welcomeContainer.style.display = 'none';
        JaniceApp.elements.errorContainer.style.display = 'none';
        JaniceApp.elements.resultContainer.style.display = 'none';
        JaniceApp.elements.loadingContainer.style.display = 'block';
        
        // Adicionar classe para modo transcrição (simplifica interface)
        JaniceApp.elements.loadingContainer.classList.add('transcription-mode');
        
        // Adaptar tela de carregamento para transcrição
        JaniceApp.elements.loadingStatus.textContent = 'Iniciando transcrição...';
        document.querySelector('.loading-text').textContent = 'Processando arquivo de áudio/vídeo...';
        
        // Estimar duração baseada no tamanho do arquivo (aproximadamente 1MB por minuto para áudio de qualidade média)
        const estimatedMinutes = Math.max(1, Math.ceil(fileSize / 1));
        
        // Adicionar aviso sobre tempo de processamento real
        const infoElement = document.createElement('div');
        infoElement.className = 'transcription-time-info';
        infoElement.innerHTML = `
          <i class="fas fa-clock"></i> 
          <strong>Tempo estimado:</strong> A transcrição ocorre aproximadamente em tempo real. 
          Este arquivo de cerca de ${estimatedMinutes} minutos levará aproximadamente ${estimatedMinutes} minutos para ser processado.
        `;
        infoElement.style.margin = '15px 0';
        infoElement.style.padding = '10px';
        infoElement.style.backgroundColor = '#f8f9fa';
        infoElement.style.borderRadius = '5px';
        infoElement.style.fontSize = '14px';
        
        // Adicionar elemento abaixo da barra de progresso
        const progressContainer = document.querySelector('.progress-container');
        if (progressContainer && !progressContainer.querySelector('.transcription-time-info')) {
          progressContainer.appendChild(infoElement);
        }
        
        // Adaptação para transcrição
        document.getElementById('step-1').querySelector('.step-text').textContent = 'Preparando arquivo';
        document.getElementById('step-2').querySelector('.step-text').textContent = 'Processando áudio';
        document.getElementById('step-3').querySelector('.step-text').textContent = 'Gerando transcrição';
        document.getElementById('step-4').querySelector('.step-text').textContent = 'Finalizando';
        
        // Resetar barra de progresso
        JaniceApp.modules.analysis.resetProgress();
        
        // Decidir qual rota usar baseado no tamanho do arquivo
        let response;
        
        if (fileSize > 100) { // Arquivos maiores que 100MB usam Cloudinary
          console.log('📤 [SCRIPT_3] Arquivo grande detectado, usando rota Cloudinary...');
          
          // Verificar se a função Cloudinary está disponível
          if (typeof window.submitTranscriptionFormCloudinary === 'function') {
            console.log('✅ [SCRIPT_3] Delegando para função Cloudinary...');
            // Delegar para a função Cloudinary
            return window.submitTranscriptionFormCloudinary(event);
          } else {
            console.warn('⚠️ [SCRIPT_3] Função Cloudinary não disponível, usando upload direto...');
          }
        }
        
        console.log('📤 [SCRIPT_3] Usando upload direto via servidor...');
        
        // Preparar dados do formulário para upload direto
        const formData = new FormData();
        formData.append('titulo', JaniceApp.elements.transcriptionTitleInput.value.trim());
        formData.append('idioma', JaniceApp.elements.transcriptionLanguageSelect.value);
        formData.append('arquivo', JaniceApp.elements.transcriptionFileInput.files[0]);
        
        // Enviar requisição para iniciar transcrição via upload direto
        response = await fetch(`/api/transcricoes/upload/${JaniceApp.state.currentClientId}`, {
          method: 'POST',
          body: formData
        });
        
        if (!response.ok) {
          // Tentar extrair o erro da resposta
          let errorMessage = 'Erro ao iniciar transcrição';
          try {
            const errorData = await response.json();
            errorMessage = errorData.erro || 'Erro ao iniciar transcrição';
          } catch (jsonError) {
            // Caso a resposta não seja um JSON válido, tentar obter o texto
            try {
              const errorText = await response.text();
              if (errorText.includes('Tipo de arquivo não suportado')) {
                errorMessage = 'Tipo de arquivo não suportado. Por favor, envie apenas arquivos de áudio ou vídeo.';
              } else if (errorText.length < 200) {
                // Se for um texto curto, exibir diretamente
                errorMessage = errorText;
              }
            } catch (textError) {
              // Fallback para mensagem genérica
              console.error('Erro ao processar resposta:', textError);
            }
          }
          throw new Error(errorMessage);
        }
        
        // Obter ID da transcrição para acompanhar progresso
        const data = await response.json();
        const transcriptionId = data.transcricaoId;
        
        // Iniciar monitoramento de progresso via verificação periódica
        // O sistema SSE de processos ativos já está conectado e funcionando
        setTimeout(() => {
          this.startPeriodicStatusCheck(transcriptionId);
        }, 10000); // Iniciar após 10 segundos
        
        // Atualizar lista de transcrições em segundo plano
        this.loadClientTranscriptions(JaniceApp.state.currentClientId);
        
      } catch (error) {
        console.error('Erro:', error);
        JaniceApp.modules.analysis.showError(error.message || 'Ocorreu um erro ao iniciar a transcrição.');
      }
    },
    
    // Carregar transcrições do cliente
    loadClientTranscriptions: async function(clientId) {
      try {
        console.log(`🔄 [DEBUG] Carregando transcrições para cliente: ${clientId}`);
        
        // Quebrar cache do navegador adicionando timestamp
        const response = await fetch(`/api/transcricoes/cliente/${clientId}?t=${Date.now()}`, {
          credentials: 'include',
          headers: {
            'Accept': 'application/json'
          }
        });
        
        if (!response.ok) {
          console.error(`❌ [FETCH-ERROR] Status: ${response.status} ${response.statusText}`);
          console.error(`❌ [FETCH-ERROR] URL: ${response.url}`);
          console.error(`❌ [FETCH-ERROR] Headers:`, Object.fromEntries(response.headers.entries()));
          
          if (response.status === 502) {
            throw new Error('Erro 502: Servidor temporariamente indisponível. Tente novamente em alguns segundos.');
          } else if (response.status === 401) {
            throw new Error('Erro de autenticação. Faça login novamente.');
          } else {
            throw new Error(`Erro ${response.status}: ${response.statusText}`);
          }
        }
        
        const transcriptions = await response.json();
        
        console.log(`🔍 [DEBUG] Encontradas ${transcriptions.length} transcrições para cliente ${clientId}:`, transcriptions);
        
        // Validar se todas as transcrições pertencem ao cliente correto
        transcriptions.forEach(t => {
          if (t.cliente !== clientId) {
            console.error(`❌ [BUG] Transcrição ${t._id} pertence ao cliente ${t.cliente}, não ${clientId}`);
          }
        });
        
        if (!transcriptions.length) {
          JaniceApp.elements.transcriptionList.innerHTML = `
            <div class="transcription-list-empty">
              <i class="fas fa-microphone-slash"></i>
              <p>Nenhuma transcrição realizada</p>
            </div>
          `;
          return;
        }
        
        // Ordenar transcrições por data (mais recente primeiro)
        transcriptions.sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt));
        
        // Renderizar lista de transcrições
        JaniceApp.elements.transcriptionList.innerHTML = transcriptions.map(transcription => {
          // Calcular duração formatada
          const duration = this.formatDuration(transcription.duracao);
          
          // Determinar status e classe CSS
          let statusClass = 'completed';
          let statusText = 'Concluído';
          
          if (transcription.emProgresso) {
            statusClass = 'in-progress';
            statusText = 'Em progresso';
          } else if (transcription.erro) {
            statusClass = 'error';
            statusText = 'Erro';
          }
          
          return `
            <div class="transcription-item ${statusClass}" data-id="${transcription._id}">
              <div class="transcription-item-content">
                <div class="transcription-date">
                  ${new Date(transcription.dataCriacao).toLocaleDateString('pt-BR', {
                    day: '2-digit',
                    month: '2-digit',
                    year: 'numeric'
                  })}
                </div>
                <div class="transcription-title">
                  ${transcription.titulo}
                </div>
                <div class="transcription-meta">
                  <span><i class="fas fa-clock"></i> ${duration}</span>
                  <span><i class="fas fa-language"></i> ${transcription.idioma}</span>
                  <span class="transcription-status ${statusClass}">${statusText}</span>
                </div>
              </div>
              <div class="transcription-item-actions">
                <button class="delete-transcription-btn" data-id="${transcription._id}" title="Excluir transcrição">
                  <i class="fas fa-trash"></i>
                </button>
              </div>
            </div>
          `;
        }).join('');
        
        // Adicionar evento de clique para cada transcrição
        JaniceApp.elements.transcriptionList.querySelectorAll('.transcription-item').forEach(item => {
          const content = item.querySelector('.transcription-item-content');
          content.addEventListener('click', () => {
            const transcriptionId = item.dataset.id;
            this.viewTranscription(transcriptionId);
          });
        });
        
        // Adicionar eventos para botões de delete
        JaniceApp.elements.transcriptionList.querySelectorAll('.delete-transcription-btn').forEach(btn => {
          btn.addEventListener('click', (e) => {
            e.stopPropagation(); // Evitar que o clique propague para o item
            const transcriptionId = btn.dataset.id;
            this.deleteTranscription(transcriptionId);
          });
        });
        
      } catch (error) {
        console.error('Erro ao carregar transcrições:', error);
        JaniceApp.elements.transcriptionList.innerHTML = `
          <div class="transcription-list-empty">
            <i class="fas fa-exclamation-circle"></i>
            <p>Erro ao carregar transcrições. Tente novamente.</p>
          </div>
        `;
      }
    },
    
    // Visualizar uma transcrição específica
    viewTranscription: async function(transcriptionId) {
      try {
        const response = await fetch(`/api/transcricoes/${transcriptionId}`);
        if (!response.ok) {
          throw new Error('Erro ao carregar transcrição');
        }
        
        const transcription = await response.json();
        JaniceApp.state.currentTranscriptionData = transcription;
        
        // Preencher dados da transcrição
        JaniceApp.elements.transcriptionTitleDisplay.textContent = transcription.titulo;
        JaniceApp.elements.transcriptionDate.textContent = new Date(transcription.dataCriacao).toLocaleString('pt-BR');
        JaniceApp.elements.transcriptionDuration.textContent = this.formatDuration(transcription.duracao);
        
        // Exibir o texto da transcrição
        JaniceApp.elements.transcriptionText.textContent = transcription.conteudo;
        
        // Mostrar apenas a seção de resultado da transcrição (estado exclusivo)
        JaniceApp.utils.showOnlySection('transcription-result-container');
        
        // Scroll automático para a seção de resultado da transcrição
        JaniceApp.utils.scrollToElement('transcription-result-container');
        
      } catch (error) {
        console.error('Erro ao visualizar transcrição:', error);
        alert('Não foi possível carregar a transcrição. Tente novamente.');
      }
    },
    
    // Deletar transcrição
    deleteTranscription: async function(transcriptionId) {
      // Confirmar exclusão
      if (!confirm('Tem certeza que deseja excluir esta transcrição? Esta ação não pode ser desfeita.')) {
        return;
      }
      
      try {
        const response = await fetch(`/api/transcricoes/${transcriptionId}`, {
          method: 'DELETE'
        });
        
        if (!response.ok) {
          const errorData = await response.json();
          throw new Error(errorData.erro || 'Erro ao excluir transcrição');
        }
        
        // Recarregar lista de transcrições
        if (JaniceApp.state.currentClientId) {
          this.loadClientTranscriptions(JaniceApp.state.currentClientId);
        }
        
        // Mostrar feedback de sucesso
        console.log('✅ Transcrição excluída com sucesso');
        
      } catch (error) {
        console.error('Erro ao excluir transcrição:', error);
        alert('Não foi possível excluir a transcrição. Tente novamente.');
      }
    },
    
    // Copiar transcrição
    copyTranscription: function() {
      if (!JaniceApp.state.currentTranscriptionData) return;
      
      // Obter texto da transcrição
      const transcriptionContent = JaniceApp.state.currentTranscriptionData.conteudo;
      
      // Copiar para a área de transferência
      navigator.clipboard.writeText(transcriptionContent)
        .then(() => {
          const originalText = JaniceApp.elements.copyTranscriptionBtn.innerHTML;
          JaniceApp.elements.copyTranscriptionBtn.innerHTML = '<i class="fas fa-check"></i> Copiado!';
          
          setTimeout(() => {
            JaniceApp.elements.copyTranscriptionBtn.innerHTML = originalText;
          }, 2000);
        })
        .catch(err => {
          console.error('Erro ao copiar: ', err);
        });
    },
    
    // Exportar transcrição como TXT
    exportTxt: function() {
      if (!JaniceApp.state.currentTranscriptionData) return;
      
      // Obter texto da transcrição
      const transcriptionContent = JaniceApp.state.currentTranscriptionData.conteudo;
      const transcriptionTitle = JaniceApp.state.currentTranscriptionData.titulo || 'Transcrição';
      
      // Criar blob e link para download
      const blob = new Blob([transcriptionContent], { type: 'text/plain' });
      const url = URL.createObjectURL(blob);
      
      const a = document.createElement('a');
      a.href = url;
      a.download = `${transcriptionTitle.replace(/[^a-z0-9]/gi, '_').toLowerCase()}.txt`;
      document.body.appendChild(a);
      a.click();
      
      // Limpeza
      setTimeout(() => {
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
      }, 100);
    },
    
    // Função para formatar a duração em formato legível
    formatDuration: function(seconds) {
      if (!seconds) return '0:00';
      
      const minutes = Math.floor(seconds / 60);
      const remainingSeconds = Math.floor(seconds % 60);
      
      if (minutes < 60) {
        return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
      } else {
        const hours = Math.floor(minutes / 60);
        const remainingMinutes = minutes % 60;
        return `${hours}:${remainingMinutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
      }
    },
    
    // Iniciar atualizações de progresso via SSE (adaptada para transcrições)
    startProgressUpdates: function(clientId, type = 'analysis', resourceId = null) {
      // Fechar conexão anterior se existir
      if (window.progressEventSource) {
        window.progressEventSource.close();
      }
      
      // Armazenar informações sobre o processo atual
      window.currentProcessInfo = {
        type: type,
        resourceId: resourceId,
        clientId: clientId,
        startTime: new Date(),
        isChecking: false
      };
      
      // Abrir nova conexão SSE
      const eventSource = new EventSource(`/api/progress/${clientId}`);
      window.progressEventSource = eventSource;
      
      // Manipular eventos de progresso
      eventSource.addEventListener('progress', (event) => {
        const data = JSON.parse(event.data);
        this.updateProgress(data);
      });
      
      // Manipular eventos de erro
      eventSource.addEventListener('error', () => {
        // Fechar conexão em caso de erro
        eventSource.close();
        window.progressEventSource = null;
        
        // Iniciar verificação periódica como fallback se for uma transcrição
        if (type === 'transcription' && resourceId) {
          this.startPeriodicStatusCheck(resourceId);
        }
      });
      
      // Manipular eventos de conclusão
      eventSource.addEventListener('complete', (event) => {
        // Atualizar para 100% e fechar conexão
        JaniceApp.modules.analysis.updateProgress({
          percentage: 100,
          message: type === 'transcription' ? 'Transcrição concluída!' : 'Análise concluída!',
          step: 4,
          stepStatus: 'completed'
        });
        
        // Aguardar um momento para que o usuário veja que o progresso chegou a 100%
        setTimeout(() => {
          if (type === 'transcription' && resourceId) {
            // Buscar a transcrição completa e exibir o resultado
            this.viewTranscription(resourceId);
            
            // Parar verificação periódica se estiver em andamento
            this.stopPeriodicStatusCheck();
          } else if (window.currentAnalysisId) {
            // Buscar a análise completa e exibir o resultado
            JaniceApp.modules.analysis.viewAnalysis(window.currentAnalysisId);
          }
          
          // Fechar a conexão SSE
          eventSource.close();
          window.progressEventSource = null;
        }, 2000); // Aguardar 2 segundos antes de mostrar o resultado
      });
      
      // Para transcrições, iniciar verificação periódica como backup
      if (type === 'transcription' && resourceId) {
        // Iniciar após 30 segundos para dar tempo à barra de progresso SSE
        setTimeout(() => {
          this.startPeriodicStatusCheck(resourceId);
        }, 30000);
      }
    },
    
    // Atualizar progresso na UI (delegado para o módulo de análises)
    updateProgress: function(data) {
      JaniceApp.modules.analysis.updateProgress(data);
    },
    
    // Função para verificar periodicamente o status de uma transcrição com timeout inteligente
    startPeriodicStatusCheck: function(transcriptionId) {
      if (!window.currentProcessInfo || window.currentProcessInfo.isChecking) return;
      
      window.currentProcessInfo.isChecking = true;
      window.currentProcessInfo.transcriptionId = transcriptionId;
      window.currentProcessInfo.startTime = new Date();
      
      // Salvar no localStorage para persistência
      localStorage.setItem('activeTranscription', JSON.stringify({
        id: transcriptionId,
        startTime: window.currentProcessInfo.startTime,
        clientId: JaniceApp.state.currentClientId
      }));
      
      // Calcular timeout baseado no tamanho do arquivo (se disponível)
      const fileSize = window.currentProcessInfo.fileSizeMB || 35; // fallback para 35MB
      const timeoutMinutes = Math.max(10, Math.min(120, fileSize * 2)); // 2 min por MB, min 10min, max 2h
      const timeoutMs = timeoutMinutes * 60 * 1000;
      
      console.log(`🕐 [TRANSCRIPTION-MONITOR] Timeout configurado: ${timeoutMinutes} minutos para arquivo de ${fileSize}MB`);
      
      // Timeout de segurança
      window.transcriptionTimeout = setTimeout(() => {
        console.warn('⏰ [TRANSCRIPTION-MONITOR] Timeout atingido, cancelando monitoramento');
        this.handleTranscriptionTimeout(transcriptionId);
      }, timeoutMs);
      
      // Verificar status a cada 10 segundos (mais responsivo)
      window.statusCheckInterval = setInterval(async () => {
        try {
          const now = new Date();
          const elapsedMs = now - window.currentProcessInfo.startTime;
          const elapsedMinutes = Math.floor(elapsedMs / 60000);
          const elapsedSeconds = Math.floor((elapsedMs % 60000) / 1000);
          
          // Atualizar feedback visual com tempo decorrido
          const timeDisplay = `${elapsedMinutes}:${elapsedSeconds.toString().padStart(2, '0')}`;
          JaniceApp.elements.loadingStatus.textContent = `Processando... ${timeDisplay} / ~${timeoutMinutes}min`;
          
          // Verificar se a transcrição já foi concluída
          const response = await fetch(`/api/transcricoes/${transcriptionId}`);
          if (!response.ok) {
            console.error('Erro ao verificar status da transcrição');
            return;
          }
          
          const transcription = await response.json();
          
          // Se não está mais em progresso (concluída ou com erro)
          if (!transcription.emProgresso) {
            console.log('✅ [TRANSCRIPTION-MONITOR] Transcrição concluída via verificação periódica:', transcription);
            
            // Limpar monitoramento
            this.stopPeriodicStatusCheck();
            
            // Limpar localStorage
            localStorage.removeItem('activeTranscription');
            
            // Atualizar UI para mostrar conclusão
            JaniceApp.modules.analysis.updateProgress({
              percentage: 100,
              message: transcription.erro ? 'Erro na transcrição!' : 'Transcrição concluída!',
              step: 4,
              stepStatus: transcription.erro ? 'error' : 'completed'
            });
            
            // Após 2 segundos, mostrar o resultado
            setTimeout(() => {
              // Fechar conexão SSE se ainda existir
              if (window.progressEventSource) {
                window.progressEventSource.close();
                window.progressEventSource = null;
              }
              
              // Mostrar resultado
              if (!transcription.erro) {
                this.viewTranscription(transcriptionId);
              } else {
                JaniceApp.modules.analysis.showError(transcription.mensagemErro || 'Ocorreu um erro durante a transcrição.');
              }
            }, 2000);
            
            // Recarregar lista de transcrições em segundo plano
            if (JaniceApp.state.currentClientId) {
              this.loadClientTranscriptions(JaniceApp.state.currentClientId);
            }
          }
        } catch (error) {
          console.error('❌ [TRANSCRIPTION-MONITOR] Erro ao verificar status:', error);
        }
      }, 10000); // Verificar a cada 10 segundos (mais responsivo)
    },
    
    // Função para lidar com timeout de transcrição
    handleTranscriptionTimeout: function(transcriptionId) {
      console.warn('⏰ [TRANSCRIPTION-TIMEOUT] Transcrição atingiu timeout, limpando recursos...');
      
      // Parar monitoramento
      this.stopPeriodicStatusCheck();
      
      // Limpar localStorage
      localStorage.removeItem('activeTranscription');
      
      // Tentar limpar arquivo do BunnyCDN se possível
      const activeTranscription = JSON.parse(localStorage.getItem('activeTranscription') || '{}');
      if (activeTranscription.bunnycdnKey) {
        this.cleanupBunnyCDNFile(activeTranscription.bunnycdnKey);
      }
      
      // Mostrar erro de timeout
      JaniceApp.modules.analysis.showError(
        'A transcrição demorou mais que o esperado e foi cancelada. ' +
        'Isso pode acontecer com arquivos muito grandes ou problemas no servidor. ' +
        'Tente novamente com um arquivo menor ou entre em contato com o suporte.'
      );
    },
    
    // Função para limpar arquivo do BunnyCDN
    cleanupBunnyCDNFile: async function(fileName) {
      try {
        console.log('🗑️ [BUNNYCDN-CLEANUP] Tentando limpar arquivo:', fileName);
        await deleteFromBunnyCDN(fileName);
        console.log('✅ [BUNNYCDN-CLEANUP] Arquivo limpo com sucesso');
      } catch (error) {
        console.warn('⚠️ [BUNNYCDN-CLEANUP] Erro na limpeza (não crítico):', error);
      }
    },
    
    // Função para parar a verificação periódica
    stopPeriodicStatusCheck: function() {
      if (window.statusCheckInterval) {
        clearInterval(window.statusCheckInterval);
        window.statusCheckInterval = null;
      }
      
      if (window.currentProcessInfo) {
        window.currentProcessInfo.isChecking = false;
      }
    }
  };
  
  // ===== INICIALIZAÇÃO DOS MÓDULOS =====
  
  // Aguardar que o DOM esteja pronto e o JaniceApp inicializado
  document.addEventListener('DOMContentLoaded', () => {
    // Aguardar um pouco para garantir que o script principal foi executado
    setTimeout(() => {
      if (window.JaniceApp && window.JaniceApp.modules) {
        JaniceApp.modules.clients.init();
        JaniceApp.modules.analysis.init();
        JaniceApp.modules.transcriptions.init();
        console.log('✅ Módulos de script_3.js inicializados');
      } else {
        console.error('❌ JaniceApp não está disponível para inicializar módulos de script_3.js');
      }
    }, 200);
  });
  
})();