Update recebimento.py

recebimento.py

@@ -17,6 +17,8 @@ try:
 except Exception:
     ALT_AVAILABLE = False
 
+from sqlalchemy import func, or_, and_
+
 from banco import SessionLocal
 from models import RecebimentoRegistro
 
@@ -973,6 +975,309 @@ def _kpis_metas(total_reg: int, datas: pd.Series, meta_diaria: float, meta_mensa
         c6.metric("Ating. total vs soma metas diárias", "—")
 
 
+# ==========================================================
+# Helpers — Registros (consulta completa, filtros dinâmicos, paginação)
+# ==========================================================
+def _sa_col_python_type(sa_col) -> type:
+    """Tenta inferir o tipo Python do campo SQLAlchemy; fallback para str."""
+    try:
+        return sa_col.type.python_type  # nem todo dialecto implementa
+    except Exception:
+        return str
+
+def _all_model_columns():
+    """Retorna lista [(nome_attr, coluna_sqlalchemy)] do modelo RecebimentoRegistro."""
+    return [(c.name, c) for c in RecebimentoRegistro.__table__.columns]
+
+def _campo_to_label():
+    """Mapeia campo interno -> rótulo oficial (se existir), senão retorna o próprio nome do campo."""
+    lbl = {}
+    for rot, (campo, _conv) in COLUMN_MAP.items():
+        lbl[campo] = rot
+    return lbl
+
+def _label_to_campo():
+    """Mapeia rótulo -> campo interno."""
+    return {rot: campo for rot, (campo, _conv) in COLUMN_MAP.items()}
+
+def _make_filters_ui(db, key_prefix: str = "reg"):
+    """
+    Renderiza UI de filtros executiva:
+    - Busca global (texto) em todos os campos textuais
+    - Filtros avançados dinâmicos e tipados
+    - Ordenação + paginação
+    Retorna dicionário de configuração.
+    """
+    # Descobrir campos e tipos
+    cols = _all_model_columns()
+    campo_to_sa = {name: col for name, col in cols}
+    campo_types = {name: _sa_col_python_type(col) for name, col in cols}
+
+    # Mapas de rótulos
+    campo2label = _campo_to_label()
+    label2campo = _label_to_campo()
+
+    # Lista de rótulos disponíveis (prefere OFFICIAL_COLUMNS + ID; adiciona extras existentes)
+    rotulos_base = []
+    if "ID" in OPTIONAL_COLUMNS:
+        rotulos_base.append("ID")
+    rotulos_base.extend(OFFICIAL_COLUMNS)
+
+    # Converter rótulos -> campos (existentes no modelo)
+    campos_oficiais = []
+    for rot in rotulos_base:
+        if rot == "ID":
+            continue
+        campo = label2campo.get(rot)
+        if campo and campo in campo_to_sa:
+            campos_oficiais.append((rot, campo))
+
+    # Extras: qualquer coluna do modelo que não esteja no mapping acima
+    usados = {c for _, c in campos_oficiais}
+    extras = [(campo2label.get(c, c).upper(), c) for c in campo_to_sa.keys() if c not in usados]
+
+    # Busca global
+    st.subheader("🔎 Consulta Executiva")
+    global_q = st.text_input(
+        "Pesquisa Global (em textos e códigos)",
+        placeholder="Digite um termo para buscar em múltiplos campos (ex.: NF, Fornecedor, PO, Placa, Projeto...)",
+        key=f"{key_prefix}__global_q"
+    ).strip()
+    global_q = global_q or None
+
+    # Filtros avançados (dinâmicos)
+    with st.expander("⚙️ Filtros avançados por campo", expanded=False):
+        # Selecionar campos para filtrar
+        options_labels = [rot for rot, _c in campos_oficiais] + [rot for rot, _c in extras]
+        # Remover duplicidades mantendo ordem
+        seen = set()
+        options_labels = [x for x in options_labels if not (x in seen or seen.add(x))]
+        sel_labels = st.multiselect(
+            "Escolha os campos que deseja filtrar:",
+            options=options_labels,
+            key=f"{key_prefix}__sel_campos"
+        )
+
+        # Renderizar widgets para cada campo selecionado
+        field_filters: Dict[str, Dict[str, Any]] = {}
+        cols_grid = st.columns(2)
+        for i, rot in enumerate(sel_labels):
+            col = cols_grid[i % 2]
+            campo = label2campo.get(rot, None)
+            if not campo:
+                # extras foram upper(); tente casar pelo label upper do mapping
+                match = [c for c, lbl in _campo_to_label().items() if lbl.upper() == rot]
+                campo = match[0] if match else (rot.lower() if rot.lower() in campo_to_sa else None)
+
+            if not campo or campo not in campo_to_sa:
+                continue
+
+            py_type = campo_types.get(campo, str)
+
+            with col:
+                st.caption(f"Filtro — **{rot}**")
+
+                # DATA / DATETIME
+                if py_type in (date, datetime):
+                    d_ini = st.date_input(f"De ({rot})", value=None, key=f"{key_prefix}__f_{campo}_ini")
+                    d_fim = st.date_input(f"Até ({rot})", value=None, key=f"{key_prefix}__f_{campo}_fim")
+                    field_filters[campo] = {"op": "between_date", "ini": d_ini, "fim": d_fim}
+
+                # BOOLEAN
+                elif py_type is bool:
+                    val = st.selectbox(
+                        rot,
+                        options=["Todos", "SIM", "NÃO"],
+                        key=f"{key_prefix}__f_{campo}_bool"
+                    )
+                    field_filters[campo] = {"op": "eq_bool", "value": None if val == "Todos" else (val == "SIM")}
+
+                # NUMÉRICO
+                elif py_type in (int, float):
+                    c1, c2 = st.columns(2)
+                    vmin = c1.number_input(f"Mín ({rot})", value=0.0 if py_type is float else 0, key=f"{key_prefix}__f_{campo}_min")
+                    vmax = c2.number_input(f"Máx ({rot})", value=0.0 if py_type is float else 0, key=f"{key_prefix}__f_{campo}_max")
+                    field_filters[campo] = {"op": "between_num", "min": vmin, "max": vmax, "is_float": py_type is float}
+
+                # TEXTO (inclui horas em 'HH:MM:SS' e códigos)
+                else:
+                    term = st.text_input(f"Contém ({rot})", value="", key=f"{key_prefix}__f_{campo}_txt").strip()
+                    if term != "":
+                        field_filters[campo] = {"op": "contains", "value": term}
+
+    # Ordenação e Paginação (básicos; primeira/última/ir p/ página serão aplicados depois de saber o total)
+    st.divider()
+    st.subheader("📑 Ordenação & Paginação")
+
+    # Lista de campos ordenáveis (todos)
+    sort_labels = [rot for rot, _ in campos_oficiais] + [rot for rot, _ in extras]
+    # remover duplicatas mantendo ordem
+    seen_s = set()
+    sort_labels = [x for x in sort_labels if not (x in seen_s or seen_s.add(x))]
+
+    sort_sel = st.selectbox(
+        "Ordenar por",
+        options=sort_labels,
+        index=sort_labels.index("DATA") if "DATA" in sort_labels else 0,
+        key=f"{key_prefix}__sort_label"
+    )
+
+    sort_campo = label2campo.get(sort_sel)
+    if not sort_campo:
+        # extras: tentar inferir pelo label uppercase
+        m = [c for c, lbl in _campo_to_label().items() if lbl.upper() == sort_sel]
+        sort_campo = m[0] if m else (sort_sel.lower() if sort_sel.lower() in campo_to_sa else None)
+    sort_dir = st.radio("Direção", options=["Ascendente", "Descendente"], horizontal=True, key=f"{key_prefix}__sort_dir")
+    sort_dir = "asc" if sort_dir == "Ascendente" else "desc"
+
+    cpg1, cpg2, cpg3 = st.columns([1, 1, 2])
+    page_size = cpg1.selectbox("Registros por página", options=[50, 100, 250, 1000], index=1, key=f"{key_prefix}__page_size")
+    # Estado da página
+    page_state_key = f"{key_prefix}__page_idx"
+    if page_state_key not in st.session_state:
+        st.session_state[page_state_key] = 0
+    # Botões navegação básicos
+    prev = cpg2.button("⬅️ Anterior", key=f"{key_prefix}__prev")
+    next_ = cpg3.button("Próxima ➡️", key=f"{key_prefix}__next")
+    if prev and st.session_state[page_state_key] > 0:
+        st.session_state[page_state_key] -= 1
+    if next_:
+        st.session_state[page_state_key] += 1
+
+    return {
+        "global_q": global_q,
+        "field_filters": field_filters if len(field_filters) > 0 else {},
+        "sort_field": sort_campo,
+        "sort_dir": sort_dir,
+        "page_size": int(page_size),
+        "page_idx": int(st.session_state[page_state_key]),
+        "page_state_key": page_state_key,
+        "sort_labels": sort_labels
+    }
+
+def _apply_filters_build_query(db, fcfg):
+    """Monta query SQLAlchemy com filtros, ordenação e retorna (query, total_count)."""
+    q = db.query(RecebimentoRegistro)
+
+    # Tipos por coluna
+    campo_to_sa = {c.name: c for c in RecebimentoRegistro.__table__.columns}
+    campo_types = {name: _sa_col_python_type(col) for name, col in campo_to_sa.items()}
+
+    # Filtro global (aplica em campos textuais)
+    if fcfg["global_q"]:
+        g = f"%{fcfg['global_q']}%"
+        ors = []
+        for campo, sa_col in campo_to_sa.items():
+            py_t = campo_types.get(campo, str)
+            if py_t in (str,):
+                try:
+                    ors.append(sa_col.ilike(g))
+                except Exception:
+                    # alguns tipos não suportam ilike nativamente
+                    pass
+        if ors:
+            q = q.filter(or_(*ors))
+
+    # Filtros por campo
+    for campo, spec in (fcfg["field_filters"] or {}).items():
+        col = campo_to_sa.get(campo)
+        if col is None:
+            continue
+        op = spec.get("op")
+        if op == "between_date":
+            d_ini = spec.get("ini")
+            d_fim = spec.get("fim")
+            ands = []
+            if d_ini:
+                ands.append(col >= d_ini)
+            if d_fim:
+                ands.append(col <= d_fim)
+            if ands:
+                q = q.filter(and_(*ands))
+        elif op == "eq_bool":
+            val = spec.get("value", None)
+            if val is True or val is False:
+                q = q.filter(col == val)
+        elif op == "between_num":
+            vmin = spec.get("min", None)
+            vmax = spec.get("max", None)
+            ands = []
+            if vmin is not None:
+                ands.append(col >= vmin)
+            if vmax is not None:
+                ands.append(col <= vmax)
+            if ands:
+                q = q.filter(and_(*ands))
+        elif op == "contains":
+            term = spec.get("value")
+            if term:
+                try:
+                    q = q.filter(col.ilike(f"%{term}%"))
+                except Exception:
+                    pass
+
+    # Total filtrado
+    total = q.with_entities(func.count(RecebimentoRegistro.id)).scalar() or 0
+
+    # Ordenação
+    sort_field = fcfg.get("sort_field")
+    sort_dir = fcfg.get("sort_dir", "asc")
+    if sort_field and sort_field in campo_to_sa:
+        col = campo_to_sa[sort_field]
+        q = q.order_by(col.asc() if sort_dir == "asc" else col.desc())
+    else:
+        q = q.order_by(RecebimentoRegistro.created_at.desc())
+
+    return q, int(total)
+
+def _query_paginated(q, page_idx: int, page_size: int):
+    """Aplica paginação server-side."""
+    if page_idx < 0:
+        page_idx = 0
+    return q.offset(page_idx * page_size).limit(page_size)
+
+def _rows_to_dataframe(rows: List[RecebimentoRegistro]) -> pd.DataFrame:
+    if not rows:
+        return pd.DataFrame()
+    return pd.DataFrame([{c.name: getattr(r, c.name) for c in r.__table__.columns} for r in rows])
+
+def _format_display_df(df_base: pd.DataFrame) -> pd.DataFrame:
+    """
+    Constrói DF de exibição com rótulos oficiais, preservando ordem executiva.
+    Adiciona extras ao final.
+    """
+    if df_base.empty:
+        return df_base
+
+    # Rótulo -> campo e vice-versa
+    label2campo = _label_to_campo()
+
+    # Monta DF de exibição com rótulos em ordem oficial
+    df_disp = pd.DataFrame()
+    # ID (opcional)
+    if "id_planilha" in df_base.columns:
+        df_disp["ID"] = df_base["id_planilha"]
+
+    # Oficiais
+    for rot in OFFICIAL_COLUMNS:
+        campo = label2campo.get(rot)
+        if campo and campo in df_base.columns:
+            df_disp[rot] = df_base[campo]
+
+    # Extras
+    usados = {"id_planilha"}
+    usados.update([label2campo.get(rot) for rot in OFFICIAL_COLUMNS if label2campo.get(rot)])
+    for extra in df_base.columns:
+        if extra not in usados:
+            df_disp[extra] = df_base[extra]
+
+    # Normalizar datas na exibição
+    if "DATA" in df_disp.columns:
+        df_disp["DATA"] = pd.to_datetime(df_disp["DATA"], errors="coerce").dt.date
+
+    return df_disp
+
+
 # ==========================================================
 # Helpers de UI (preview + processamento)
 # ==========================================================
@@ -1135,7 +1440,7 @@ def formulario(payload: Optional[Dict[str, Any]] = None, key_prefix: str = "new"
     return {
         "id_planilha": (payload.get("id_planilha") or _next_id_planilha()),
 
-        "DATA": None,  # apenas para referência visual no form
+        "DATA": None,  # apenas para referência visual no form (será filtrado no _filter_to_model)
         "data": data,
         "data_emissao": data_emissao,
         "nota_fiscal": nf,
@@ -1596,165 +1901,165 @@ def main():
                 st.session_state["__idx_iguais_db__"] = []
                 st.info("Prévia descartada. Clique em **⚙️ Processar agora** para gerar novamente.")
 
-    # ------------------ LISTA ------------------
+    # ------------------ REGISTROS (CONSULTA COMPLETA) ------------------
     with aba_reg:
-        st.header("Registros (com filtros)")
+        st.header("Registros — Consulta Completa")
 
         db = _get_db()
         try:
-            regs = (
-                db.query(RecebimentoRegistro)
-                  .order_by(RecebimentoRegistro.created_at.desc())
-                  .limit(5000)
-                  .all()
+            # Filtros e paginação (UI)
+            fcfg = _make_filters_ui(db, key_prefix="reg")
+
+            # Montar query com filtros
+            q, total = _apply_filters_build_query(db, fcfg)
+
+            # Cálculo de total de páginas
+            total_pages = max(1, (total + fcfg["page_size"] - 1) // fcfg["page_size"])
+
+            # Navegação aprimorada: Primeira/Última/Ir para página
+            st.markdown("### 🧭 Navegação")
+            cnav1, cnav2, cnav3, cnav4 = st.columns([1, 1, 2, 1])
+            first = cnav1.button("⏮️ Primeira", key="reg__first")
+            last = cnav2.button("Última ⏭️", key="reg__last")
+            goto_val = cnav3.number_input(
+                "Ir para página",
+                min_value=1, max_value=total_pages,
+                value=min(fcfg['page_idx'] + 1, total_pages),
+                step=1, key="reg__goto"
             )
+            go_btn = cnav4.button("Ir", key="reg__go")
+
+            # Ajustes de navegação
+            if first:
+                fcfg["page_idx"] = 0
+                st.session_state[fcfg["page_state_key"]] = 0
+            if last:
+                fcfg["page_idx"] = total_pages - 1
+                st.session_state[fcfg["page_state_key"]] = total_pages - 1
+            if go_btn:
+                new_idx = max(0, min(total_pages - 1, int(goto_val) - 1))
+                fcfg["page_idx"] = new_idx
+                st.session_state[fcfg["page_state_key"]] = new_idx
+
+            # Corrigir índice de página caso ultrapasse o total
+            if fcfg["page_idx"] >= total_pages:
+                fcfg["page_idx"] = max(0, total_pages - 1)
+                st.session_state[fcfg["page_state_key"]] = fcfg["page_idx"]
+
+            # Buscar página
+            qp = _query_paginated(q, fcfg["page_idx"], fcfg["page_size"])
+            rows = qp.all()
         finally:
             db.close()
 
-        if not regs:
-            st.info("Nenhum registro encontrado.")
-            st.stop()
-
-        df_base = pd.DataFrame([{c.name: getattr(r, c.name) for c in r.__table__.columns} for r in regs])
-
-        if not df_base.empty and "data" in df_base.columns:
-            df_base["data"] = pd.to_datetime(df_base["data"], errors="coerce").dt.date
-
-        def rotulo_to_campo(rotulo: str) -> Optional[str]:
-            info = COLUMN_MAP.get(rotulo)
-            return info[0] if info else None
+        df_base = _rows_to_dataframe(rows)
+        df_disp = _format_display_df(df_base)
 
-        ordem_rotulos = []
-        if "ID" in OPTIONAL_COLUMNS:
-            ordem_rotulos.append("ID")
-        ordem_rotulos.extend(OFFICIAL_COLUMNS)
-
-        colunas_display = []
-        for rot in ordem_rotulos:
-            campo = rotulo_to_campo(rot)
-            if campo and campo in df_base.columns:
-                colunas_display.append((rot, campo))
-
-        df_disp = pd.DataFrame()
-        for rot, campo in colunas_display:
-            df_disp[rot] = df_base[campo]
-
-        usados = {campo for _rot, campo in colunas_display}
-        extras = [c for c in df_base.columns if c not in usados]
-        for extra in extras:
-            df_disp[extra] = df_base[extra]
-
-        with st.expander("🔎 Filtros", expanded=True):
-            c1, c2, c3 = st.columns(3)
-            f_po = c1.text_input("P.O (campo: po)", placeholder="ex.: 4500...", key="reg__f_po")
-            f_pn = c2.text_input("PN (campo: pn)", placeholder="ex.: 1Z23...", key="reg__f_pn")
-            f_lot = c3.text_input("LOT BATCH (campo: lot_batch)", placeholder="ex.: L123...", key="reg__f_lot")
-
-            c4, c5, c6 = st.columns(3)
-            f_nf = c4.text_input("Nota Fiscal (campo: nota_fiscal)", placeholder="ex.: 12345", key="reg__f_nf")
-            f_forn = c5.text_input("Fornecedor (campo: fornecedor)", placeholder="ex.: ACME", key="reg__f_forn")
-            f_placa = c6.text_input("Placa do Veículo (campo: placa_veiculo)", placeholder="ex.: ABC1D23", key="reg__f_placa")
-
-            c7, c8, c9 = st.columns([1, 1, 1])
-            f_data_ini = c7.date_input("Data inicial (campo: data)", value=None, key="reg__f_data_ini")
-            f_data_fim = c8.date_input("Data final (campo: data)", value=None, key="reg__f_data_fim")
-            limpar = c9.button("Limpar filtros", key="reg__btn_limpar_filtros")
-
-            if limpar:
-                for k in ["reg__f_po", "reg__f_pn", "reg__f_lot", "reg__f_nf", "reg__f_forn", "reg__f_placa", "reg__f_data_ini", "reg__f_data_fim"]:
-                    if k in st.session_state:
-                        del st.session_state[k]
-                st.rerun()
-
-        df_filtrado = df_base.copy()
-
-        def _contains(df, col, term):
-            if not term or col not in df.columns:
-                return pd.Series([True] * len(df))
-            return df[col].astype(str).str.contains(str(term), case=False, na=False)
-
-        if f_po:   df_filtrado = df_filtrado[_contains(df_filtrado, "po", f_po)]
-        if f_pn:   df_filtrado = df_filtrado[_contains(df_filtrado, "pn", f_pn)]
-        if f_lot:  df_filtrado = df_filtrado[_contains(df_filtrado, "lot_batch", f_lot)]
-        if f_nf:   df_filtrado = df_filtrado[_contains(df_filtrado, "nota_fiscal", f_nf)]
-        if f_forn: df_filtrado = df_filtrado[_contains(df_filtrado, "fornecedor", f_forn)]
-        if f_placa:df_filtrado = df_filtrado[_contains(df_filtrado, "placa_veiculo", f_placa)]
-        if "data" in df_filtrado.columns:
-            if f_data_ini:
-                df_filtrado = df_filtrado[df_filtrado["data"] >= f_data_ini]
-            if f_data_fim:
-                df_filtrado = df_filtrado[df_filtrado["data"] <= f_data_fim]
-
-        df_disp_filtrado = pd.DataFrame()
-        for rot, campo in colunas_display:
-            if campo in df_filtrado.columns:
-                df_disp_filtrado[rot] = df_filtrado[campo]
-        for extra in extras:
-            if extra in df_filtrado.columns:
-                df_disp_filtrado[extra] = df_filtrado[extra]
-
-        total_filtrado = len(df_disp_filtrado)
-        if "DATA" in df_disp_filtrado.columns:
-            datas_validas = pd.to_datetime(df_disp_filtrado["DATA"], errors="coerce").dt.date.dropna()
+        # KPIs executivos
+        cK1, cK2, cK3, cK4 = st.columns(4)
+        cK1.metric("Total filtrado", value=f"{total:,}".replace(",", "."))
+        cK2.metric("Página atual", value=f"{fcfg['page_idx']+1}/{total_pages}")
+        if "DATA" in df_disp.columns:
+            datas_validas = pd.to_datetime(df_disp["DATA"], errors="coerce").dt.date.dropna()
             if not datas_validas.empty:
-                st.caption(
-                    f"Exibindo **{total_filtrado}** registro(s). "
-                    f"Primeira data: **{datas_validas.min()}** — Última data: **{datas_validas.max()}**."
-                )
+                cK3.metric("1ª Data", value=str(datas_validas.min()))
+                cK4.metric("Últ. Data", value=str(datas_validas.max()))
             else:
-                st.caption(f"Exibindo **{total_filtrado}** registro(s).")
+                cK3.metric("1ª Data", value="—")
+                cK4.metric("Últ. Data", value="—")
         else:
-            st.caption(f"Exibindo **{total_filtrado}** registro(s).")
+            cK3.metric("1ª Data", value="—")
+            cK4.metric("Últ. Data", value="—")
 
-        st.markdown("**Colunas visíveis**")
-        final_labels_order = list(df_disp_filtrado.columns)
+        st.divider()
 
-        vis_key = "__cols_visiveis_labels__"
-        if vis_key not in st.session_state:
-            st.session_state[vis_key] = set(final_labels_order)
-        else:
-            st.session_state[vis_key] = {lbl for lbl in st.session_state[vis_key] if lbl in final_labels_order}
-            if not st.session_state[vis_key]:
-                st.session_state[vis_key] = set(final_labels_order)
-
-        def render_columns_selector(title: str, labels: List[str], state_key: str):
-            container_supported = hasattr(st, "popover")
-            ctx_mgr = st.popover(title) if container_supported else st.expander(title, expanded=False)
-            with ctx_mgr:
-                st.write("Marque as colunas que deseja **exibir**:")
-                ac1, ac2 = st.columns(2)
-                if ac1.button("Selecionar tudo"):
-                    st.session_state[state_key] = set(labels)
-                if ac2.button("Limpar"):
-                    st.session_state[state_key] = set()
-
-                left, right = st.columns(2)
-                half = (len(labels) + 1) // 2
-                for i, lbl in enumerate(labels):
-                    col = left if i < half else right
-                    checked = lbl in st.session_state[state_key]
-                    new_val = col.checkbox(lbl, value=checked, key=f"__chk_col_{state_key}_{lbl}")
-                    if new_val and lbl not in st.session_state[state_key]:
-                        st.session_state[state_key].add(lbl)
-                    if (not new_val) and (lbl in st.session_state[state_key]):
-                        st.session_state[state_key].discard(lbl)
-
-        render_columns_selector("⚙️ Definir colunas", final_labels_order, vis_key)
-
-        visible_labels_sorted = [lbl for lbl in final_labels_order if lbl in st.session_state[vis_key]]
-        if not visible_labels_sorted:
-            st.warning("Nenhuma coluna selecionada. Selecione pelo menos uma para visualizar a tabela.")
-        else:
-            st.dataframe(df_disp_filtrado[visible_labels_sorted], use_container_width=True)
-
-        cexp1, cexp2 = st.columns([1, 1])
-        csv_data = df_disp_filtrado.to_csv(index=False).encode("utf-8-sig")
-        cexp1.download_button("⬇️ Exportar CSV (filtrados)", data=csv_data, file_name="registros_filtrados.csv")
-        xlsx_all = _df_to_excel_bytes(df_disp_filtrado)
-        if xlsx_all:
-            cexp2.download_button("⬇️ Exportar Excel (filtrados)", data=xlsx_all, file_name="registros_filtrados.xlsx")
+        # Seletor de colunas visíveis (labels)
+        if df_disp.empty:
+            st.info("Nenhum registro para os filtros aplicados.")
         else:
-            cexp2.caption("Excel indisponível (openpyxl ausente).")
+            st.markdown("**Colunas visíveis**")
+            all_labels = list(df_disp.columns)
+            vis_key = "__cols_visiveis_labels__"
+            if vis_key not in st.session_state:
+                st.session_state[vis_key] = set(all_labels)
+            else:
+                # saneamento se schema mudar
+                st.session_state[vis_key] = {lbl for lbl in st.session_state[vis_key] if lbl in all_labels}
+                if not st.session_state[vis_key]:
+                    st.session_state[vis_key] = set(all_labels)
+
+            def render_columns_selector(title: str, labels: List[str], state_key: str):
+                container_supported = hasattr(st, "popover")
+                ctx_mgr = st.popover(title) if container_supported else st.expander(title, expanded=False)
+                with ctx_mgr:
+                    st.write("Marque as colunas que deseja **exibir**:")
+                    ac1, ac2 = st.columns(2)
+                    if ac1.button("Selecionar tudo", key="__btn_sel_all_cols__"):
+                        st.session_state[state_key] = set(labels)
+                    if ac2.button("Limpar", key="__btn_clear_cols__"):
+                        st.session_state[state_key] = set()
+
+                    left, right = st.columns(2)
+                    half = (len(labels) + 1) // 2
+                    for i, lbl in enumerate(labels):
+                        col = left if i < half else right
+                        checked = lbl in st.session_state[state_key]
+                        new_val = col.checkbox(lbl, value=checked, key=f"__chk_col_{state_key}_{lbl}")
+                        if new_val and lbl not in st.session_state[state_key]:
+                            st.session_state[state_key].add(lbl)
+                        if (not new_val) and (lbl in st.session_state[state_key]):
+                            st.session_state[state_key].discard(lbl)
+
+            render_columns_selector("⚙️ Definir colunas", all_labels, vis_key)
+            visible_labels_sorted = [lbl for lbl in all_labels if lbl in st.session_state[vis_key]]
+
+            st.dataframe(
+                df_disp[visible_labels_sorted],
+                use_container_width=True,
+                hide_index=True
+            )
+
+            # Exportações — página e todos filtrados
+            st.divider()
+            cexp1, cexp2, cexp3 = st.columns([1, 1, 2])
+
+            # Exportar somente a página atual
+            csv_page = df_disp[visible_labels_sorted].to_csv(index=False).encode("utf-8-sig")
+            cexp1.download_button("⬇️ CSV (página)", data=csv_page, file_name="registros_pagina.csv")
+
+            xlsx_page = _df_to_excel_bytes(df_disp[visible_labels_sorted])
+            if xlsx_page:
+                cexp2.download_button("⬇️ Excel (página)", data=xlsx_page, file_name="registros_pagina.xlsx")
+            else:
+                cexp2.caption("Excel indisponível (openpyxl ausente).")
+
+            # Exportar TODOS os filtrados (sem paginação)
+            with cexp3:
+                st.caption("Exportar **todos** os registros filtrados")
+                do_export_all = st.button("⬇️ Gerar arquivo completo", key="__btn_export_all__")
+                if do_export_all:
+                    db = _get_db()
+                    try:
+                        q_all, _tot = _apply_filters_build_query(db, fcfg)
+                        # CUIDADO com bases muito grandes
+                        MAX_EXCEL = 150_000  # limite de segurança p/ Excel
+                        rows_all = q_all.all()
+                        df_all_base = _rows_to_dataframe(rows_all)
+                        df_all_disp = _format_display_df(df_all_base)
+
+                        csv_all = df_all_disp.to_csv(index=False).encode("utf-8-sig")
+                        st.download_button("⬇️ Baixar CSV (completo)", data=csv_all, file_name="registros_filtrados_completo.csv", key="__dl_csv_all__")
+
+                        if len(df_all_disp) <= MAX_EXCEL:
+                            xlsx_all = _df_to_excel_bytes(df_all_disp)
+                            if xlsx_all:
+                                st.download_button("⬇️ Baixar Excel (completo)", data=xlsx_all, file_name="registros_filtrados_completo.xlsx", key="__dl_xlsx_all__")
+                            else:
+                                st.caption("Excel indisponível (openpyxl ausente).")
+                        else:
+                            st.warning(f"A exportação completa em Excel foi limitada a {MAX_EXCEL:,} linhas. Use o CSV para volumes maiores.")
+                    finally:
+                        db.close()
 
     # ------------------ RELATÓRIOS ------------------
     with aba_rel:
@@ -1789,7 +2094,6 @@ def main():
                 "Aprovado": "SIM" if getattr(r, "aprovado", None) is True else ("NÃO" if getattr(r, "aprovado", None) is False else "N/A"),
                 "SKU": getattr(r, "qtd_sku", None),
                 "Tipo de Operação": getattr(r, "tipo_operacao", None),
-                # Removido campo "Divergência" genérico — não faz parte do layout oficial
             })
         dr = pd.DataFrame(rows)