Update app.py

app.py

@@ -1,726 +1,977 @@
+
 import os
 import sys
 import json
 import time
-import copy
 import logging
 import requests
 import urllib3
-from flask import Flask, request, jsonify
+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__)
 
-# ============================================
-# CONSTANTES
-# ============================================
-URL_API = "https://jurisprudencia.stf.jus.br/api/search/search"
-HEADERS_BASE = {
-    "Accept": "application/json, text/plain, */*",
-    "Content-Type": "application/json",
-    "User-Agent": (
-        "Mozilla/5.0 (Linux; Android 10; Pixel 4a Build/QD4A.200805.003; wv) "
-        "AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/129.0.6668.71 "
-        "Mobile Safari/537.36"
-    ),
-    "Referer": "https://jurisprudencia.stf.jus.br/pages/search",
-    "Origin": "https://jurisprudencia.stf.jus.br",
-}
-token_cache = {"token": None, "expires_at": 0}
+app = Flask(__name__)
 
 # ============================================
-# CAMPOS REUTILIZÁVEIS
+# PAYLOAD COMPLETO (com todos os campos e highlight)
 # ============================================
-_FIELDS_FULL = [
-    "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",
-]
-
-_FIELDS_SHOULD = [
-    "acordao_ata.plural^3",
-    "documental_doutrina_texto.plural",
-    "documental_indexacao_texto.plural",
-    "documental_jurisprudencia_citada_texto.plural",
-    "documental_observacao_texto.plural",
-    "documental_tese_tema_texto.plural^3",
-    "documental_tese_texto.plural^3",
-    "ementa_texto.plural^3",
-    "titulo.plural^6",
-    "decisao_texto.plural^2",
-    "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",
-]
-
-_SOURCE_FIELDS = [
-    "base", "_id", "id", "dg_unique", "titulo", "ministro_facet",
-    "procedencia_geografica_completo", "procedencia_geografica_uf_sigla",
-    "processo_codigo_completo", "processo_classe_processual_unificada_extenso",
-    "processo_classe_processual_unificada_classe_sigla", "processo_numero",
-    "julgamento_data", "publicacao_data",
-    "relator_processo_nome", "relator_acordao_nome", "relator_decisao_nome",
-    "acordao_ata", "decisao_texto", "ementa_texto",
-    "partes_lista_texto", "orgao_julgador",
-    "inteiro_teor_url", "acompanhamento_processual_url", "dje_url",
-    "documental_tese_texto", "documental_tese_tema_texto",
-    "documental_indexacao_texto", "documental_observacao_texto",
-    "documental_legislacao_citada_texto", "documental_publicacao_lista_texto",
-    "documental_acordao_mesmo_sentido_lista_texto",
-    "documental_decisao_mesmo_sentido_lista_texto",
-    "documental_jurisprudencia_citada_texto",
-    "is_repercussao_geral", "is_repercussao_geral_merito",
-    "is_repercussao_geral_admissibilidade", "is_questao_ordem",
-    "ramo_direito", "sumula_texto", "sumula_numero", "situacao_sumula",
-    "is_vinculante", "is_colac", "colac_numero", "colac_pagina",
-    "julgamento_is_sessao_virtual", "tipo_julgamento",
-    "volume_informativo", "titulo_noticia", "resumo_noticia",
-    "conteudo_noticia", "materia_noticia", "ramo_noticia",
-    "pesquisa_url", "informativo_url", "audio_url", "video_url",
-    "dg_atualizado_em",
-]
-
-
-def _build_query(term: str) -> dict:
-    """Monta o bloco function_score com os 3 boosters do portal STF."""
-    qs_base = {
-        "default_operator": "AND",
-        "fields": _FIELDS_FULL,
-        "query": term,
-        "type": "cross_fields",
-        "fuzziness": "AUTO:4,7",
-        "analyzer": "legal_search_analyzer",
-        "quote_analyzer": "legal_index_analyzer",
-    }
-    qs_should_1 = {
-        "default_operator": "AND",
-        "fields": _FIELDS_SHOULD,
-        "query": term,
-        "tie_breaker": 1,
-        "fuzziness": "AUTO:4,7",
-        "analyzer": "legal_search_analyzer",
-        "quote_analyzer": "legal_index_analyzer",
-    }
-    qs_should_2 = {
-        "default_operator": "and",
-        "type": "phrase",
-        "tie_breaker": 1,
-        "phrase_slop": 20,
-        "fields": [
-            "acordao_ata.plural^3", "documental_tese_tema_texto.plural^3",
-            "documental_tese_texto.plural^3", "ementa_texto.plural^3",
-            "decisao_texto.plural^2", "titulo_noticia.plural^3",
-            "resumo_noticia.plural^3", "conteudo_noticia.plural^1",
-        ],
-        "query": term,
-        "fuzziness": "AUTO:4,7",
-        "analyzer": "legal_search_analyzer",
-        "quote_analyzer": "legal_index_analyzer",
-    }
-
-    return {
+PAYLOAD_COMPLETO = {
+    "query": {
         "function_score": {
             "functions": [
-                {
-                    "exp": {
-                        "julgamento_data": {
-                            "origin": "now",
-                            "scale": "47450d",
-                            "offset": "1095d",
-                            "decay": 0.1,
-                        }
-                    }
-                },
-                {
-                    "filter": {"term": {"orgao_julgador.keyword": "Tribunal Pleno"}},
-                    "weight": 1.15,
-                },
-                {
-                    "filter": {"term": {"is_repercussao_geral": True}},
-                    "weight": 1.1,
-                },
+                {"exp": {"julgamento_data": {"origin": "now", "scale": "47450d", "offset": "1095d", "decay": 0.1}}}
             ],
             "query": {
                 "bool": {
-                    "filter": [{"query_string": qs_base}],
-                    "must": [],
-                    "should": [
-                        {"query_string": qs_should_1},
-                        {"query_string": qs_should_2},
-                    ],
+                    "filter": [
+                        {"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",
+                            "fuzziness": "AUTO:4,7"
+                        }}
+                    ]
                 }
-            },
+            }
         }
-    }
-
-
-def _build_aggs() -> dict:
-    """Aggregations para facets (contagens por base, órgão, ministro, etc.)."""
-    return {
+    },
+    "_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"}},
-                }
-            }
-        },
-        "is_repercussao_geral_agg": {
-            "filters": {
-                "filters": {
-                    "true": {"bool": {"must": [
-                        {"match": {"is_repercussao_geral": True}},
-                        {"term": {"base": "acordaos"}},
-                    ]}},
-                    "false": {"bool": {"must": [
-                        {"match": {"is_repercussao_geral": False}},
-                        {"term": {"base": "acordaos"}},
-                    ]}},
+                    "informativos": {"match": {"base": "novo_informativo"}}
                 }
             }
         },
         "orgao_julgador_agg": {
             "aggs": {
                 "orgao_julgador_agg": {
-                    "terms": {
-                        "field": "orgao_julgador.keyword",
-                        "size": 200,
-                        "execution_hint": "map",
-                    }
+                    "terms": {"field": "orgao_julgador.keyword", "size": 10}
                 }
-            },
-            "filter": {"bool": {"must": [{"term": {"base": "acordaos"}}]}},
+            }
         },
         "ministro_facet_agg": {
             "aggs": {
                 "ministro_facet_agg": {
-                    "terms": {
-                        "field": "ministro_facet.keyword",
-                        "size": 200,
-                        "execution_hint": "map",
-                    }
+                    "terms": {"field": "ministro_facet.keyword", "size": 10}
                 }
-            },
-            "filter": {"bool": {"must": [{"term": {"base": "acordaos"}}]}},
+            }
         },
-    }
-
-
-def _build_highlight(term: str) -> dict:
-    """Bloco de highlight com highlight_query espelhando a query principal."""
-    return {
-        "highlight_query": _build_query(term),
-        "number_of_fragments": 64,
-        "fragment_size": 300,
-        "order": "score",
-        "pre_tags": ["<em>"],
-        "post_tags": ["</em>"],
+        "procedencia_geografica_uf_sigla_agg": {
+            "aggs": {
+                "procedencia_geografica_uf_sigla_agg": {
+                    "terms": {"field": "procedencia_geografica_uf_sigla", "size": 10}
+                }
+            }
+        }
+    },
+    "highlight": {
         "fields": {
-            "ementa_texto": {
-                "fragment_size": 24000,
-                "matched_fields": ["ementa_texto.plural"],
-                "type": "fvh",
-            },
-            "acordao_ata": {
-                "fragment_size": 600,
-                "matched_fields": ["acordao_ata.plural"],
-                "type": "fvh",
-            },
-            "decisao_texto": {
-                "fragment_size": 1200,
-                "matched_fields": ["decisao_texto.plural"],
-                "type": "fvh",
-            },
-            "documental_tese_texto": {
-                "fragment_size": 2000,
-                "matched_fields": ["documental_tese_texto.plural"],
-                "type": "fvh",
-            },
-            "documental_tese_tema_texto": {
-                "fragment_size": 2000,
-                "matched_fields": ["documental_tese_tema_texto.plural"],
-                "type": "fvh",
-            },
-            "resumo_noticia": {
-                "fragment_size": 5000,
-                "matched_fields": ["resumo_noticia.plural"],
-                "type": "fvh",
-            },
+            "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"}
         },
-    }
-
-
-def build_payload(
-    term: str,
-    size: int = 20,
-    from_: int = 0,
-    sort: str = "_score",           # "_score" | "julgamento_data" | "publicacao_data"
-    sort_order: str = "desc",
-    base: str = "acordaos",         # acordaos | sumulas | decisoes | novo_informativo | None
-    include_aggs: bool = True,
-    include_highlight: bool = True,
-) -> dict:
-    """
-    Monta o payload completo para a API do STF.
-    """
-    sort_clause = (
-        [{"_score": sort_order}]
-        if sort == "_score"
-        else [{sort: {"order": sort_order}}]
-    )
+        "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 = {
-        "query": _build_query(term),
-        "_source": _SOURCE_FIELDS,
-        "size": size,
-        "from": from_,
-        "sort": sort_clause,
-        "track_total_hits": True,
-    }
+# Payload sem highlight e sem aggs (apenas _source e query)
+PAYLOAD_SEM_HIGHLIGHT = {
+    "query": PAYLOAD_COMPLETO["query"],
+    "_source": PAYLOAD_COMPLETO["_source"],
+    "size": 100,
+    "from": 0,
+    "sort": [{"julgamento_data": {"order": "desc"}}],
+    "track_total_hits": True
+}
 
-    if base:
-        payload["post_filter"] = {
-            "bool": {
-                "must": [{"term": {"base": base}}],
-                "should": [],
-            }
+# Payload mínimo (apenas o essencial, testado anteriormente)
+PAYLOAD_MINIMO = {
+    "query": {
+        "bool": {
+            "filter": [
+                {"term": {"base": "acordaos"}}
+            ]
         }
+    },
+    "_source": ["id", "titulo", "ementa_texto", "processo_numero", "julgamento_data", "relator_processo_nome", "inteiro_teor_url"],
+    "size": 100,
+    "sort": [{"julgamento_data": {"order": "desc"}}],
+    "track_total_hits": True
+}
 
-    if include_aggs:
-        payload["aggs"] = _build_aggs()
+# Payload para busca por ID (versão completa com highlight)
+PAYLOAD_POR_ID_COMPLETO = {
+    "query": {"ids": {"values": []}},
+    "_source": PAYLOAD_COMPLETO["_source"],
+    "highlight": PAYLOAD_COMPLETO["highlight"],
+    "size": 1
+}
 
-    if include_highlight:
-        payload["highlight"] = _build_highlight(term)
+# Payload para busca por ID (versão sem highlight)
+PAYLOAD_POR_ID_SIMPLES = {
+    "query": {"ids": {"values": []}},
+    "_source": PAYLOAD_COMPLETO["_source"],
+    "size": 1
+}
 
-    return payload
+# Constantes da API
+URL_API = "https://jurisprudencia.stf.jus.br/api/search/search"
+URL_API_GET = "https://jurisprudencia.stf.jus.br/api/search/get"  # endpoint para obter documento por ID
+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}
 
 # ============================================
-# TOKEN / WAF
+# HTML TEMPLATE COMPLETO (mantido para interface web)
 # ============================================
-def get_fresh_token() -> str | None:
+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>
+        /* (estilos completos, mantidos da versão anterior) */
+        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; }
+        .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; }
+        .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; }
+        .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; }
+        .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; }
+        .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.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; }
+        .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; }
+    </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>
+            • 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>🔍 Filtros de Busca</h3>
+            <div class="filter-group">
+                <div class="filter-item"><label>Quantidade</label><select id="pageSize"><option value="5">5</option><option value="10">10</option><option value="25">25</option><option value="50">50</option><option value="100" selected>100</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>🔍 Buscar Documentos</button>
+            <button id="getByIdBtn" class="secondary" onclick="getDocumentById()">📄 Buscar por ID</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, lastToken = null, requestsCount = 0, successCount = 0, failCount = 0, docsCount = 0;
+        function renderCampo(nome, valor, tipo='normal') {
+            if (!valor && valor!==0) return `<div class="campo-card"><div class="campo-nome">${nome}</div><div class="campo-vazio">(vazio)</div></div>`;
+            if (tipo==='url') 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==='texto' && 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>`;
+            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 displayResult(data) {
+            if (!data?.result?.hits?.hits) return document.getElementById('result').innerHTML = '<div class="warning">⚠️ Nenhum documento encontrado</div>';
+            const hits = data.result.hits.hits, total = data.result.hits.total?.value || 0;
+            let html = `<div class="success">✅ Encontrados ${total.toLocaleString()} documentos. Exibindo ${hits.length} resultados.</div>`;
+            hits.forEach((hit, idx) => {
+                const src = hit._source || {}, hl = hit.highlight || {}, docId = src.id || hit._id || `doc_${idx}`;
+                html += `<div class="campo-lista"><h3 style="display:flex;justify-content:space-between;"><span>📄 ${idx+1}: ${src.titulo || src.processo_codigo_completo || docId}</span><span class="badge">ID: ${docId}</span></h3>`;
+                html += `<div style="margin-bottom:10px;"><button class="secondary" onclick="fetchFullDocument('${docId}')">📄 Obter texto completo</button></div>`;
+                html += `<div style="display:flex;gap:5px;margin:15px 0;flex-wrap:wrap;">`;
+                ['geral','ementa','acordao','legislacao','highlight','completo'].forEach(t => html += `<button class="badge" style="cursor:pointer;" onclick="showDocTab('${t}-${idx}')">${t}</button>`);
+                html += `</div>`;
+                html += `<div id="doc-tab-geral-${idx}" class="doc-tab" style="display:block;">`;
+                html += renderCampo('Processo', src.processo_codigo_completo);
+                html += renderCampo('Classe', src.processo_classe_processual_unificada_extenso);
+                html += renderCampo('Órgão Julgador', src.orgao_julgador);
+                html += renderCampo('Relator', src.relator_processo_nome);
+                html += renderCampo('Relator Acórdão', src.relator_acordao_nome);
+                html += renderCampo('Ministros', src.ministro_facet);
+                html += renderCampo('Data Julgamento', src.julgamento_data);
+                html += renderCampo('Data Publicação', src.publicacao_data);
+                html += renderCampo('Procedência', src.procedencia_geografica_completo);
+                html += `</div>`;
+                html += `<div id="doc-tab-ementa-${idx}" class="doc-tab" style="display:none;">`;
+                html += renderCampo('Ementa', src.ementa_texto, 'texto');
+                html += renderCampo('Tese', src.documental_tese_texto, 'texto');
+                html += renderCampo('Tema', src.documental_tese_tema_texto);
+                html += `</div>`;
+                html += `<div id="doc-tab-acordao-${idx}" class="doc-tab" style="display:none;">`;
+                html += renderCampo('Acórdão/Ata', src.acordao_ata, 'texto');
+                html += renderCampo('Decisão', src.decisao_texto, 'texto');
+                html += renderCampo('Súmula', src.sumula_texto, 'texto');
+                html += renderCampo('Indexação', src.documental_indexacao_texto, 'texto');
+                html += renderCampo('Observações', src.documental_observacao_texto, 'texto');
+                html += `</div>`;
+                html += `<div id="doc-tab-legislacao-${idx}" class="doc-tab" style="display:none;">`;
+                html += renderCampo('Legislação Citada', src.documental_legislacao_citada_texto, 'texto');
+                html += renderCampo('Jurisprudência Citada', src.documental_jurisprudencia_citada_texto, 'texto');
+                html += renderCampo('Doutrina', src.documental_doutrina_texto, 'texto');
+                html += renderCampo('Precedentes', src.processo_precedente_texto, 'texto');
+                html += `</div>`;
+                html += `<div id="doc-tab-highlight-${idx}" class="doc-tab" style="display:none;">`;
+                if (Object.keys(hl).length) {
+                    for (const [campo, valores] of Object.entries(hl)) {
+                        html += `<div class="campo-card"><div class="campo-nome">${campo}</div>`;
+                        valores.forEach(valor => html += `<div class="highlight-box">${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>`;
+                html += `<div id="doc-tab-completo-${idx}" class="doc-tab" style="display:none;">`;
+                html += `<pre>${JSON.stringify(src, null, 2).replace(/<em>/g,'<span class="highlight">').replace(/<\\/em>/g,'</span>')}</pre>`;
+                html += `</div>`;
+                if (src.inteiro_teor_url) html += `<div style="margin-top:15px;padding:10px;background:#e8f0fe;border-radius:8px;"><strong>🔗 Links:</strong><br><a href="${src.inteiro_teor_url}" target="_blank" class="url-link">📄 Inteiro Teor</a></div>`;
+                html += `</div>`;
+            });
+            document.getElementById('result').innerHTML = html;
+        }
+        function showDocTab(tabId) {
+            const idx = tabId.split('-')[2];
+            document.querySelectorAll(`[id^="doc-tab-"]`).forEach(el => { if (el.id.includes(`-${idx}`)) el.style.display = 'none'; });
+            const sel = document.getElementById(`doc-tab-${tabId}`);
+            if (sel) sel.style.display = 'block';
+        }
+        async function runSearch() {
+            const btn = document.getElementById('testBtn'), loading = document.getElementById('loading'), resultDiv = document.getElementById('result');
+            btn.disabled = true; loading.style.display = 'inline-block'; resultDiv.innerHTML = '<div class="info-box">⏳ Executando busca...</div>';
+            try {
+                const resp = await fetch('/api/search-advanced', {
+                    method:'POST', headers:{'Content-Type':'application/json'},
+                    body:JSON.stringify({ pageSize: parseInt(document.getElementById('pageSize').value), sortOrder: document.getElementById('sortOrder').value, base: document.getElementById('base').value || undefined })
+                });
+                const data = await resp.json();
+                requestsCount++; document.getElementById('requestsCount').textContent = requestsCount;
+                if (data.success) {
+                    successCount++; document.getElementById('successCount').textContent = successCount;
+                    if (data.data?.result?.hits) {
+                        docsCount = data.data.result.hits.hits.length;
+                        document.getElementById('docsCount').textContent = docsCount;
+                        if (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;
+                    resultDiv.innerHTML = '<div class="error">❌ Falha</div><pre>'+JSON.stringify(data,null,2)+'</pre>';
+                }
+            } catch(e) {
+                failCount++; document.getElementById('failCount').textContent = failCount;
+                resultDiv.innerHTML = '<div class="error">❌ Erro: '+e.message+'</div>';
+            } finally {
+                btn.disabled = false; loading.style.display = 'none';
+            }
+        }
+        async function getDocumentById() {
+            const docId = document.getElementById('docId').value.trim();
+            if (!docId) return alert('Digite um ID');
+            const btn = document.getElementById('getByIdBtn'), loading = document.getElementById('loading'), resultDiv = document.getElementById('result');
+            btn.disabled = true; loading.style.display = 'inline-block'; resultDiv.innerHTML = '<div class="info-box">⏳ Buscando...</div>';
+            try {
+                const resp = await fetch(`/api/document/${docId}`);
+                const data = await resp.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(e) {
+                failCount++; document.getElementById('failCount').textContent = failCount;
+                resultDiv.innerHTML = '<div class="error">❌ Erro: '+e.message+'</div>';
+            } finally {
+                btn.disabled = false; loading.style.display = 'none';
+            }
+        }
+        async function fetchFullDocument(docId) {
+            try {
+                const resp = await fetch(`/api/document-raw/${docId}`);
+                const data = await resp.json();
+                if (data.success) {
+                    alert('Documento completo obtido! Verifique o console.');
+                    console.log('Documento completo:', data.document);
+                } else alert('Erro: ' + (data.error || 'desconhecido'));
+            } catch(e) { alert('Erro: ' + e.message); }
+        }
+        function downloadJSON() {
+            if (!lastResult) return alert('Nenhum resultado');
+            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_${new Date().toISOString().slice(0,10)}.json`;
+            document.body.appendChild(a); a.click(); document.body.removeChild(a); URL.revokeObjectURL(url);
+        }
+        function copyToken() { if (lastToken) navigator.clipboard.writeText(lastToken).then(()=>alert('✅ Token copiado!')); else alert('Nenhum token'); }
+        window.onload = async () => {
+            try {
+                const resp = await fetch('/api/health');
+                const data = await resp.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
-    now = time.time()
-    if token_cache["token"] and now < token_cache["expires_at"]:
+    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", "--disable-dev-shm-usage"]
-            )
+            browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
             context = browser.new_context(
-                viewport={"width": 1920, "height": 1080},
-                user_agent=HEADERS_BASE["User-Agent"],
+                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.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()
-
-        token = next(
-            (c["value"] for c in cookies if c["name"] == "aws-waf-token"), None
-        )
-        if token:
-            token_cache["token"] = token
-            token_cache["expires_at"] = now + 3300  # ~55 min
-            logger.info(f"Token obtido: {token[:30]}...")
-            return token
-
-        logger.warning("Cookie aws-waf-token não encontrado")
-        return None
+            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: {e}")
+        logger.error(f"Erro ao obter token: {str(e)}")
         return None
 
-
-def _make_headers(token: str) -> dict:
-    h = HEADERS_BASE.copy()
-    h["Cookie"] = f"aws-waf-token={token}"
-    return h
-
-
-def search_with_token(token: str, payload: dict) -> dict:
+def try_search_with_payloads(token, base_payload, sort_order='desc', base_filter=None):
     """
-    Retorna {"success": bool, "data": {...}} ou {"success": False, "error": ..., "status": int}
-    - 200 → sucesso
-    - 403 → token expirado (limpa cache)
-    - 202 → WAF bloqueou (token aceito como cookie mas requisição não passa)
+    Tenta vários payloads em ordem decrescente de complexidade até obter sucesso.
+    Retorna (success, data, payload_usado)
     """
-    if not token:
-        return {"success": False, "error": "Token ausente"}
+    # Payload 1: completo com aggs e highlight
+    payload1 = base_payload.copy()
+    payload1["sort"] = [{"julgamento_data": {"order": sort_order}}]
+    if base_filter:
+        payload1["post_filter"] = {"bool": {"must": [{"term": {"base": base_filter}}]}}
+    
+    logger.info("Tentando payload completo...")
+    res = search_with_token(token, payload1)
+    if res.get("success"):
+        return True, res["data"], "completo"
+    
+    # Se falhou com 400, tenta sem highlight e sem aggs
+    if res.get("status") == 400:
+        logger.info("Payload completo falhou (400). Tentando payload sem highlight...")
+        payload2 = PAYLOAD_SEM_HIGHLIGHT.copy()
+        payload2["sort"] = [{"julgamento_data": {"order": sort_order}}]
+        if base_filter:
+            payload2["post_filter"] = {"bool": {"must": [{"term": {"base": base_filter}}]}}
+        res2 = search_with_token(token, payload2)
+        if res2.get("success"):
+            return True, res2["data"], "sem_highlight"
+        
+        if res2.get("status") == 400:
+            logger.info("Payload sem highlight falhou. Tentando payload mínimo...")
+            payload3 = PAYLOAD_MINIMO.copy()
+            payload3["sort"] = [{"julgamento_data": {"order": sort_order}}]
+            if base_filter:
+                payload3["post_filter"] = {"bool": {"must": [{"term": {"base": base_filter}}]}}
+            res3 = search_with_token(token, payload3)
+            if res3.get("success"):
+                return True, res3["data"], "minimo"
+    
+    return False, None, None
 
+def search_with_token(token, payload):
+    if not token:
+        return {"success": False, "error": "Token não fornecido"}
+    headers = HEADERS.copy()
+    headers['Cookie'] = f'aws-waf-token={token}'
     try:
-        response = requests.post(
-            URL_API,
-            headers=_make_headers(token),
-            json=payload,
-            verify=False,
-            timeout=30,
-        )
-        logger.info(f"HTTP {response.status_code}")
-
+        logger.debug(f"Enviando payload: {json.dumps(payload)[:200]}...")
+        response = requests.post(URL_API, headers=headers, json=payload, verify=False, timeout=30)
+        logger.info(f"Resposta: status {response.status_code}")
         if response.status_code == 200:
             return {"success": True, "data": response.json()}
-
-        if response.status_code == 403:
+        elif response.status_code == 403:
             token_cache["token"] = None
-            token_cache["expires_at"] = 0
-            return {"success": False, "error": "Token expirado (403)", "status": 403}
-
-        if response.status_code == 202:
-            return {
-                "success": False,
-                "error": "WAF bloqueou requisição (202)",
-                "status": 202,
-            }
-
-        return {
-            "success": False,
-            "error": f"HTTP {response.status_code}",
-            "status": response.status_code,
-            "text": response.text[:500],
-        }
+            return {"success": False, "error": "Token expirado", "status": 403}
+        else:
+            return {"success": False, "error": f"HTTP {response.status_code}", "status": response.status_code, "text": response.text[:500]}
     except Exception as e:
-        logger.error(f"Erro na requisição: {e}")
+        logger.error(f"Erro na requisição: {str(e)}")
         return {"success": False, "error": str(e)}
 
-
-def try_search_cascade(
-    token: str,
-    term: str,
-    size: int,
-    from_: int,
-    sort: str,
-    sort_order: str,
-    base: str,
-) -> tuple[bool, dict | None, str | None]:
+def get_document_by_id(token, doc_id):
     """
-    Tenta 3 níveis de complexidade de payload.
-    Retorna (success, data, nivel_usado).
+    Busca um documento por ID, tentando diferentes payloads (completo, simples, etc.)
     """
-    levels = [
-        ("completo",      dict(include_aggs=True,  include_highlight=True)),
-        ("sem_highlight", dict(include_aggs=False, include_highlight=False)),
-        ("minimo",        None),
-    ]
-
-    for nivel, kwargs in levels:
-        if nivel == "minimo":
-            payload = {
-                "query": {"bool": {"filter": [{"term": {"base": base}}]}},
-                "_source": ["id", "titulo", "ementa_texto", "processo_numero",
-                            "julgamento_data", "relator_processo_nome", "inteiro_teor_url"],
-                "size": size,
-                "from": from_,
-                "sort": [{"julgamento_data": {"order": sort_order}}],
-                "track_total_hits": True,
+    # Tentar payload completo com highlight
+    payload_completo = PAYLOAD_POR_ID_COMPLETO.copy()
+    payload_completo["query"]["ids"]["values"] = [doc_id]
+    res = search_with_token(token, payload_completo)
+    if res.get("success") and res["data"].get("hits", {}).get("hits"):
+        return res
+    
+    # Se falhou, tentar payload sem highlight
+    logger.info("Payload completo por ID falhou. Tentando payload simples...")
+    payload_simples = PAYLOAD_POR_ID_SIMPLES.copy()
+    payload_simples["query"]["ids"]["values"] = [doc_id]
+    res2 = search_with_token(token, payload_simples)
+    if res2.get("success") and res2["data"].get("hits", {}).get("hits"):
+        return res2
+    
+    # Último recurso: buscar por termo no campo id (alguns documentos podem ter id em _id)
+    logger.info("Payloads por ID falharam. Tentando busca por termo...")
+    payload_termo = {
+        "query": {
+            "bool": {
+                "should": [
+                    {"term": {"_id": doc_id}},
+                    {"term": {"id": doc_id}},
+                    {"term": {"dg_unique": doc_id}}
+                ]
             }
-        else:
-            payload = build_payload(
-                term=term, size=size, from_=from_,
-                sort=sort, sort_order=sort_order, base=base,
-                **kwargs,
-            )
-
-        logger.info(f"Tentando payload [{nivel}]...")
-        res = search_with_token(token, payload)
-
-        if res.get("success"):
-            return True, res["data"], nivel
-
-        # Apenas continua em erros de payload (400), não de auth (403/202)
-        if res.get("status") not in (400, None):
-            break
-
-    return False, None, None
+        },
+        "_source": PAYLOAD_COMPLETO["_source"],
+        "size": 1
+    }
+    res3 = search_with_token(token, payload_termo)
+    return res3
 
+def get_document_raw(token, doc_id):
+    """
+    Tenta obter o documento completo via endpoint /api/search/get/{id}
+    """
+    if not token:
+        return {"success": False, "error": "Token não fornecido"}
+    headers = HEADERS.copy()
+    headers['Cookie'] = f'aws-waf-token={token}'
+    # Remove Content-Type para GET
+    headers.pop("Content-Type", None)
+    url = f"{URL_API_GET}/{doc_id}"
+    try:
+        response = requests.get(url, headers=headers, verify=False, timeout=30)
+        logger.info(f"GET documento raw: status {response.status_code}")
+        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}", "status": response.status_code, "text": response.text[:500]}
+    except Exception as e:
+        logger.error(f"Erro na requisição GET: {str(e)}")
+        return {"success": False, "error": str(e)}
 
-def playwright_fetch(payload: dict) -> dict:
-    """Fallback: executa fetch() dentro do browser já autenticado pelo WAF."""
-    logger.info("Fallback Playwright fetch...")
+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", "--disable-dev-shm-usage"]
-            )
+            browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
             context = browser.new_context(
-                viewport={"width": 1920, "height": 1080},
-                user_agent=HEADERS_BASE["User-Agent"],
+                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.goto("https://jurisprudencia.stf.jus.br/pages/search", wait_until='domcontentloaded', timeout=30000)
             page.wait_for_timeout(3000)
-
             cookies = context.cookies()
-            token = next(
-                (c["value"] for c in cookies if c["name"] == "aws-waf-token"), None
-            )
-
-            result = page.evaluate(
-                """async (payload) => {
+            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 r = await fetch(
-                            'https://jurisprudencia.stf.jus.br/api/search/search',
-                            {
-                                method: 'POST',
-                                headers: {
-                                    'Content-Type': 'application/json',
-                                    'Accept': 'application/json'
-                                },
-                                body: JSON.stringify(payload)
-                            }
-                        );
-                        return r.ok
-                            ? { success: true, data: await r.json() }
-                            : { success: false, status: r.status };
-                    } catch(e) {
-                        return { success: false, error: e.toString() };
+                        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,
-            )
+                }
+            """, payload)
             browser.close()
-
-            if token:
-                token_cache["token"] = token
-                token_cache["expires_at"] = time.time() + 3300
-
-            if result.get("success"):
-                return {"success": True, "data": result["data"], "token": token}
-
-            return {
-                "success": False,
-                "error": result.get("error", "Falha desconhecida"),
-                "status": result.get("status"),
-            }
+            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'), "status": api_result.get('status'), "token": token}
     except Exception as e:
-        logger.error(f"Erro no Playwright fetch: {e}")
+        logger.error(f"Erro no Playwright: {str(e)}")
         return {"success": False, "error": str(e)}
 
-
 # ============================================
-# HELPERS DE RESPOSTA
+# Rotas
 # ============================================
-def _extract_first(d: dict, *keys, default=""):
-    for k in keys:
-        v = d.get(k)
-        if v:
-            return v
-    return default
+@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')
+    
+    token = get_fresh_token()
+    if not token:
+        # Fallback para Playwright
+        payload = PAYLOAD_MINIMO.copy()
+        payload["size"] = min(page_size, 250)
+        payload["sort"] = [{"julgamento_data": {"order": sort_order}}]
+        if base:
+            payload["post_filter"] = {"bool": {"must": [{"term": {"base": base}}]}}
+        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', 'Falha')}), 500
+    
+    # Tentar com múltiplos payloads
+    success, data, payload_type = try_search_with_payloads(token, PAYLOAD_COMPLETO, sort_order, base)
+    if success:
+        logger.info(f"Busca bem-sucedida com payload: {payload_type}")
+        return jsonify({"success": True, "token": token, "data": data, "timestamp": time.time()})
+    else:
+        # Último recurso: Playwright
+        payload = PAYLOAD_MINIMO.copy()
+        payload["size"] = min(page_size, 250)
+        payload["sort"] = [{"julgamento_data": {"order": sort_order}}]
+        if base:
+            payload["post_filter"] = {"bool": {"must": [{"term": {"base": base}}]}}
+        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": "Todas as tentativas falharam"}), 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/document-raw/<doc_id>', methods=['GET'])
+def get_document_raw_endpoint(doc_id):
+    """
+    Endpoint para obter o documento completo via GET (pode incluir inteiro teor em texto)
+    """
+    token = get_fresh_token()
+    if not token:
+        return jsonify({"error": "Não foi possível obter token"}), 500
+    
+    result = get_document_raw(token, doc_id)
+    
+    if result.get("success"):
+        return jsonify({"success": True, "document": result["data"]})
+    else:
+        # Se token expirou, limpar cache e tentar novamente uma vez
+        if result.get("status") == 403:
+            token_cache["token"] = None
+            token = get_fresh_token()
+            if token:
+                result = get_document_raw(token, doc_id)
+                if result.get("success"):
+                    return jsonify({"success": True, "document": result["data"]})
+        return jsonify({"success": False, "error": result.get("error", "Falha")}), 500
 
-def _format_hits(hits: list) -> list:
-    results = []
-    for hit in hits:
-        src = hit.get("_source", {})
-        hl = hit.get("highlight", {})
-        ementa = _extract_first(
-            hl, "ementa_texto",
-            default=src.get("ementa_texto", ""),
-        )
-        if isinstance(ementa, list):
-            ementa = ementa[0] if ementa else ""
-
-        results.append({
-            "id": src.get("id"),
-            "titulo": src.get("titulo"),
-            "processo": src.get("processo_codigo_completo") or src.get("processo_numero"),
-            "classe": src.get("processo_classe_processual_unificada_extenso"),
-            "orgao": src.get("orgao_julgador"),
-            "relator": src.get("relator_processo_nome") or src.get("relator_acordao_nome"),
-            "data_julgamento": src.get("julgamento_data"),
-            "data_publicacao": src.get("publicacao_data"),
-            "ramo_direito": src.get("ramo_direito"),
-            "is_repercussao_geral": src.get("is_repercussao_geral"),
-            "ementa": ementa.strip() if ementa else "",
-            "tese": src.get("documental_tese_texto"),
-            "url_inteiro_teor": src.get("inteiro_teor_url"),
-            "url_acompanhamento": src.get("acompanhamento_processual_url"),
-            "url_dje": src.get("dje_url"),
-            "score": hit.get("_score"),
-        })
-    return results
+@app.route('/api/test-bypass', methods=['POST'])
+def test_bypass():
+    token = get_fresh_token()
+    if token:
+        # Tenta payload completo
+        success, data, _ = try_search_with_payloads(token, PAYLOAD_COMPLETO, 'desc', None)
+        if success:
+            return jsonify({"success": True, "method": "token", "token": token, "data": data})
+    # Fallback Playwright com payload mínimo
+    res = test_with_playwright_full(PAYLOAD_MINIMO)
+    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"})
 
 # ============================================
-# ENDPOINTS
+# NOVO ENDPOINT SIMPLIFICADO /busca
 # ============================================
-@app.route("/busca")
-def busca():
+@app.route('/busca')
+def busca_simplificada():
     """
-    GET /busca?q=termo&page=1&size=20&sort=_score&base=acordaos
+    Endpoint público para busca simplificada de jurisprudência.
+    Exemplo: /busca?q=dano%20moral
+    Retorna JSON com campos: id, titulo, processo, relator, orgao, data, ementa, url_documento, score.
     """
-    query = request.args.get("q", "").strip()
+    query = request.args.get('q', '')
     if not query:
-        return jsonify({"error": "Parâmetro 'q' é obrigatório"}), 400
-
-    page       = max(1, int(request.args.get("page", 1)))
-    size       = min(int(request.args.get("size", 20)), 250)
-    sort       = request.args.get("sort", "_score")        # _score | julgamento_data | publicacao_data
-    sort_order = request.args.get("order", "desc")         # asc | desc
-    base       = request.args.get("base", "acordaos")      # acordaos | sumulas | decisoes | novo_informativo
-
-    from_ = (page - 1) * size
+        return jsonify({"erro": "Parâmetro 'q' é obrigatório"}), 400
 
     token = get_fresh_token()
     if not token:
-        return jsonify({"success": False, "error": "Falha ao obter token WAF"}), 500
-
-    success, data, nivel = try_search_cascade(
-        token, query, size, from_, sort, sort_order, base
-    )
-
-    if not success:
-        # Fallback Playwright
-        fallback_payload = build_payload(
-            term=query, size=size, from_=from_,
-            sort=sort, sort_order=sort_order, base=base,
-            include_aggs=False, include_highlight=True,
-        )
-        res = playwright_fetch(fallback_payload)
-        if res.get("success"):
-            data  = res["data"]
-            nivel = "playwright"
-            success = True
-
-    if not success:
-        return jsonify({"success": False, "error": "Todas as tentativas falharam"}), 500
-
-    # Normaliza estrutura da resposta (API retorna result.hits.hits ou hits.hits)
-    root  = data.get("result", data)
-    hits_obj = root.get("hits", {})
-    total    = hits_obj.get("total", {}).get("value", 0)
-    hits     = hits_obj.get("hits", [])
-
-    # Aggregations (facets), quando disponíveis
-    aggs = root.get("aggregations", data.get("aggregations"))
+        return jsonify({"erro": "Não foi possível obter token de acesso"}), 503
 
-    return jsonify({
-        "success": True,
-        "query":   query,
-        "base":    base,
-        "total":   total,
-        "page":    page,
-        "size":    size,
-        "nivel_payload": nivel,
-        "aggregations": aggs,
-        "results": _format_hits(hits),
-    })
+    # Payload leve e focado nos campos desejados
+    payload = {
+        "query": {
+            "query_string": {
+                "query": query,
+                "default_operator": "AND",
+                "fields": ["ementa_texto", "acordao_ata", "decisao_texto", "titulo"]
+            }
+        },
+        "_source": [
+            "id", "titulo", "processo_codigo_completo", "relator_processo_nome",
+            "orgao_julgador", "julgamento_data", "ementa_texto", "inteiro_teor_url"
+        ],
+        "size": 20,
+        "sort": [{"julgamento_data": {"order": "desc"}}],
+        "track_total_hits": True
+    }
 
+    headers = HEADERS.copy()
+    headers['Cookie'] = f'aws-waf-token={token}'
 
-@app.route("/health")
-def health():
-    playwright_ok = False
     try:
-        with sync_playwright() as p:
-            p.chromium.launch(headless=True, args=["--no-sandbox"]).close()
-            playwright_ok = True
-    except Exception:
-        pass
+        response = requests.post(URL_API, headers=headers, json=payload, verify=False, timeout=15)
+    except Exception as e:
+        return jsonify({"erro": f"Falha na comunicação com a API: {str(e)}"}), 502
 
-    # Ping mínimo na API
-    api_ok    = False
-    total_docs = None
-    token = get_fresh_token()
-    if token:
-        res = search_with_token(
-            token,
-            {"size": 0, "query": {"match_all": {}}, "track_total_hits": True},
-        )
-        if res.get("success"):
-            api_ok     = True
-            total_docs = (
-                res["data"]
-                .get("hits", {})
-                .get("total", {})
-                .get("value")
-            )
+    if response.status_code != 200:
+        return jsonify({"erro": f"API retornou status {response.status_code}"}), response.status_code
+
+    data = response.json()
+    hits = data.get('result', {}).get('hits', {}).get('hits', [])
+
+    resultados = []
+    for hit in hits:
+        source = hit.get('_source', {})
+        # Mapeia exatamente os campos desejados, incluindo score
+        item = {
+            "id": source.get('id') or hit.get('_id'),
+            "titulo": source.get('titulo'),
+            "processo": source.get('processo_codigo_completo'),
+            "relator": source.get('relator_processo_nome'),
+            "orgao": source.get('orgao_julgador'),
+            "data": source.get('julgamento_data'),
+            "ementa": source.get('ementa_texto'),
+            "url_documento": source.get('inteiro_teor_url'),
+            "score": hit.get('_score')
+        }
+        # Remove campos nulos (opcional)
+        item = {k: v for k, v in item.items() if v is not None}
+        resultados.append(item)
 
     return jsonify({
-        "status":            "healthy" if playwright_ok and api_ok else "degraded",
-        "timestamp":         time.time(),
-        "playwright_ready":  playwright_ok,
-        "api_reachable":     api_ok,
-        "token_cached":      bool(token_cache["token"]),
-        "token_expires_in":  max(0, token_cache["expires_at"] - time.time()),
-        "total_docs":        total_docs,
-        "python_version":    sys.version,
+        "q": query,
+        "total": data.get('result', {}).get('hits', {}).get('total', {}).get('value', 0),
+        "resultados": resultados
     })
 
-
-# ============================================
-# MAIN
-# ============================================
-if __name__ == "__main__":
+if __name__ == '__main__':
     try:
         import certifi
-        os.environ["SSL_CERT_FILE"]        = certifi.where()
-        os.environ["REQUESTS_CA_BUNDLE"]   = certifi.where()
-    except ImportError:
+        os.environ['SSL_CERT_FILE'] = certifi.where()
+        os.environ['REQUESTS_CA_BUNDLE'] = certifi.where()
+    except:
         pass
-
-    logger.info("=" * 50)
-    logger.info("🚀 STF Jurisprudência — Para.AI")
-    logger.info(f"📋 _source fields: {len(_SOURCE_FIELDS)}")
-    logger.info("=" * 50)
-
+    logger.info("="*50)
+    logger.info("🚀 Iniciando aplicação STF Jurisprudência")
+    logger.info(f"📋 Campos _source: {len(PAYLOAD_COMPLETO['_source'])}")
+    logger.info("="*50)
     try:
         with sync_playwright() as p:
-            p.chromium.launch(headless=True, args=["--no-sandbox"]).close()
-        logger.info("✅ Playwright pronto")
+            p.chromium.launch(headless=True).close()
+        logger.info("✅ Playwright pronto para uso")
     except Exception as e:
-        logger.warning(f"⚠️  Playwright: {e}")
-
-    port = int(os.environ.get("PORT", 7860))
-    app.run(host="0.0.0.0", port=port, debug=False)
+        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)