ui/chunking_comparison_tab.py

"""
Aba de Comparação de Estratégias de Chunking
Permite testar e comparar diferentes métodos de chunking
"""
import gradio as gr
from src.chunking import compare_chunking_strategies, get_chunk_stats


def create_chunking_comparison_tab():
    """Cria aba de comparação de estratégias de chunking"""

    with gr.Tab("Comparação de Chunking"):
        gr.Markdown("""
        ## Comparação de Estratégias de Chunking

        Experimente diferentes estratégias de chunking no mesmo texto para entender o impacto de cada abordagem.

        **Estratégias disponíveis:**
        - **Tamanho Fixo**: Divide em chunks de tamanho fixo com overlap
        - **Por Sentenças**: Respeita limites de sentenças
        - **Semântico**: Agrupa por parágrafos mantendo coerência
        - **Recursivo**: Hierarquia de separadores (parágrafos → sentenças → palavras)
        """)

        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("### Configuração")

                sample_text = gr.Textbox(
                    label="Texto para Análise",
                    placeholder="Cole ou digite o texto que deseja dividir em chunks...",
                    lines=15,
                    max_lines=20
                )

                chunk_size_compare = gr.Slider(
                    minimum=200,
                    maximum=2000,
                    value=500,
                    step=100,
                    label="Tamanho Máximo do Chunk"
                )

                compare_btn = gr.Button(
                    "Comparar Estratégias",
                    variant="primary",
                    size="lg",
                    elem_classes=["primary-button"]
                )

                gr.Markdown("""
                **Dicas:**
                - Textos mais longos mostram diferenças mais claras
                - Chunks menores = mais contextos, mas mais fragmentados
                - Chunks maiores = menos contextos, mais informação por chunk
                """)

            with gr.Column(scale=2):
                gr.Markdown("### Resultados da Comparação")

                comparison_summary = gr.Markdown("Aguardando comparação...")

                with gr.Tabs():
                    with gr.Tab("Tamanho Fixo"):
                        fixed_stats = gr.JSON(label="Estatísticas")
                        fixed_chunks = gr.Textbox(
                            label="Chunks Gerados",
                            lines=10,
                            max_lines=15,
                            interactive=False
                        )

                    with gr.Tab("Por Sentenças"):
                        sentences_stats = gr.JSON(label="Estatísticas")
                        sentences_chunks = gr.Textbox(
                            label="Chunks Gerados",
                            lines=10,
                            max_lines=15,
                            interactive=False
                        )

                    with gr.Tab("Semântico"):
                        semantic_stats = gr.JSON(label="Estatísticas")
                        semantic_chunks = gr.Textbox(
                            label="Chunks Gerados",
                            lines=10,
                            max_lines=15,
                            interactive=False
                        )

                    with gr.Tab("Recursivo"):
                        recursive_stats = gr.JSON(label="Estatísticas")
                        recursive_chunks = gr.Textbox(
                            label="Chunks Gerados",
                            lines=10,
                            max_lines=15,
                            interactive=False
                        )

        # Função de comparação
        def compare_strategies(text, chunk_size_val):
            if not text or not text.strip():
                return (
                    "**Erro**: Por favor, forneça um texto para análise",
                    {}, "", {}, "", {}, "", {}, ""
                )

            try:
                results = compare_chunking_strategies(text, int(chunk_size_val))

                # Cria resumo
                summary_lines = ["## Resumo da Comparação\n"]
                summary_lines.append(f"**Texto original**: {len(text)} caracteres\n")
                summary_lines.append(f"**Tamanho máximo do chunk**: {chunk_size_val}\n")
                summary_lines.append("\n### Resultados por Estratégia:\n")

                for strategy, data in results.items():
                    if data["success"]:
                        stats = data["stats"]
                        summary_lines.append(
                            f"- **{strategy.title()}**: {stats['total_chunks']} chunks "
                            f"(média: {stats['avg_size']:.0f} chars)"
                        )
                    else:
                        summary_lines.append(f"- **{strategy.title()}**: Erro - {data.get('error', 'Desconhecido')}")

                summary = "\n".join(summary_lines)

                # Formata chunks para exibição
                def format_chunks(chunks):
                    if not chunks:
                        return "Nenhum chunk gerado"
                    formatted = []
                    for i, chunk in enumerate(chunks[:5]):  # Mostra primeiros 5
                        formatted.append(f"--- Chunk {i+1} ({len(chunk)} chars) ---\n{chunk}\n")
                    if len(chunks) > 5:
                        formatted.append(f"\n... e mais {len(chunks) - 5} chunks")
                    return "\n".join(formatted)

                # Extrai dados
                fixed_data = results.get("fixed", {})
                sentences_data = results.get("sentences", {})
                semantic_data = results.get("semantic", {})
                recursive_data = results.get("recursive", {})

                return (
                    summary,
                    fixed_data.get("stats", {}),
                    format_chunks(fixed_data.get("chunks", [])),
                    sentences_data.get("stats", {}),
                    format_chunks(sentences_data.get("chunks", [])),
                    semantic_data.get("stats", {}),
                    format_chunks(semantic_data.get("chunks", [])),
                    recursive_data.get("stats", {}),
                    format_chunks(recursive_data.get("chunks", []))
                )

            except Exception as e:
                error_msg = f"**Erro na comparação**: {str(e)}"
                return (error_msg, {}, "", {}, "", {}, "", {}, "")

        # Conecta evento
        compare_btn.click(
            fn=compare_strategies,
            inputs=[sample_text, chunk_size_compare],
            outputs=[
                comparison_summary,
                fixed_stats, fixed_chunks,
                sentences_stats, sentences_chunks,
                semantic_stats, semantic_chunks,
                recursive_stats, recursive_chunks
            ]
        )