import { createRoot } from 'react-dom/client'
import App from './App.tsx'
import './index.css'
import { UpdateAvailableDialog } from './components/pwa/UpdateAvailableDialog'
import { checkOfflineModeEnabled } from './utils/offlineConfig'
import { safeLocalStorage } from './utils/safeLocalStorage'
import { captureTrackingParams } from './utils/trackingParams'

// Capture UTM / fbclid / gclid params from the landing URL before any
// React navigation can strip them. Persisted in sessionStorage and
// forwarded to Hotmart via the pre-checkout modals.
captureTrackingParams();

// Verificação de integridade antes do render
const initializeApp = () => {
  try {
    const rootElement = document.getElementById("root");
    if (!rootElement) {
      console.error('❌ Root element not found');
      return;
    }

    const root = createRoot(rootElement);
    root.render(<App />);
    console.log('✅ App initialized successfully');
  } catch (error) {
    console.error('❌ Error initializing app:', error);
    // Fallback de emergência
    document.body.innerHTML = '<div style="padding: 20px; text-align: center;">Carregando aplicação...</div>';
  }
};

// Inicializar app
initializeApp();

// Função para mostrar dialog de atualização
const showUpdateDialog = (newWorker: ServiceWorker) => {
  // Verificar se deve mostrar o dialog baseado na rota atual
  const currentPath = window.location.pathname;
  const isLandingOrAuth = currentPath === '/sistemagestao' || currentPath === '/auth' || currentPath === '/' || currentPath === '/inicio';
  
  // Não mostrar dialog na sistemagestao ou página de login
  if (isLandingOrAuth) {
    console.log('🚫 PWA: Update dialog suppressed on sistemagestao/auth page');
    return;
  }
  
  // Verificar se está em iframe (Lovable preview)
  try {
    if (window.self !== window.top) {
      console.log('🚫 PWA: Update dialog suppressed in iframe');
      return;
    }
  } catch {
    console.log('🚫 PWA: Update dialog suppressed in cross-origin iframe');
    return;
  }

  console.log('📱 PWA: Showing update dialog');
  
  // Criar container para o dialog
  const dialogContainer = document.createElement('div');
  document.body.appendChild(dialogContainer);
  
  const dialogRoot = createRoot(dialogContainer);
  
  const handleUpdate = () => {
    newWorker.postMessage({ type: 'SKIP_WAITING' });
    window.location.reload();
  };
  
  const handleDismiss = () => {
    dialogRoot.unmount();
    document.body.removeChild(dialogContainer);
  };
  
  dialogRoot.render(
    <UpdateAvailableDialog
      open={true}
      onUpdate={handleUpdate}
      onDismiss={handleDismiss}
    />
  );
};

// Função para detectar ambiente de desenvolvimento/Lovable
const isDevelopment = () => {
  const hostname = window.location.hostname;
  const href = window.location.href;
  
  return hostname === 'localhost' ||
         hostname === '127.0.0.1' ||
         hostname.includes('lovableproject.com') ||
         hostname.includes('lovable.app') ||
         hostname.includes('lovable.dev') ||
         hostname.includes('preview-') ||
         href.includes('preview') ||
         href.includes('lovable') ||
         import.meta.env.DEV;
};

// Função para detectar especificamente o ambiente Lovable
const isLovableEnvironment = () => {
  const hostname = window.location.hostname;
  const href = window.location.href;
  
  try {
    const inIframe = window.self !== window.top;
    const hasLovableHostname = hostname.includes('lovable') || 
                              hostname.includes('lovableproject') ||
                              href.includes('lovable');
    const hasLovableReferrer = document.referrer.includes('lovable');
    
    return inIframe && (hasLovableHostname || hasLovableReferrer);
  } catch {
    // Cross-origin iframe - likely Lovable
    return hostname.includes('lovable') || href.includes('lovable');
  }
};

// Função para detectar se é Capacitor
const isCapacitor = () => {
  return !!(window as any).Capacitor;
};

// Função para detectar dispositivo móvel/tablet
const isMobileOrTablet = () => {
  return /Android|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ||
         (navigator.maxTouchPoints && navigator.maxTouchPoints > 1);
};

// Função para detectar PWA standalone
const isStandalone = () => {
  return window.matchMedia('(display-mode: standalone)').matches ||
         (window.navigator as any).standalone === true;
};

// Função para desregistrar Service Workers com limpeza agressiva
const unregisterServiceWorker = async () => {
  if ('serviceWorker' in navigator) {
    try {
      const registrations = await navigator.serviceWorker.getRegistrations();
      for (const registration of registrations) {
        const success = await registration.unregister();
        if (success) {
          console.log('🗑️ PWA: Service Worker desregistrado:', registration.scope);
        }
      }
      
      // Força recarregamento para garantir limpeza completa em ambiente Lovable
      if (isLovableEnvironment() && registrations.length > 0) {
        console.log('🔄 PWA: Recarregando para limpar Service Worker no Lovable');
        setTimeout(() => window.location.reload(), 100);
      }
    } catch (error) {
      console.warn('⚠️ PWA: Erro ao desregistrar Service Worker:', error);
    }
  }
};

// Limpar caches antigos durante desenvolvimento
const clearDevelopmentCaches = async () => {
  if ('caches' in window && isDevelopment()) {
    try {
      // Primeiro desregistrar SW existente
      await unregisterServiceWorker();
      
      // Depois limpar todos os caches
      const cacheNames = await caches.keys();
      await Promise.all(
        cacheNames.map(cacheName => caches.delete(cacheName))
      );
      console.log('🧹 PWA: Caches de desenvolvimento limpos');
      
      // Limpar storage relacionado ao SW
      safeLocalStorage.removeItem('swVersion');
      
    } catch (error) {
      console.warn('⚠️ PWA: Erro ao limpar caches:', error);
    }
  }
};

// Determinar se deve registrar Service Worker com verificação otimizada
const shouldRegisterServiceWorker = async () => {
  // Nunca registrar em desenvolvimento ou Lovable
  if (isDevelopment() || isLovableEnvironment()) {
    console.log('🔧 Development/Lovable mode: Service Worker not registered');
    return false;
  }
  
  // Detectar se está em iframe
  try {
    if (window.self !== window.top) {
      console.log('🖼️ Iframe environment: Service Worker not registered');
      return false;
    }
  } catch (error) {
    console.log('🖼️ Cross-origin iframe: Service Worker not registered');
    return false;
  }
  
  // Verificação de configuração com timeout e fallback
  let offlineModeEnabled = false;
  try {
    const timeoutPromise = new Promise<boolean>((_, reject) => 
      setTimeout(() => reject(new Error('Timeout')), 3000)
    );
    
    offlineModeEnabled = await Promise.race([
      checkOfflineModeEnabled(),
      timeoutPromise
    ]);
  } catch (error) {
    console.warn('⚠️ PWA: Timeout/erro na verificação offline, usando fallback');
    offlineModeEnabled = false;
  }
  
  if (!offlineModeEnabled) {
    console.log('⚙️ Offline mode disabled by admin: Service Worker not registered');
    return false;
  }
  
  // Registrar apenas se for:
  // - Capacitor (app nativo) OU
  // - PWA standalone OU  
  // - Mobile/tablet em produção
  const shouldRegister = isCapacitor() || isStandalone() || isMobileOrTablet();
  console.log(`📱 Capacitor: ${isCapacitor()}, Standalone: ${isStandalone()}, Mobile/Tablet: ${isMobileOrTablet()}, Offline enabled: ${offlineModeEnabled}, Should register SW: ${shouldRegister}`);
  
  return shouldRegister;
};

// Registrar Service Worker apenas quando apropriado
if ('serviceWorker' in navigator) {
  window.addEventListener('load', async () => {
    const shouldRegister = await shouldRegisterServiceWorker();
    
    if (shouldRegister) {
      navigator.serviceWorker.register('/sw.js')
        .then((registration) => {
          console.log('🚀 PWA: Service Worker registrado com sucesso', registration.scope);
          
          // Verificar por atualizações
          registration.addEventListener('updatefound', () => {
            const newWorker = registration.installing;
            if (newWorker) {
              newWorker.addEventListener('statechange', () => {
                if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
                  console.log('🔄 PWA: Nova versão disponível');
                  
                  // Aguardar um pouco para garantir que a página carregou completamente
                  setTimeout(() => {
                    showUpdateDialog(newWorker);
                  }, 2000);
                }
              });
            }
          });
        })
        .catch((registrationError) => {
          console.log('❌ PWA: Falha ao registrar Service Worker:', registrationError);
        });
    } else {
      // Sempre limpar caches e desregistrar SW quando não deveria estar ativo
      if (isDevelopment()) {
        console.log('🔧 PWA: Ambiente de desenvolvimento detectado');
        clearDevelopmentCaches();
      } else {
        // Em produção, mas não deveria ter SW (desktop ou desabilitado)
        unregisterServiceWorker();
      }
      
      if (isDevelopment()) {
        console.log('🔧 PWA: Service Worker desativado durante desenvolvimento');
      } else {
        console.log('ℹ️ PWA: Service Worker desativado por configuração ou ambiente');
      }
    }
  });
}