Spaces:

caarleexx
/

Stf

Paused

App Files Files Community

caarleexx commited on Mar 3

Commit

cd040e7

verified ·

1 Parent(s): 6bff912

Update app.py

Browse files

Files changed (1) hide show

app.py +843 -396

app.py CHANGED Viewed

@@ -7,23 +7,20 @@ import logging
 import requests
 import urllib3
 from flask import Flask, request, jsonify, render_template_string
-from playwright.sync_api import sync_playwright, TimeoutError as PlaywrightTimeoutError
 import traceback
 # Suprimir warnings de SSL
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
-# Configuração detalhada de logging
-logging.basicConfig(
-    level=logging.DEBUG,  # Mudar para DEBUG para mais detalhes
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
 logger = logging.getLogger(__name__)
 app = Flask(__name__)
 # ============================================
-# PAYLOAD COMPLETO com TODOS os campos
 # ============================================
 PAYLOAD_COMPLETO = {
     "query": {
@@ -37,8 +34,38 @@ PAYLOAD_COMPLETO = {
                         {"query_string": {
                             "default_operator": "AND",
                             "fields": [
                                 "ementa_texto.plural^3",
-                                "acordao_ata.plural^3"
                             ],
                             "query": "*",
                             "type": "cross_fields",
@@ -50,489 +77,909 @@ PAYLOAD_COMPLETO = {
         }
     },
     "_source": [
-        "id", "titulo", "ementa_texto", "acordao_ata", "decisao_texto",
-        "processo_codigo_completo", "processo_numero", "julgamento_data",
-        "publicacao_data", "orgao_julgador", "relator_processo_nome",
-        "ministro_facet", "partes_lista_texto", "inteiro_teor_url",
-        "documental_legislacao_citada_texto", "documental_jurisprudencia_citada_texto",
-        "is_repercussao_geral", "documental_tese_texto"
     ],
-    "size": 10,
     "from": 0,
     "sort": [{"julgamento_data": {"order": "desc"}}],
     "track_total_hits": True
 }
 # Constantes da API
 URL_API = "https://jurisprudencia.stf.jus.br/api/search/search"
 HEADERS = {
     "Accept": "application/json, text/plain, */*",
     "Content-Type": "application/json",
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
     "Referer": "https://jurisprudencia.stf.jus.br/pages/search",
     "Origin": "https://jurisprudencia.stf.jus.br"
 }
-# Cache simples para tokens
-token_cache = {
-    "token": None,
-    "expires_at": 0
-}
-# Template HTML simplificado para teste
 HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html>
 <head>
-    <title>STF Jurisprudência - Teste</title>
     <meta charset="utf-8">
     <style>
-        body { font-family: Arial, sans-serif; max-width: 1200px; margin: 0 auto; padding: 20px; }
-        .container { background: white; border-radius: 10px; padding: 20px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
-        h1 { color: #333; border-bottom: 2px solid #4CAF50; padding-bottom: 10px; }
-        button { background: #4CAF50; color: white; border: none; padding: 10px 20px; font-size: 16px; border-radius: 5px; cursor: pointer; }
-        pre { background: #f5f5f5; padding: 15px; border-radius: 5px; overflow: auto; max-height: 500px; }
-        .error { color: red; background: #ffeeee; padding: 10px; border-radius: 5px; }
-        .success { color: green; background: #eeffee; padding: 10px; border-radius: 5px; }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>⚖️ STF Jurisprudência - Teste</h1>
-        <button onclick="test()">Testar Conexão</button>
-        <button onclick="search()">Buscar Documentos</button>
-        <div id="result"></div>
     </div>
     <script>
-        async function test() {
-            document.getElementById('result').innerHTML = 'Testando...';
             try {
-                const response = await fetch('/api/health');
                 const data = await response.json();
-                document.getElementById('result').innerHTML = '<pre>' + JSON.stringify(data, null, 2) + '</pre>';
-            } catch(e) {
-                document.getElementById('result').innerHTML = '<div class="error">Erro: ' + e.message + '</div>';
             }
         }
-        async function search() {
-            document.getElementById('result').innerHTML = 'Buscando...';
             try {
-                const response = await fetch('/api/test-bypass', { method: 'POST' });
                 const data = await response.json();
-                document.getElementById('result').innerHTML = '<pre>' + JSON.stringify(data, null, 2) + '</pre>';
-            } catch(e) {
-                document.getElementById('result').innerHTML = '<div class="error">Erro: ' + e.message + '</div>';
             }
         }
     </script>
 </body>
 </html>
 """
 # ============================================
-# Funções auxiliares com tratamento de erro
 # ============================================
 def get_fresh_token():
-    """Obtém um token novo via Playwright com tratamento de erro"""
     global token_cache
-    logger.debug("get_fresh_token: Iniciando")
-    # Verificar cache
     if token_cache["token"] and time.time() < token_cache["expires_at"]:
         logger.info("Usando token em cache")
         return token_cache["token"]
     logger.info("Obtendo novo token via Playwright")
-    playwright = None
-    browser = None
     try:
-        from playwright.sync_api import sync_playwright
-        playwright = sync_playwright().start()
-        logger.debug("Playwright iniciado")
-        browser = playwright.chromium.launch(
-            headless=True,
-            args=['--no-sandbox', '--disable-dev-shm-usage']
-        )
-        logger.debug("Navegador iniciado")
-        context = browser.new_context(
-            viewport={'width': 1920, 'height': 1080},
-            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        )
-        page = context.new_page()
-        logger.debug("Página criada")
-        # Navegar para a página
-        response = page.goto(
-            "https://jurisprudencia.stf.jus.br/pages/search",
-            wait_until='domcontentloaded',
-            timeout=30000
-        )
-        if not response:
-            raise Exception("Sem resposta da página")
-        logger.debug(f"Página carregada: status {response.status}")
-        # Aguardar um pouco
-        page.wait_for_timeout(3000)
-        # Obter cookies
-        cookies = context.cookies()
-        token = None
-        for cookie in cookies:
-            if cookie.get('name') == 'aws-waf-token':
-                token = cookie.get('value')
-                logger.debug(f"Token encontrado: {token[:30]}...")
-                break
-        if not token:
-            logger.warning("Token não encontrado nos cookies")
-            # Tentar extrair de localStorage
-            token = page.evaluate("""
-                () => {
-                    for(let i=0; i<localStorage.length; i++) {
-                        let key = localStorage.key(i);
-                        if(key && key.includes('waf')) {
-                            return localStorage.getItem(key);
-                        }
-                    }
-                    return null;
-                }
-            """)
             if token:
-                logger.debug(f"Token encontrado no localStorage: {token[:30]}...")
-        return token
     except Exception as e:
         logger.error(f"Erro ao obter token: {str(e)}")
-        logger.error(traceback.format_exc())
         return None
-    finally:
-        if browser:
-            try:
-                browser.close()
-                logger.debug("Navegador fechado")
-            except:
-                pass
-        if playwright:
-            try:
-                playwright.stop()
-                logger.debug("Playwright parado")
-            except:
-                pass
 def search_with_token(token, custom_payload=None):
-    """Faz busca usando token com tratamento de erro"""
-    logger.debug("search_with_token: Iniciando")
     if not token:
         return {"success": False, "error": "Token não fornecido"}
     payload = custom_payload or PAYLOAD_COMPLETO
     headers = HEADERS.copy()
     headers['Cookie'] = f'aws-waf-token={token}'
     try:
-        logger.debug(f"Fazendo requisição para {URL_API}")
-        response = requests.post(
-            URL_API,
-            headers=headers,
-            json=payload,
-            verify=False,  # Ignorar SSL para teste
-            timeout=30
-        )
-        logger.debug(f"Resposta: status {response.status_code}")
         if response.status_code == 200:
-            try:
-                data = response.json()
-                return {"success": True, "data": data}
-            except Exception as e:
-                return {"success": False, "error": f"Erro ao decodificar JSON: {str(e)}"}
         else:
-            return {
-                "success": False,
-                "error": f"HTTP {response.status_code}",
-                "text": response.text[:500]
-            }
-    except requests.exceptions.Timeout:
-        return {"success": False, "error": "Timeout na requisição"}
-    except requests.exceptions.ConnectionError as e:
-        return {"success": False, "error": f"Erro de conexão: {str(e)}"}
     except Exception as e:
-        return {"success": False, "error": str(e), "traceback": traceback.format_exc()}
-def test_playwright_installation():
-    """Testa se o Playwright está instalado corretamente"""
-    logger.info("Testando instalação do Playwright...")
     try:
-        from playwright.sync_api import sync_playwright
         with sync_playwright() as p:
-            # Tenta listar navegadores disponíveis
-            browsers = p.chromium, p.firefox, p.webkit
-            logger.info(f"Navegadores disponíveis: Chromium, Firefox, WebKit")
-            # Tenta iniciar Chromium
-            browser = p.chromium.launch(headless=True)
             browser.close()
-        logger.info("✅ Playwright instalado corretamente")
-        return True
-    except ImportError as e:
-        logger.error(f"❌ Playwright não importado: {e}")
-        return False
     except Exception as e:
-        logger.error(f"❌ Erro no Playwright: {e}")
-        logger.error(traceback.format_exc())
-        return False
 # ============================================
-# Rotas da aplicação
 # ============================================
 @app.route('/')
 def index():
-    """Página principal"""
     try:
         return render_template_string(HTML_TEMPLATE)
     except Exception as e:
-        logger.error(f"Erro ao renderizar template: {e}")
-        return f"Erro: {str(e)}", 500
-@app.route('/api/health', methods=['GET'])
-def health():
-    """Health check detalhado"""
-    logger.debug("Health check requisitado")
-    result = {
-        "status": "checking",
-        "timestamp": time.time(),
-        "python_version": sys.version,
-        "environment": {}
-    }
-    # Verificar variáveis de ambiente importantes
-    result["environment"]["PORT"] = os.environ.get('PORT', 'não definido')
-    result["environment"]["HOME"] = os.environ.get('HOME', 'não definido')
-    result["environment"]["PATH"] = os.environ.get('PATH', 'não definido')[:100] + "..."
-    # Verificar Playwright
-    try:
-        from playwright.sync_api import sync_playwright
-        result["playwright_import"] = "ok"
-        with sync_playwright() as p:
-            browsers = []
-            if hasattr(p, 'chromium'):
-                browsers.append('chromium')
-            if hasattr(p, 'firefox'):
-                browsers.append('firefox')
-            if hasattr(p, 'webkit'):
-                browsers.append('webkit')
-            result["playwright_browsers"] = browsers
-        result["playwright_status"] = "ok"
-    except Exception as e:
-        result["playwright_status"] = f"erro: {str(e)}"
-    # Verificar requests
-    try:
-        test_response = requests.get("https://httpbin.org/get", timeout=5)
-        result["requests_status"] = f"ok (status {test_response.status_code})"
-    except Exception as e:
-        result["requests_status"] = f"erro: {str(e)}"
-    # Tentar obter token
     token = get_fresh_token()
-    result["token_obtained"] = bool(token)
-    if token:
-        result["token_preview"] = token[:30] + "..."
-    # Tentar busca simples
-    if token:
-        try:
-            test_search = search_with_token(token, {"size": 1, "track_total_hits": True})
-            result["test_search"] = "ok" if test_search.get("success") else f"falha: {test_search.get('error')}"
-            if test_search.get("success") and test_search["data"].get("hits", {}).get("total"):
-                result["total_docs"] = test_search["data"]["hits"]["total"]["value"]
-        except Exception as e:
-            result["test_search"] = f"erro: {str(e)}"
-    result["status"] = "healthy"
-    return jsonify(result)
 @app.route('/api/test-bypass', methods=['POST'])
 def test_bypass():
-    """Endpoint de teste com fallback"""
-    logger.info("Requisição de teste recebida")
-    result = {
-        "success": False,
-        "timestamp": time.time(),
-        "attempts": []
-    }
-    # Tentar com token primeiro
-    logger.info("Tentando obter token...")
     token = get_fresh_token()
     if token:
-        logger.info("Token obtido, tentando busca...")
-        search_result = search_with_token(token)
-        result["attempts"].append({
-            "method": "token",
-            "success": search_result.get("success", False),
-            "token_used": bool(token)
-        })
-        if search_result.get("success"):
-            result["success"] = True
-            result["data"] = search_result["data"]
-            result["token"] = token
-            return jsonify(result)
-    else:
-        result["attempts"].append({
-            "method": "token",
-            "success": False,
-            "error": "Não foi possível obter token"
-        })
-    # Se falhou, tentar Playwright direto
-    logger.info("Tentando acesso direto com Playwright...")
     try:
-        from playwright.sync_api import sync_playwright
         with sync_playwright() as p:
-            browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
-            context = browser.new_context()
-            page = context.new_page()
-            # Navegar e executar busca
-            page.goto("https://jurisprudencia.stf.jus.br/pages/search",
-                     wait_until='domcontentloaded',
-                     timeout=30000)
-            # Executar busca via JavaScript
-            api_result = page.evaluate("""
-                async () => {
-                    try {
-                        const response = await fetch('https://jurisprudencia.stf.jus.br/api/search/search', {
-                            method: 'POST',
-                            headers: {'Content-Type': 'application/json'},
-                            body: JSON.stringify({
-                                query: {match_all: {}},
-                                size: 5
-                            })
-                        });
-                        return await response.json();
-                    } catch(e) {
-                        return {error: e.toString()};
-                    }
-                }
-            """)
-            browser.close()
-            if api_result and not api_result.get('error'):
-                result["success"] = True
-                result["method"] = "playwright_direct"
-                result["data"] = api_result
-                result["attempts"].append({
-                    "method": "playwright_direct",
-                    "success": True
-                })
-                return jsonify(result)
-            else:
-                result["attempts"].append({
-                    "method": "playwright_direct",
-                    "success": False,
-                    "error": api_result.get('error', 'Falha desconhecida')
-                })
-    except Exception as e:
-        logger.error(f"Erro no Playwright direto: {str(e)}")
-        result["attempts"].append({
-            "method": "playwright_direct",
-            "success": False,
-            "error": str(e),
-            "traceback": traceback.format_exc()
-        })
-    # Se todas as tentativas falharam
-    result["error"] = "Todas as tentativas falharam"
-    return jsonify(result), 500
-@app.route('/api/debug', methods=['GET'])
-def debug():
-    """Endpoint de debug para verificar ambiente"""
-    debug_info = {
-        "cwd": os.getcwd(),
-        "files": os.listdir('.'),
-        "env": dict(os.environ),
-        "python_path": sys.path,
-        "modules": list(sys.modules.keys())[:20]  # Primeiros 20 módulos
-    }
-    return jsonify(debug_info)
-@app.errorhandler(Exception)
-def handle_error(error):
-    """Handler global de erros"""
-    logger.error(f"Erro não tratado: {str(error)}")
-    logger.error(traceback.format_exc())
     return jsonify({
-        "error": str(error),
-        "type": type(error).__name__,
-        "traceback": traceback.format_exc()
-    }), 500
 if __name__ == '__main__':
-    print("="*60)
-    print("🚀 Iniciando aplicação STF Jurisprudência")
-    print("="*60)
-    # Informações do sistema
-    print(f"Python version: {sys.version}")
-    print(f"Current directory: {os.getcwd()}")
-    print(f"Files in directory: {os.listdir('.')}")
-    # Testar importações
     try:
-        import flask
-        print(f"✅ Flask version: {flask.__version__}")
-    except ImportError as e:
-        print(f"❌ Flask: {e}")
     try:
-        import requests
-        print(f"✅ Requests version: {requests.__version__}")
-    except ImportError as e:
-        print(f"❌ Requests: {e}")
-    # Testar Playwright
-    playwright_ok = test_playwright_installation()
-    # Porta
     port = int(os.environ.get('PORT', 7860))
-    print(f"📡 Porta: {port}")
-    print("="*60)
-    # Iniciar app
-    app.run(host='0.0.0.0', port=port, debug=True)  # debug=True para mais detalhes

 import requests
 import urllib3
 from flask import Flask, request, jsonify, render_template_string
+from playwright.sync_api import sync_playwright
 import traceback
 # Suprimir warnings de SSL
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+# Configuração de logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 app = Flask(__name__)
 # ============================================
+# PAYLOAD COMPLETO (com True/False maiúsculos)
 # ============================================
 PAYLOAD_COMPLETO = {
     "query": {
                         {"query_string": {
                             "default_operator": "AND",
                             "fields": [
+                                "processo_codigo_completo.plural",
+                                "acordao_ata.plural^3",
+                                "documental_acordao_mesmo_sentido_lista_texto.plural",
+                                "documental_doutrina_texto.plural",
+                                "documental_indexacao_texto.plural",
+                                "documental_jurisprudencia_citada_texto.plural",
+                                "documental_legislacao_citada_texto.plural",
+                                "documental_observacao_texto.plural",
+                                "documental_publicacao_lista_texto.plural",
+                                "documental_tese_tema_texto.plural^3",
+                                "documental_tese_texto.plural^3",
                                 "ementa_texto.plural^3",
+                                "ministro_facet.plural",
+                                "revisor_processo_nome.plural",
+                                "orgao_julgador.plural",
+                                "partes_lista_texto.plural",
+                                "procedencia_geografica_completo.plural",
+                                "processo_classe_processual_unificada_extenso.plural",
+                                "titulo.plural^6",
+                                "colac_numero.plural",
+                                "colac_pagina.plural",
+                                "decisao_texto.plural^2",
+                                "documental_decisao_mesmo_sentido_lista_texto.plural",
+                                "processo_precedente_texto.plural",
+                                "sumula_texto.plural^3",
+                                "ramo_direito.plural^1",
+                                "situacao_sumula.plural^1",
+                                "materia_noticia.plural^1",
+                                "titulo_noticia.plural^3",
+                                "resumo_noticia.plural^3",
+                                "conteudo_noticia.plural^1",
+                                "ramo_noticia.plural^1"
                             ],
                             "query": "*",
                             "type": "cross_fields",
         }
     },
     "_source": [
+        "base", "_id", "id", "dg_unique",
+        "titulo", "ministro_facet", "orgao_julgador",
+        "procedencia_geografica_completo",
+        "procedencia_geografica_pais_sigla",
+        "procedencia_geografica_uf_sigla",
+        "procedencia_geografica_uf_extenso",
+        "processo_codigo_completo",
+        "processo_classe_processual_unificada_extenso",
+        "processo_classe_processual_unificada_classe_sigla",
+        "processo_classe_processual_unificada_incidente_sigla",
+        "processo_classe_processual_unificada_sigla",
+        "processo_numero",
+        "processo_lista_texto",
+        "julgamento_data",
+        "publicacao_data",
+        "republicacao_data",
+        "periodo_inicio_data",
+        "periodo_fim_data",
+        "dg_atualizado_em",
+        "is_decisao_presidencia",
+        "relator_processo_nome",
+        "relator_decisao_nome",
+        "relator_acordao_nome",
+        "presidente_nome",
+        "revisor_processo_nome",
+        "ementa_texto",
+        "acordao_ata",
+        "decisao_texto",
+        "inteiro_teor_url",
+        "sumula_texto",
+        "partes_lista_texto",
+        "acompanhamento_processual_url",
+        "dje_url",
+        "informativo_url",
+        "pesquisa_url",
+        "audio_url",
+        "video_url",
+        "numero_noticias_url",
+        "aprovacao_url",
+        "documental_publicacao_lista_texto",
+        "documental_decisao_mesmo_sentido_lista_texto",
+        "documental_decisao_mesmo_sentido_lista_html",
+        "documental_decisao_mesmo_sentido_is_secundario",
+        "documental_legislacao_citada_texto",
+        "documental_jurisprudencia_citada_texto",
+        "documental_indexacao_texto",
+        "documental_observacao_texto",
+        "documental_observacao_html",
+        "documental_doutrina_texto",
+        "documental_acordao_mesmo_sentido_lista_texto",
+        "documental_acordao_mesmo_sentido_lista_html",
+        "documental_acordao_mesmo_sentido_is_secundario",
+        "documental_assunto_texto",
+        "documental_tese_tipo",
+        "documental_tese_texto",
+        "documental_tese_tema_texto",
+        "externo_seq_objeto_incidente",
+        "volume_informativo",
+        "ramo_noticia",
+        "materia_noticia",
+        "titulo_noticia",
+        "resumo_noticia",
+        "conteudo_noticia",
+        "numero_noticias_processo",
+        "is_covid",
+        "tipo_julgamento",
+        "julgamento_is_sessao_virtual",
+        "sumula_numero",
+        "is_vinculante",
+        "situacao_sumula",
+        "ramo_direito",
+        "processo_precedente_texto",
+        "processo_precedente_html",
+        "is_questao_ordem",
+        "is_repercussao_geral_admissibilidade",
+        "is_repercussao_geral_merito",
+        "is_repercussao_geral_recurso_interno",
+        "is_repercussao_geral",
+        "is_processo_antigo",
+        "is_colac",
+        "colac_numero",
+        "colac_pagina",
+        "old_seq_colac",
+        "old_seq_repercussao_geral",
+        "old_seq_sjur",
+        "ods_onu"
     ],
+    "aggs": {
+        "base_agg": {
+            "filters": {
+                "filters": {
+                    "acordaos": {"match": {"base": "acordaos"}},
+                    "sumulas": {"match": {"base": "sumulas"}},
+                    "decisoes": {"match": {"base": "decisoes"}},
+                    "informativos": {"match": {"base": "novo_informativo"}}
+                }
+            }
+        },
+        "orgao_julgador_agg": {
+            "aggs": {
+                "orgao_julgador_agg": {
+                    "terms": {"field": "orgao_julgador.keyword", "size": 10}
+                }
+            }
+        },
+        "ministro_facet_agg": {
+            "aggs": {
+                "ministro_facet_agg": {
+                    "terms": {"field": "ministro_facet.keyword", "size": 10}
+                }
+            }
+        },
+        "procedencia_geografica_uf_sigla_agg": {
+            "aggs": {
+                "procedencia_geografica_uf_sigla_agg": {
+                    "terms": {"field": "procedencia_geografica_uf_sigla", "size": 10}
+                }
+            }
+        }
+    },
+    "highlight": {
+        "fields": {
+            "ementa_texto": {"matched_fields": ["ementa_texto.plural"], "type": "fvh", "fragment_size": 24000},
+            "sumula_texto": {"matched_fields": ["sumula_texto.plural"], "type": "fvh", "number_of_fragments": 0},
+            "materia_noticia": {"matched_fields": ["materia_noticia.plural"], "type": "fvh"},
+            "titulo_noticia": {"matched_fields": ["titulo_noticia.plural"], "type": "fvh"},
+            "resumo_noticia": {"matched_fields": ["resumo_noticia.plural"], "type": "fvh", "fragment_size": 5000},
+            "conteudo_noticia": {"matched_fields": ["conteudo_noticia.plural"], "type": "fvh", "fragment_size": 50000},
+            "acordao_ata": {"matched_fields": ["acordao_ata.plural"], "type": "fvh", "fragment_size": 600},
+            "decisao_texto": {"matched_fields": ["decisao_texto.plural"], "type": "fvh", "fragment_size": 1200},
+            "documental_tese_texto": {"matched_fields": ["documental_tese_texto.plural"], "type": "fvh", "fragment_size": 2000},
+            "documental_tese_tema_texto": {"matched_fields": ["documental_tese_tema_texto.plural"], "type": "fvh", "fragment_size": 2000},
+            "documental_observacao_texto": {"matched_fields": ["documental_observacao_texto.plural"], "type": "fvh"},
+            "documental_indexacao_texto": {"matched_fields": ["documental_indexacao_texto.plural"], "type": "fvh"},
+            "documental_legislacao_citada_texto": {"matched_fields": ["documental_legislacao_citada_texto.plural"], "type": "fvh"},
+            "documental_jurisprudencia_citada_texto": {"matched_fields": ["documental_jurisprudencia_citada_texto.plural"], "type": "fvh"},
+            "documental_doutrina_texto": {"matched_fields": ["documental_doutrina_texto.plural"], "type": "fvh"},
+            "partes_lista_texto": {"matched_fields": ["partes_lista_texto.plural"], "type": "fvh"},
+            "documental_publicacao_lista_texto": {"matched_fields": ["documental_publicacao_lista_texto.plural"], "type": "fvh"},
+            "documental_acordao_mesmo_sentido_lista_texto": {"matched_fields": ["documental_acordao_mesmo_sentido_lista_texto.plural"], "type": "fvh"},
+            "documental_decisao_mesmo_sentido_lista_texto": {"matched_fields": ["documental_decisao_mesmo_sentido_lista_texto.plural"], "type": "fvh"},
+            "processo_precedente_texto": {"matched_fields": ["processo_precedente_texto.plural"], "type": "fvh"},
+            "procedencia_geografica_completo": {"matched_fields": ["procedencia_geografica_completo.plural"], "type": "fvh"}
+        },
+        "pre_tags": ["<em>"],
+        "post_tags": ["</em>"],
+        "fragment_size": 300,
+        "number_of_fragments": 64,
+        "order": "score"
+    },
+    "size": 100,
     "from": 0,
     "sort": [{"julgamento_data": {"order": "desc"}}],
     "track_total_hits": True
 }
+# Payload para busca por ID
+PAYLOAD_POR_ID = {
+    "query": {"ids": {"values": []}},
+    "_source": PAYLOAD_COMPLETO["_source"],
+    "highlight": PAYLOAD_COMPLETO["highlight"],
+    "size": 1
+}
 # Constantes da API
 URL_API = "https://jurisprudencia.stf.jus.br/api/search/search"
 HEADERS = {
     "Accept": "application/json, text/plain, */*",
     "Content-Type": "application/json",
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
     "Referer": "https://jurisprudencia.stf.jus.br/pages/search",
     "Origin": "https://jurisprudencia.stf.jus.br"
 }
+# Cache de token
+token_cache = {"token": None, "expires_at": 0}
+# ============================================
+# HTML TEMPLATE COMPLETO (com abas, botões, etc.)
+# ============================================
 HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html>
 <head>
+    <title>⚖️ STF Jurisprudência - Visualizador Completo</title>
     <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
     <style>
+        body { font-family: 'Segoe UI', Roboto, system-ui, sans-serif; max-width: 1600px; margin: 0 auto; padding: 20px; background: #f0f2f5; }
+        .container { background: white; border-radius: 12px; padding: 30px; box-shadow: 0 8px 20px rgba(0,0,0,0.1); }
+        h1 { color: #1a1a2e; border-bottom: 3px solid #4CAF50; padding-bottom: 15px; display: flex; align-items: center; gap: 10px; }
+        h1:before { content: "⚖️"; font-size: 1.2em; }
+        h2 { color: #2c3e50; margin-top: 25px; margin-bottom: 15px; font-size: 1.5em; border-left: 5px solid #4CAF50; padding-left: 15px; }
+        h3 { color: #34495e; margin-top: 20px; margin-bottom: 10px; font-size: 1.2em; border-bottom: 1px solid #e0e0e0; padding-bottom: 8px; }
+        .info-box { background: #e8f0fe; border-left: 5px solid #2196F3; padding: 15px 20px; margin: 20px 0; border-radius: 8px; }
+        .stats-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 25px 0; }
+        .stat-card { background: white; border: 1px solid #e0e0e0; border-radius: 10px; padding: 20px; text-align: center; box-shadow: 0 2px 8px rgba(0,0,0,0.05); }
+        .stat-value { font-size: 32px; font-weight: bold; color: #1a73e8; }
+        .stat-label { color: #5f6368; font-size: 14px; margin-top: 8px; text-transform: uppercase; letter-spacing: 0.5px; }
+        .button-group { display: flex; gap: 15px; flex-wrap: wrap; margin: 25px 0; }
+        button { background: #1a73e8; color: white; border: none; padding: 14px 28px; font-size: 16px; font-weight: 500; border-radius: 8px; cursor: pointer; transition: all 0.3s; display: inline-flex; align-items: center; gap: 10px; box-shadow: 0 2px 8px rgba(26,115,232,0.3); }
+        button:hover { background: #1557b0; transform: translateY(-2px); box-shadow: 0 4px 12px rgba(26,115,232,0.4); }
+        button:disabled { background: #a0a0a0; cursor: not-allowed; transform: none; box-shadow: none; }
+        button.secondary { background: #34a853; }
+        button.secondary:hover { background: #2d8745; }
+        button.download { background: #f9ab00; color: #1a1a2e; }
+        button.download:hover { background: #e69c00; }
+        .loading { display: inline-block; width: 20px; height: 20px; border: 3px solid rgba(255,255,255,0.3); border-top: 3px solid white; border-radius: 50%; animation: spin 1s linear infinite; margin-right: 10px; vertical-align: middle; }
+        @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
+        pre { background: #f8f9fa; border: 1px solid #e0e0e0; border-radius: 10px; padding: 20px; overflow: auto; max-height: 800px; font-size: 13px; font-family: 'Consolas', 'Monaco', monospace; box-shadow: inset 0 2px 4px rgba(0,0,0,0.05); }
+        .success { color: #0f9d58; background: #e6f4ea; border-left: 5px solid #34a853; padding: 15px 20px; margin: 15px 0; border-radius: 8px; font-weight: 500; }
+        .error { color: #d93025; background: #fce8e6; border-left: 5px solid #ea4335; padding: 15px 20px; margin: 15px 0; border-radius: 8px; font-weight: 500; }
+        .warning { color: #e37400; background: #fef7e0; border-left: 5px solid #f9ab00; padding: 15px 20px; margin: 15px 0; border-radius: 8px; font-weight: 500; }
+        .token-box { background: #1a1a2e; color: #e0e0e0; padding: 15px; border-radius: 8px; font-family: 'Consolas', monospace; word-break: break-all; margin: 15px 0; border: 1px solid #2a2a3e; }
+        .token-label { color: #f9ab00; font-weight: bold; margin-bottom: 8px; display: block; }
+        .filters { background: #f8f9fa; border-radius: 8px; padding: 20px; margin: 20px 0; border: 1px solid #e0e0e0; }
+        .filter-group { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; align-items: end; }
+        .filter-item { min-width: 200px; }
+        .filter-item label { display: block; margin-bottom: 8px; color: #5f6368; font-size: 14px; font-weight: 500; }
+        .filter-item input, .filter-item select { width: 100%; padding: 10px; border: 1px solid #ddd; border-radius: 6px; font-size: 14px; }
+        .filter-item input:focus, .filter-item select:focus { outline: none; border-color: #1a73e8; box-shadow: 0 0 0 2px rgba(26,115,232,0.2); }
+        .badge { display: inline-block; background: #e8f0fe; color: #1a73e8; padding: 4px 12px; border-radius: 20px; font-size: 13px; font-weight: 500; margin: 2px; }
+        .campo-lista { background: #f8f9fa; border: 1px solid #e9ecef; border-radius: 8px; padding: 15px; margin: 10px 0; }
+        .campo-nome { font-weight: bold; color: #2c3e50; font-size: 14px; text-transform: uppercase; letter-spacing: 0.5px; margin-bottom: 5px; }
+        .campo-valor { color: #1a1a2e; font-size: 14px; word-break: break-word; font-family: 'Consolas', monospace; background: white; padding: 8px; border-radius: 4px; border: 1px solid #e0e0e0; }
+        .campo-vazio { color: #999; font-style: italic; }
+        .texto-completo { max-height: 400px; overflow-y: auto; background: #f1f8fe; padding: 15px; border-radius: 8px; border: 1px solid #b8daf5; margin: 10px 0; white-space: pre-wrap; font-family: inherit; line-height: 1.5; }
+        .nav-tabs { display: flex; gap: 5px; margin: 20px 0; flex-wrap: wrap; border-bottom: 2px solid #e0e0e0; padding-bottom: 10px; }
+        .nav-tab { padding: 10px 20px; cursor: pointer; background: white; border: 1px solid #e0e0e0; border-radius: 8px 8px 0 0; margin-bottom: -2px; font-weight: 500; transition: all 0.2s; }
+        .nav-tab:hover { background: #f0f0f0; }
+        .nav-tab.active { background: #1a73e8; color: white; border-color: #1a73e8; }
+        .tab-content { display: none; padding: 20px; background: white; border: 1px solid #e0e0e0; border-top: none; border-radius: 0 0 8px 8px; }
+        .tab-content.active { display: block; }
+        .campo-card { background: #f8f9fa; border: 1px solid #e9ecef; border-radius: 8px; padding: 15px; margin: 10px 0; transition: all 0.2s; }
+        .campo-card:hover { box-shadow: 0 4px 12px rgba(0,0,0,0.1); border-color: #1a73e8; }
+        .flag-true { color: #0f9d58; font-weight: bold; }
+        .flag-false { color: #d93025; }
+        .url-link { color: #1a73e8; text-decoration: none; word-break: break-all; }
+        .url-link:hover { text-decoration: underline; }
+        .highlight { background-color: #f9ab00; color: #1a1a2e; font-weight: bold; padding: 2px 4px; border-radius: 4px; }
+        .highlight-box { background: #fef7e0; border: 1px solid #f9ab00; padding: 10px; border-radius: 8px; margin: 10px 0; }
+        .highlight-title { font-weight: bold; color: #e37400; margin-bottom: 5px; }
     </style>
 </head>
 <body>
     <div class="container">
+        <h1>STF Jurisprudência - Visualizador Completo</h1>
+        <div class="info-box">
+            <strong>📌 API de Jurisprudência do STF - Todos os Campos com Highlight</strong><br>
+            • Total de campos disponíveis: <span id="totalCampos">102</span><br>
+            • Campos com highlight: 22 campos configurados<br>
+            • Documentos disponíveis: <span id="totalDocs">carregando...</span>
+        </div>
+        <div class="stats-grid">
+            <div class="stat-card"><div class="stat-value" id="requestsCount">0</div><div class="stat-label">Requisições</div></div>
+            <div class="stat-card"><div class="stat-value" id="successCount">0</div><div class="stat-label">Sucessos</div></div>
+            <div class="stat-card"><div class="stat-value" id="failCount">0</div><div class="stat-label">Falhas</div></div>
+            <div class="stat-card"><div class="stat-value" id="docsCount">0</div><div class="stat-label">Docs Obtidos</div></div>
+        </div>
+        <div class="filters">
+            <h3 style="margin-top: 0;">🔍 Filtros de Busca</h3>
+            <div class="filter-group">
+                <div class="filter-item">
+                    <label>Quantidade</label>
+                    <select id="pageSize">
+                        <option value="5">5 resultados</option>
+                        <option value="10">10 resultados</option>
+                        <option value="25">25 resultados</option>
+                        <option value="50">50 resultados</option>
+                        <option value="100" selected>100 resultados</option>
+                    </select>
+                </div>
+                <div class="filter-item">
+                    <label>Ordenar por</label>
+                    <select id="sortOrder">
+                        <option value="desc">Mais recentes</option>
+                        <option value="asc">Mais antigos</option>
+                    </select>
+                </div>
+                <div class="filter-item">
+                    <label>Base</label>
+                    <select id="base">
+                        <option value="acordaos">Acórdãos</option>
+                        <option value="decisoes">Decisões</option>
+                        <option value="sumulas">Súmulas</option>
+                        <option value="informativos">Informativos</option>
+                        <option value="">Todas</option>
+                    </select>
+                </div>
+                <div class="filter-item">
+                    <label>Busca por ID</label>
+                    <input type="text" id="docId" placeholder="Ex: sjur505215">
+                </div>
+            </div>
+        </div>
+        <div class="button-group">
+            <button id="testBtn" onclick="runSearch()">
+                <span class="loading" id="loading" style="display: none;"></span>
+                <span>🔍 Buscar Documentos</span>
+            </button>
+            <button id="getByIdBtn" class="secondary" onclick="getDocumentById()">
+                <span>📄 Buscar por ID</span>
+            </button>
+            <button id="downloadBtn" class="download" onclick="downloadJSON()" disabled>
+                📥 Download JSON
+            </button>
+            <button id="copyBtn" class="secondary" onclick="copyToken()">
+                🔑 Copiar Token
+            </button>
+        </div>
+        <div id="tokenDisplay" style="display: none;" class="token-box">
+            <span class="token-label">🔐 Token AWS WAF</span>
+            <span id="tokenValue"></span>
+        </div>
+        <div id="result" style="margin-top: 25px;"></div>
     </div>
     <script>
+        let lastResult = null;
+        let lastToken = null;
+        let requestsCount = 0, successCount = 0, failCount = 0, docsCount = 0;
+        function renderCampo(nome, valor, tipo = 'normal') {
+            if (valor === null || valor === undefined || valor === '') {
+                return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-vazio">(vazio)</div></div>`;
+            }
+            if (tipo === 'url' && valor) {
+                return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-valor"><a href="${valor}" target="_blank" class="url-link">${valor}</a></div></div>`;
+            }
+            if (tipo === 'flag') {
+                const flagClass = valor ? 'flag-true' : 'flag-false';
+                return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-valor ${flagClass}">${valor ? '✓ Sim' : '✗ Não'}</div></div>`;
+            }
+            if (tipo === 'texto' && valor && valor.length > 200) {
+                return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="texto-completo">${valor.replace(/\\n/g, '<br>').replace(/<em>/g, '<span class="highlight">').replace(/<\\/em>/g, '</span>')}</div></div>`;
+            }
+            if (Array.isArray(valor)) {
+                return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-valor">${valor.join('<br>')}</div></div>`;
+            }
+            return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-valor">${String(valor).replace(/\\n/g, '<br>').replace(/<em>/g, '<span class="highlight">').replace(/<\\/em>/g, '</span>')}</div></div>`;
+        }
+        function renderHighlight(highlight) {
+            if (!highlight) return '';
+            let html = '<div class="highlight-box"><div class="highlight-title">🔆 Termos destacados (highlight):</div>';
+            for (const [campo, valores] of Object.entries(highlight)) {
+                if (valores && valores.length > 0) {
+                    html += `<div><strong>${campo}:</strong> `;
+                    valores.forEach(valor => {
+                        html += `<div style="margin-left: 20px; margin-top: 5px;">${valor.replace(/<em>/g, '<span class="highlight">').replace(/<\\/em>/g, '</span>')}</div>`;
+                    });
+                    html += '</div>';
+                }
+            }
+            html += '</div>';
+            return html;
+        }
+        function displayResult(data) {
+            if (!data || !data.result || !data.result.hits || !data.result.hits.hits || data.result.hits.hits.length === 0) {
+                document.getElementById('result').innerHTML = '<div class="warning">⚠️ Nenhum documento encontrado</div>';
+                return;
+            }
+            const hits = data.result.hits.hits;
+            const total = data.result.hits.total?.value || 0;
+            let html = `<div class="success">✅ Encontrados ${total.toLocaleString()} documentos. Exibindo ${hits.length} resultados.</div>`;
+            hits.forEach((hit, index) => {
+                const source = hit._source || {};
+                const highlight = hit.highlight || {};
+                const docId = source.id || hit._id || `doc_${index}`;
+                html += `<div class="campo-lista" style="margin-top: 30px;">`;
+                html += `<h3 style="display: flex; justify-content: space-between; align-items: center;">
+                            <span>📄 Documento ${index + 1}: ${source.titulo || source.processo_codigo_completo || docId}</span>
+                            <span class="badge">ID: ${docId}</span>
+                        </h3>`;
+                // Abas internas para cada documento
+                html += `<div style="display: flex; gap: 5px; margin: 15px 0; flex-wrap: wrap;">`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('geral-${index}')">📋 Geral</button>`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('ementa-${index}')">📝 Ementa</button>`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('acordao-${index}')">⚖️ Acórdão</button>`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('legislacao-${index}')">📚 Legislação</button>`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('highlight-${index}')">🔆 Highlight</button>`;
+                html += `<button class="badge" style="cursor: pointer;" onclick="showDocTab('completo-${index}')">📋 Todos Campos</button>`;
+                html += `</div>`;
+                // Aba: Geral
+                html += `<div id="doc-tab-geral-${index}" class="doc-tab" style="display: block;">`;
+                html += renderCampo('Processo', source.processo_codigo_completo);
+                html += renderCampo('Classe', source.processo_classe_processual_unificada_extenso);
+                html += renderCampo('Órgão Julgador', source.orgao_julgador);
+                html += renderCampo('Relator', source.relator_processo_nome);
+                html += renderCampo('Relator Acórdão', source.relator_acordao_nome);
+                html += renderCampo('Ministros', source.ministro_facet);
+                html += renderCampo('Data Julgamento', source.julgamento_data);
+                html += renderCampo('Data Publicação', source.publicacao_data);
+                html += renderCampo('Procedência', source.procedencia_geografica_completo);
+                html += renderCampo('UF', source.procedencia_geografica_uf_sigla);
+                html += `</div>`;
+                // Aba: Ementa
+                html += `<div id="doc-tab-ementa-${index}" class="doc-tab" style="display: none;">`;
+                html += renderCampo('Ementa', source.ementa_texto, 'texto');
+                html += renderCampo('Tese', source.documental_tese_texto, 'texto');
+                html += renderCampo('Tema', source.documental_tese_tema_texto);
+                html += `</div>`;
+                // Aba: Acórdão
+                html += `<div id="doc-tab-acordao-${index}" class="doc-tab" style="display: none;">`;
+                html += renderCampo('Acórdão/Ata', source.acordao_ata, 'texto');
+                html += renderCampo('Decisão', source.decisao_texto, 'texto');
+                html += renderCampo('Súmula', source.sumula_texto, 'texto');
+                html += renderCampo('Indexação', source.documental_indexacao_texto, 'texto');
+                html += renderCampo('Observações', source.documental_observacao_texto, 'texto');
+                html += `</div>`;
+                // Aba: Legislação
+                html += `<div id="doc-tab-legislacao-${index}" class="doc-tab" style="display: none;">`;
+                html += renderCampo('Legislação Citada', source.documental_legislacao_citada_texto, 'texto');
+                html += renderCampo('Jurisprudência Citada', source.documental_jurisprudencia_citada_texto, 'texto');
+                html += renderCampo('Doutrina', source.documental_doutrina_texto, 'texto');
+                html += renderCampo('Precedentes', source.processo_precedente_texto, 'texto');
+                html += `</div>`;
+                // Aba: Highlight
+                html += `<div id="doc-tab-highlight-${index}" class="doc-tab" style="display: none;">`;
+                if (Object.keys(highlight).length > 0) {
+                    for (const [campo, valores] of Object.entries(highlight)) {
+                        if (valores && valores.length > 0) {
+                            html += `<div class="campo-card">`;
+                            html += `<div class="campo-nome">${campo}</div>`;
+                            valores.forEach(valor => {
+                                html += `<div class="highlight-box" style="margin-top: 5px;">${valor.replace(/<em>/g, '<span class="highlight">').replace(/<\\/em>/g, '</span>')}</div>`;
+                            });
+                            html += `</div>`;
+                        }
+                    }
+                } else {
+                    html += `<div class="campo-vazio">Nenhum termo destacado</div>`;
+                }
+                html += `</div>`;
+                // Aba: Todos Campos
+                html += `<div id="doc-tab-completo-${index}" class="doc-tab" style="display: none;">`;
+                html += `<pre>${JSON.stringify(source, null, 2).replace(/<em>/g, '<span class="highlight">').replace(/<\\/em>/g, '</span>')}</pre>`;
+                html += `</div>`;
+                // URLs importantes
+                if (source.inteiro_teor_url) {
+                    html += `<div style="margin-top: 15px; padding: 10px; background: #e8f0fe; border-radius: 8px;">`;
+                    html += `<strong>🔗 Links:</strong><br>`;
+                    html += `<a href="${source.inteiro_teor_url}" target="_blank" class="url-link">📄 Inteiro Teor</a><br>`;
+                    if (source.acompanhamento_processual_url) {
+                        html += `<a href="${source.acompanhamento_processual_url}" target="_blank" class="url-link">📊 Acompanhamento Processual</a><br>`;
+                    }
+                    if (source.dje_url) {
+                        html += `<a href="${source.dje_url}" target="_blank" class="url-link">📰 DJE</a>`;
+                    }
+                    html += `</div>`;
+                }
+                html += `</div>`; // Fecha campo-lista
+            });
+            document.getElementById('result').innerHTML = html;
+        }
+        function showDocTab(tabId) {
+            const docIndex = tabId.split('-')[2];
+            document.querySelectorAll(`[id^="doc-tab-"]`).forEach(el => {
+                if (el.id.includes(`-${docIndex}`)) {
+                    el.style.display = 'none';
+                }
+            });
+            const selectedTab = document.getElementById(`doc-tab-${tabId}`);
+            if (selectedTab) {
+                selectedTab.style.display = 'block';
+            }
+        }
+        async function runSearch() {
+            const btn = document.getElementById('testBtn');
+            const loading = document.getElementById('loading');
+            const resultDiv = document.getElementById('result');
+            const pageSize = document.getElementById('pageSize').value;
+            const sortOrder = document.getElementById('sortOrder').value;
+            const base = document.getElementById('base').value;
+            btn.disabled = true;
+            loading.style.display = 'inline-block';
+            resultDiv.innerHTML = '<div class="info-box">⏳ Executando busca no STF...</div>';
             try {
+                const response = await fetch('/api/search-advanced', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        pageSize: parseInt(pageSize),
+                        sortOrder,
+                        base: base || undefined
+                    })
+                });
                 const data = await response.json();
+                requestsCount++;
+                document.getElementById('requestsCount').textContent = requestsCount;
+                if (data.success) {
+                    successCount++;
+                    document.getElementById('successCount').textContent = successCount;
+                    if (data.data && data.data.result && data.data.result.hits) {
+                        docsCount = data.data.result.hits.hits.length;
+                        document.getElementById('docsCount').textContent = docsCount;
+                        if (data.data.result.hits.total && data.data.result.hits.total.value) {
+                            document.getElementById('totalDocs').textContent = data.data.result.hits.total.value.toLocaleString();
+                        }
+                    }
+                    lastResult = data.data;
+                    lastToken = data.token;
+                    if (lastToken) {
+                        document.getElementById('tokenValue').textContent = lastToken;
+                        document.getElementById('tokenDisplay').style.display = 'block';
+                        document.getElementById('downloadBtn').disabled = false;
+                    }
+                    displayResult(data.data);
+                } else {
+                    failCount++;
+                    document.getElementById('failCount').textContent = failCount;
+                    let errorHtml = '<div class="error">❌ Falha na busca</div>';
+                    if (data.attempts) {
+                        data.attempts.forEach(attempt => {
+                            errorHtml += `<div class="warning"><strong>${attempt.method}:</strong> ${attempt.error || 'Erro'}</div>`;
+                        });
+                    }
+                    errorHtml += '<pre>' + JSON.stringify(data, null, 2) + '</pre>';
+                    resultDiv.innerHTML = errorHtml;
+                }
+            } catch (error) {
+                failCount++;
+                document.getElementById('failCount').textContent = failCount;
+                resultDiv.innerHTML = '<div class="error">❌ Erro: ' + error.message + '</div>';
+            } finally {
+                btn.disabled = false;
+                loading.style.display = 'none';
             }
         }
+        async function getDocumentById() {
+            const docId = document.getElementById('docId').value.trim();
+            if (!docId) {
+                alert('Digite um ID');
+                return;
+            }
+            const btn = document.getElementById('getByIdBtn');
+            const loading = document.getElementById('loading');
+            const resultDiv = document.getElementById('result');
+            btn.disabled = true;
+            loading.style.display = 'inline-block';
+            resultDiv.innerHTML = '<div class="info-box">⏳ Buscando documento...</div>';
             try {
+                const response = await fetch(`/api/document/${docId}`);
                 const data = await response.json();
+                requestsCount++;
+                document.getElementById('requestsCount').textContent = requestsCount;
+                if (data.success && data.document) {
+                    successCount++;
+                    document.getElementById('successCount').textContent = successCount;
+                    docsCount++;
+                    document.getElementById('docsCount').textContent = docsCount;
+                    lastResult = { result: { hits: { hits: [data.document] } } };
+                    displayResult(lastResult);
+                } else {
+                    failCount++;
+                    document.getElementById('failCount').textContent = failCount;
+                    resultDiv.innerHTML = '<div class="error">❌ Documento não encontrado</div>';
+                }
+            } catch (error) {
+                failCount++;
+                document.getElementById('failCount').textContent = failCount;
+                resultDiv.innerHTML = '<div class="error">❌ Erro: ' + error.message + '</div>';
+            } finally {
+                btn.disabled = false;
+                loading.style.display = 'none';
             }
         }
+        function downloadJSON() {
+            if (!lastResult) {
+                alert('Nenhum resultado para download');
+                return;
+            }
+            const dataStr = JSON.stringify(lastResult, null, 2);
+            const blob = new Blob([dataStr], { type: 'application/json' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = `stf_jurisprudencia_${new Date().toISOString().slice(0,10)}.json`;
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            URL.revokeObjectURL(url);
+        }
+        function copyToken() {
+            if (!lastToken) {
+                alert('Nenhum token disponível. Execute uma busca primeiro.');
+                return;
+            }
+            navigator.clipboard.writeText(lastToken).then(() => {
+                alert('✅ Token copiado para área de transferência!');
+            }).catch(() => {
+                alert('❌ Erro ao copiar token');
+            });
+        }
+        window.onload = async () => {
+            try {
+                const response = await fetch('/api/health');
+                const data = await response.json();
+                if (data.total_docs) {
+                    document.getElementById('totalDocs').textContent = data.total_docs.toLocaleString();
+                }
+                document.getElementById('totalCampos').textContent = "102";
+            } catch (e) {
+                document.getElementById('totalDocs').textContent = 'indisponível';
+            }
+        };
     </script>
 </body>
 </html>
 """
 # ============================================
+# Funções auxiliares
 # ============================================
 def get_fresh_token():
     global token_cache
     if token_cache["token"] and time.time() < token_cache["expires_at"]:
         logger.info("Usando token em cache")
         return token_cache["token"]
     logger.info("Obtendo novo token via Playwright")
     try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
+            context = browser.new_context(
+                viewport={'width': 1920, 'height': 1080},
+                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            )
+            page = context.new_page()
+            page.goto("https://jurisprudencia.stf.jus.br/pages/search", wait_until='domcontentloaded', timeout=30000)
+            page.wait_for_timeout(3000)
+            cookies = context.cookies()
+            token = None
+            for cookie in cookies:
+                if cookie.get('name') == 'aws-waf-token':
+                    token = cookie.get('value')
+                    break
+            browser.close()
             if token:
+                token_cache["token"] = token
+                token_cache["expires_at"] = time.time() + 3300
+                logger.info(f"Token obtido: {token[:30]}...")
+                return token
+            else:
+                logger.warning("Token não encontrado nos cookies")
+                return None
     except Exception as e:
         logger.error(f"Erro ao obter token: {str(e)}")
         return None
 def search_with_token(token, custom_payload=None):
     if not token:
         return {"success": False, "error": "Token não fornecido"}
     payload = custom_payload or PAYLOAD_COMPLETO
     headers = HEADERS.copy()
     headers['Cookie'] = f'aws-waf-token={token}'
     try:
+        response = requests.post(URL_API, headers=headers, json=payload, verify=False, timeout=30)
         if response.status_code == 200:
+            return {"success": True, "data": response.json()}
+        elif response.status_code == 403:
+            token_cache["token"] = None
+            return {"success": False, "error": "Token expirado", "status": 403}
         else:
+            return {"success": False, "error": f"HTTP {response.status_code}", "text": response.text[:500]}
     except Exception as e:
+        return {"success": False, "error": str(e)}
+def get_document_by_id(token, doc_id):
+    payload = PAYLOAD_POR_ID.copy()
+    payload["query"]["ids"]["values"] = [doc_id]
+    return search_with_token(token, payload)
+def test_with_playwright_full(payload):
+    logger.info("Tentando acesso com Playwright...")
     try:
         with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
+            context = browser.new_context(
+                viewport={'width': 1920, 'height': 1080},
+                user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            )
+            page = context.new_page()
+            page.goto("https://jurisprudencia.stf.jus.br/pages/search", wait_until='domcontentloaded', timeout=30000)
+            page.wait_for_timeout(3000)
+            cookies = context.cookies()
+            token = None
+            for cookie in cookies:
+                if cookie.get('name') == 'aws-waf-token':
+                    token = cookie.get('value')
+                    break
+            api_result = page.evaluate("""
+                async (payload) => {
+                    try {
+                        const response = await fetch('https://jurisprudencia.stf.jus.br/api/search/search', {
+                            method: 'POST',
+                            headers: {'Content-Type': 'application/json', 'Accept': 'application/json'},
+                            body: JSON.stringify(payload)
+                        });
+                        if (response.ok) {
+                            return { success: true, data: await response.json() };
+                        } else {
+                            return { success: false, status: response.status };
+                        }
+                    } catch (error) {
+                        return { success: false, error: error.toString() };
+                    }
+                }
+            """, payload)
             browser.close()
+            if api_result.get('success'):
+                if token:
+                    token_cache["token"] = token
+                    token_cache["expires_at"] = time.time() + 3300
+                return {"success": True, "data": api_result.get('data'), "token": token}
+            else:
+                return {"success": False, "error": api_result.get('error', 'Falha desconhecida'), "token": token}
     except Exception as e:
+        logger.error(f"Erro no Playwright: {str(e)}")
+        return {"success": False, "error": str(e)}
 # ============================================
+# Rotas
 # ============================================
 @app.route('/')
 def index():
     try:
         return render_template_string(HTML_TEMPLATE)
     except Exception as e:
+        return f"Erro no template: {str(e)}<br><pre>{traceback.format_exc()}</pre>", 500
+@app.route('/api/search-advanced', methods=['POST'])
+def search_advanced():
+    data = request.json or {}
+    page_size = data.get('pageSize', 100)
+    sort_order = data.get('sortOrder', 'desc')
+    base = data.get('base')
+    payload = PAYLOAD_COMPLETO.copy()
+    payload["size"] = min(page_size, 250)
+    payload["sort"] = [{"julgamento_data": {"order": sort_order}}]
+    if base:
+        if "post_filter" not in payload:
+            payload["post_filter"] = {"bool": {"must": []}}
+        payload["post_filter"]["bool"]["must"] = [{"term": {"base": base}}]
     token = get_fresh_token()
+    if not token:
+        res = test_with_playwright_full(payload)
+        if res.get('success'):
+            return jsonify({"success": True, "token": res.get('token'), "data": res['data'], "timestamp": time.time()})
+        else:
+            return jsonify({"success": False, "error": res.get('error')}), 500
+    result = search_with_token(token, payload)
+    if result.get("success"):
+        return jsonify({"success": True, "token": token, "data": result["data"], "timestamp": time.time()})
+    else:
+        if result.get("status") == 403:
+            token_cache["token"] = None
+            token = get_fresh_token()
+            if token:
+                result = search_with_token(token, payload)
+                if result.get("success"):
+                    return jsonify({"success": True, "token": token, "data": result["data"], "timestamp": time.time()})
+        # fallback
+        res = test_with_playwright_full(payload)
+        if res.get('success'):
+            return jsonify({"success": True, "token": res.get('token'), "data": res['data'], "timestamp": time.time()})
+        else:
+            return jsonify({"success": False, "error": result.get('error')}), 500
+@app.route('/api/document/<doc_id>', methods=['GET'])
+def get_document(doc_id):
+    token = get_fresh_token()
+    if not token:
+        return jsonify({"error": "Não foi possível obter token"}), 500
+    result = get_document_by_id(token, doc_id)
+    if result.get("success") and result["data"].get("hits", {}).get("hits"):
+        doc = result["data"]["hits"]["hits"][0] if result["data"]["hits"]["hits"] else None
+        return jsonify({"success": True, "document": doc})
+    else:
+        return jsonify({"success": False, "error": result.get("error", "Documento não encontrado")}), 404
 @app.route('/api/test-bypass', methods=['POST'])
 def test_bypass():
     token = get_fresh_token()
     if token:
+        res = search_with_token(token)
+        if res.get('success'):
+            return jsonify({"success": True, "method": "token", "token": token, "data": res['data']})
+    res = test_with_playwright_full(PAYLOAD_COMPLETO)
+    if res.get('success'):
+        return jsonify({"success": True, "method": "playwright", "token": res.get('token'), "data": res['data']})
+    return jsonify({"success": False, "error": res.get('error', 'Falha')}), 500
+@app.route('/api/health', methods=['GET'])
+def health():
+    playwright_status = False
     try:
         with sync_playwright() as p:
+            p.chromium.launch(headless=True).close()
+            playwright_status = True
+    except:
+        pass
+    total_docs = None
+    token = get_fresh_token()
+    if token:
+        try:
+            res = search_with_token(token, {"size": 0, "track_total_hits": True})
+            if res.get("success") and res["data"].get("hits", {}).get("total"):
+                total_docs = res["data"]["hits"]["total"]["value"]
+        except:
+            pass
     return jsonify({
+        "status": "healthy",
+        "timestamp": time.time(),
+        "playwright_ready": playwright_status,
+        "token_cached": bool(token_cache["token"]),
+        "token_expires_in": max(0, token_cache["expires_at"] - time.time()) if token_cache["expires_at"] else 0,
+        "total_docs": total_docs,
+        "python_version": sys.version
+    })
+@app.route('/api/token', methods=['GET'])
+def get_token():
+    token = get_fresh_token()
+    if token:
+        return jsonify({"success": True, "token": token, "expires_in": max(0, token_cache["expires_at"] - time.time())})
+    else:
+        return jsonify({"success": False, "error": "Não foi possível obter token"}), 500
+@app.route('/api/clear-cache', methods=['POST'])
+def clear_cache():
+    global token_cache
+    token_cache = {"token": None, "expires_at": 0}
+    return jsonify({"success": True, "message": "Cache limpo"})
 if __name__ == '__main__':
     try:
+        import certifi
+        os.environ['SSL_CERT_FILE'] = certifi.where()
+        os.environ['REQUESTS_CA_BUNDLE'] = certifi.where()
+    except:
+        pass
+    logger.info("="*50)
+    logger.info("🚀 Iniciando aplicação STF Jurisprudência")
+    logger.info(f"📋 Campos _source: {len(PAYLOAD_COMPLETO['_source'])}")
+    logger.info(f"🔆 Campos highlight: {len(PAYLOAD_COMPLETO['highlight']['fields'])}")
+    logger.info("="*50)
     try:
+        with sync_playwright() as p:
+            p.chromium.launch(headless=True).close()
+        logger.info("✅ Playwright pronto para uso")
+    except Exception as e:
+        logger.warning(f"⚠️ Playwright pode não estar configurado: {e}")
     port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port, debug=False)