<!doctype html>
<html lang="pt-BR">
  <head>
    <meta charset="UTF-8" />
    <!-- Favicon principal -->
    <link rel="icon" type="image/svg+xml" href="/favicon.svg?v=1" />
    <!-- Fallback para navegadores que não suportam SVG -->
    <link rel="alternate icon" href="/favicon.svg?v=1" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover" />
    
    <!-- PWA Manifest -->
    <link rel="manifest" href="/manifest.json" />
    <meta name="theme-color" content="#667eea" />
    <meta name="mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-capable" content="yes" />
    <meta name="apple-mobile-web-app-status-bar-style" content="default" />
    <meta name="apple-mobile-web-app-title" content="FlashConCards" />
    <link rel="apple-touch-icon" href="/logo.svg" />
    
    <!-- SEO Meta Tags Otimizadas -->
    <title>FlashCards Para Concurso Público - Polícia Militar, Polícia Civil, GCM | FlashConCards</title>
    <meta name="description" content="FlashConCards: A melhor plataforma de flashcards para concursos públicos. Estude para Polícia Militar, PMGO, PC, GCM e muito mais. Flashcards interativos, questões comentadas e simulados. Comece agora!" />
    <meta name="keywords" content="flashcards, flashconcards, concurso público, concurso polícia militar, concurso policial, estude para concursos, flashcards para concursos, PMGO, PC, GCM, polícia militar goiás, concurso PMGO, concurso PC, flashcards interativos, questões comentadas, simulados concursos, preparatório concursos, curso concurso público, estudo para concursos, flashcards online, sistema repetição espaçada, SRS flashcards, concurso policial civil, concurso guarda municipal, flashcards PMGO, flashcards PC, flashcards polícia militar" />
    <meta name="author" content="FlashConCards" />
    <meta name="robots" content="index, follow, max-image-preview:large, max-snippet:-1, max-video-preview:-1" />
    <link rel="canonical" href="https://www.flashconcards.com.br/" />
    
    <!-- Open Graph / Facebook -->
    <meta property="og:type" content="website" />
    <meta property="og:url" content="https://www.flashconcards.com.br/" />
    <meta property="og:title" content="FlashCards Para Concurso Público - Polícia Militar, Polícia Civil, GCM | FlashConCards" />
    <meta property="og:description" content="A melhor plataforma de flashcards para concursos públicos. Estude para Polícia Militar, PMGO, PC, GCM e muito mais." />
    <meta property="og:image" content="https://www.flashconcards.com.br/logo.svg" />
    <meta property="og:locale" content="pt_BR" />
    <meta property="og:site_name" content="FlashConCards" />
    
    <!-- Twitter -->
    <meta name="twitter:card" content="summary_large_image" />
    <meta name="twitter:url" content="https://www.flashconcards.com.br/" />
    <meta name="twitter:title" content="FlashCards Para Concurso Público - Polícia Militar, Polícia Civil, GCM" />
    <meta name="twitter:description" content="A melhor plataforma de flashcards para concursos públicos. Estude para Polícia Militar, PMGO, PC e muito mais!" />
    <meta name="twitter:image" content="https://www.flashconcards.com.br/logo.svg" />
    
    <!-- Preconnect para recursos externos (melhor TTFB) - Ordem importante! -->
    <!-- Firebase primeiro (mais crítico) -->
    <link rel="preconnect" href="https://firestore.googleapis.com" crossorigin />
    <link rel="preconnect" href="https://firebase.googleapis.com" crossorigin />
    <link rel="dns-prefetch" href="https://firestore.googleapis.com" />
    <link rel="dns-prefetch" href="https://firebase.googleapis.com" />
    <!-- Google Tag Manager -->
    <link rel="preconnect" href="https://www.googletagmanager.com" crossorigin />
    <link rel="dns-prefetch" href="https://www.googletagmanager.com" />
    <!-- Fonts (menos crítico) -->
    <link rel="preconnect" href="https://fonts.googleapis.com" crossorigin />
    <link rel="dns-prefetch" href="https://fonts.googleapis.com" />
    
    <!-- Preload de recursos críticos para melhor performance -->
    <link rel="modulepreload" href="/assets/jsx/main--SxBGEaL-1775232178347-v2.5-flash.jsx" />
    <link rel="modulepreload" href="/assets/jsx/App-Bb1iLVGj-1775232178347-v2.5-flash.jsx" />
    <link rel="modulepreload" href="/assets/jsx/PublicHome-B3-u8TKH-1775232178347-v2.5-flash.jsx" />
    <!-- Prefetch de rotas comuns para melhor navegação -->
    <link rel="prefetch" href="/login" />
    <link rel="prefetch" href="/dashboard" />
    
    <!-- CSS crítico inline para evitar bloqueio de renderização e CLS -->
    <style>
      /* CSS crítico mínimo para evitar CLS e melhorar LCP */
      * { box-sizing: border-box; }
      body { 
        margin: 0; 
        padding: 0; 
        font-family: system-ui, -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
        background-color: #f8fafc;
        color: #1e293b;
        /* Prevenir reflow forçado */
        contain: layout style;
        /* Otimizar renderização de texto */
        text-rendering: optimizeSpeed;
      }
      body.dark {
        background-color: #0f172a;
        color: #f1f5f9;
      }
      #root { 
        min-height: 100vh;
        background-color: inherit;
        /* Otimizar renderização */
        contain: layout style;
      }
      /* Header fixo para evitar CLS */
      header {
        contain: layout style paint;
      }
      /* Footer fixo para evitar CLS */
      footer { 
        min-height: 60px; 
        display: flex; 
        align-items: center; 
        justify-content: center; 
        padding: 1rem;
        /* Reservar espaço para evitar layout shift */
        contain: layout style paint;
      }
      /* Hero/Banner section - altura mínima para evitar CLS */
      .hero-section, .banner-section {
        min-height: 300px;
        contain: layout style paint;
      }
      /* Reviews section - altura fixa para evitar CLS */
      .reviews-container {
        min-height: 400px;
        contain: layout style paint;
      }
      /* Otimizar animações com will-change - apenas quando necessário */
      [class*="animate-"]:not([class*="animate-pulse"]),
      [class*="motion-"] {
        will-change: transform, opacity;
      }
      /* Prevenir reflow forçado em imagens */
      img, video {
        max-width: 100%;
        height: auto;
        /* Otimizar renderização de imagens */
        content-visibility: auto;
        /* Evitar layout shift */
        -o-object-fit: cover;
           object-fit: cover;
      }
      /* Otimizar renderização de elementos acima da dobra */
      .above-fold {
        contain: layout style paint;
      }
      /* Skeleton loader para evitar CLS durante carregamento */
      .skeleton {
        background: linear-gradient(90deg, #f0f0f0 25%, #e0e0e0 50%, #f0f0f0 75%);
        background-size: 200% 100%;
        animation: loading 1.5s ease-in-out infinite;
      }
      @keyframes loading {
        0% { background-position: 200% 0; }
        100% { background-position: -200% 0; }
      }
      /* Otimizar fontes para evitar FOIT */
      @font-face {
        font-family: 'system';
        font-style: normal;
        font-weight: 400;
        font-display: swap;
      }
      /* Botões e links - estilos críticos */
      button, a {
        cursor: pointer;
        transition: opacity 0.2s;
      }
      button:disabled {
        opacity: 0.5;
        cursor: not-allowed;
      }
      /* Container principal - otimizar layout */
      main {
        contain: layout style;
      }
      /* Loading spinner - evitar CLS */
      .spinner {
        display: inline-block;
        width: 2rem;
        height: 2rem;
        border: 3px solid rgba(0,0,0,0.1);
        border-top-color: currentColor;
        border-radius: 50%;
        animation: spin 0.6s linear infinite;
      }
      @keyframes spin {
        to { transform: rotate(360deg); }
      }
      /* Otimizar renderização de cards */
      .card, [class*="card"] {
        contain: layout style paint;
      }
      /* Preload de recursos críticos - melhorar LCP */
      .lcp-image {
        content-visibility: auto;
        contain-intrinsic-size: 400px 300px;
      }
    </style>
    <!-- CSS não crítico - defer para não bloquear renderização -->
    <noscript></noscript>
    <!-- Fallback para navegadores sem suporte a preload -->
    <script>
      (function() {
        var link = document.createElement('link');
        link.rel = 'stylesheet';
        link.href = '/src/index.css';
        link.media = 'print';
        link.onload = function() { this.media = 'all'; };
        document.head.appendChild(link);
      })();
    </script>
    
    <!-- Google tag (gtag.js) - Carregar de forma não bloqueante -->
    <script>
      // Carregar gtag de forma assíncrona para não bloquear TTFB
      (function() {
        const script = document.createElement('script');
        script.async = true;
        script.src = 'https://www.googletagmanager.com/gtag/js?id=AW-17766035851';
        document.head.appendChild(script);
        
        window.dataLayer = window.dataLayer || [];
        function gtag(){dataLayer.push(arguments);}
        gtag('js', new Date());
        gtag('config', 'AW-17766035851');
      })();
    </script>
    
    <script>
      // Suprimir mensagens do React DevTools e imagens base64 grandes
      (function() {
        // Função para detectar se uma string contém imagem base64 grande (fora do try para ser acessível)
        const hasLargeBase64 = (str) => {
          try {
            if (typeof str !== 'string') return false;
            // Detectar data URIs de imagem base64 (mais de 50KB de dados base64)
            const base64Pattern = /data:image\/[^;]+;base64,([A-Za-z0-9+/=]{50000,})/;
            return base64Pattern.test(str);
          } catch (e) {
            return false; // Se houver erro, não filtrar
          }
        };
        
        try {
          const originalLog = console.log;
          const originalWarn = console.warn;
          const originalError = console.error;
          
          // Interceptar console.log para filtrar React DevTools e imagens base64 grandes
          console.log = function(...args) {
            try {
              const message = args.join(' ');
              // Filtrar mensagens do React DevTools
              if (message.includes('Download the React DevTools') || 
                  message.includes('react-devtools') ||
                  message.includes('react.dev/link/react-devtools')) {
                return; // Não exibir esta mensagem
              }
              // Filtrar imagens base64 grandes
              const filtered = args.filter(arg => {
                try {
                  return !hasLargeBase64(String(arg));
                } catch (e) {
                  return true; // Em caso de erro, manter o argumento
                }
              });
              if (filtered.length > 0) {
                originalLog.apply(console, filtered);
              }
            } catch (e) {
              // Se houver erro, usar o console original
              originalLog.apply(console, args);
            }
          };
          
          // Interceptar console.warn para filtrar imagens base64 grandes
          console.warn = function(...args) {
            try {
              const filtered = args.filter(arg => {
                try {
                  return !hasLargeBase64(String(arg));
                } catch (e) {
                  return true;
                }
              });
              if (filtered.length > 0) {
                originalWarn.apply(console, filtered);
              }
            } catch (e) {
              originalWarn.apply(console, args);
            }
          };
          
          // Interceptar console.error para filtrar imagens base64 grandes
          console.error = function(...args) {
            try {
              const filtered = args.filter(arg => {
                try {
                  return !hasLargeBase64(String(arg));
                } catch (e) {
                  return true;
                }
              });
              if (filtered.length > 0) {
                originalError.apply(console, filtered);
              }
            } catch (e) {
              originalError.apply(console, args);
            }
          };
        } catch (e) {
          // Se houver erro ao configurar os filtros, continuar normalmente
          // Não fazer nada - manter console original
        }
        
        // Event listeners para suprimir erros conhecidos
        try {
          window.addEventListener('error', function(event) {
            try {
              // Suprimir erros do Firebase Auth iframe
              if (event.message && (
                event.message.includes('fireauth is not defined') ||
                event.message.includes('ERR_CONTENT_DECODING_FAILED') ||
                (event.filename && event.filename.includes('iframe.js')) ||
                (event.filename && event.filename.includes('__/auth/iframe'))
              )) {
                event.preventDefault();
                event.stopPropagation();
                return false;
              }
              
              // Suprimir erros que contêm imagens base64 grandes
              if (event.message && hasLargeBase64(event.message)) {
                event.preventDefault();
                event.stopPropagation();
                return false;
              }
            } catch (e) {
              // Ignorar erros no handler
            }
          }, true);
          
          // Suprimir erros de rede do Firebase Auth iframe
          window.addEventListener('unhandledrejection', function(event) {
            try {
              if (event.reason && (
                (event.reason.message && event.reason.message.includes('ERR_CONTENT_DECODING_FAILED')) ||
                (event.reason.stack && event.reason.stack.includes('iframe.js'))
              )) {
                event.preventDefault();
                return false;
              }
              
              // Suprimir rejections que contêm imagens base64 grandes
              if (event.reason && (
                (event.reason.message && hasLargeBase64(String(event.reason.message))) ||
                (event.reason.stack && hasLargeBase64(String(event.reason.stack)))
              )) {
                event.preventDefault();
                return false;
              }
            } catch (e) {
              // Ignorar erros no handler
            }
          });
        } catch (e) {
          // Ignorar erros ao adicionar event listeners
        }
      })();
      
      // Aplicar dark mode antes do React renderizar para evitar flash
      (function() {
        try {
          const saved = localStorage.getItem('darkMode');
          if (saved === 'true') {
            document.documentElement.classList.add('dark');
          }
        } catch (e) {
          console.error('Erro ao carregar dark mode:', e);
        }
      })();
    </script>
    <script type="module" crossorigin src="/assets/js/index-DhM1VEH8-1775232178347-v2.5-flash.js"></script>
    <link rel="modulepreload" crossorigin href="/assets/js/vendor-C-T1_hW4-1775232178347-v2.5-flash.js">
    <link rel="modulepreload" crossorigin href="/assets/js/firebase-vendor-BZuyhloA-1775232178347-v2.5-flash.js">
    <link rel="stylesheet" crossorigin href="/assets/css/index-BZnO7DF7-1775232178347-v2.5-flash.css">
  </head>
  <body>
    <div id="root"></div>
    
    <!-- Service Worker Registration -->
    <script>
      // Função para limpar cache do Service Worker
      window.clearServiceWorkerCache = async function() {
        if ('serviceWorker' in navigator && navigator.serviceWorker.controller) {
          try {
            // Enviar mensagem para o Service Worker limpar cache
            const channel = new MessageChannel()
            channel.port1.onmessage = (event) => {
              if (event.data.success) {
                console.log('✅ Cache do Service Worker limpo com sucesso')
                // Recarregar página após limpar cache
                window.location.reload()
              }
            }
            
            navigator.serviceWorker.controller.postMessage(
              { type: 'CLEAR_CACHE' },
              [channel.port2]
            )
          } catch (error) {
            console.error('❌ Erro ao limpar cache:', error)
            // Fallback: limpar todos os caches diretamente
            if ('caches' in window) {
              const cacheNames = await caches.keys()
              await Promise.all(cacheNames.map(name => caches.delete(name)))
              console.log('✅ Cache limpo via fallback')
              window.location.reload()
            }
          }
        } else if ('caches' in window) {
          // Se não tem Service Worker, limpar caches diretamente
          const cacheNames = await caches.keys()
          await Promise.all(cacheNames.map(name => caches.delete(name)))
          console.log('✅ Cache limpo (sem Service Worker)')
          window.location.reload()
        }
      }
      
      // Registrar Service Worker para PWA - TEMPORARIAMENTE DESABILITADO
      // Descomentar após corrigir erros
      /*
      if ('serviceWorker' in navigator) {
        window.addEventListener('load', () => {
          navigator.serviceWorker.register('/sw.js')
            .then((registration) => {
              console.log('✅ Service Worker registrado com sucesso:', registration.scope)
              
              // Verificar atualizações periodicamente
              registration.addEventListener('updatefound', () => {
                const newWorker = registration.installing
                newWorker.addEventListener('statechange', () => {
                  if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
                    // Novo service worker disponível
                    console.log('🔄 Nova versão disponível. Recarregue a página para atualizar.')
                  }
                })
              })
              
              // Limpar cache inválido na inicialização (apenas uma vez por sessão)
              if (!sessionStorage.getItem('sw_cache_cleaned')) {
                // Verificar se há cache inválido e limpar
                setTimeout(() => {
                  if (navigator.serviceWorker.controller) {
                    const channel = new MessageChannel()
                    navigator.serviceWorker.controller.postMessage(
                      { type: 'CLEAR_CACHE' },
                      [channel.port2]
                    )
                    sessionStorage.setItem('sw_cache_cleaned', 'true')
                  }
                }, 2000) // Aguardar 2s para não bloquear carregamento inicial
              }
            })
            .catch((error) => {
              console.error('❌ Erro ao registrar Service Worker:', error)
            })
        })
      }
      */
      
      // Desregistrar Service Workers antigos que podem estar causando problemas
      if ('serviceWorker' in navigator) {
        navigator.serviceWorker.getRegistrations().then((registrations) => {
          registrations.forEach((registration) => {
            registration.unregister().then(() => {
              console.log('✅ Service Worker antigo desregistrado')
            }).catch((err) => {
              console.warn('⚠️ Erro ao desregistrar Service Worker:', err)
            })
          })
        })
      }
    </script>
  </body>
</html>
