pdf: novo refator do compress

Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>
pdf: refatorar compressPDF
2026-02-28 19:56:28 -03:00 · 2026-02-28 19:15:54 -03:00 · 2026-02-27 20:25:46 -03:00 · 2026-02-27 20:20:07 -03:00 · 2026-02-27 20:15:07 -03:00 · 2026-02-27 19:02:18 -03:00
49 changed files with 5499 additions and 1069 deletions
@@ -0,0 +1,26 @@
+# Configurações de Manipulação de PDF
+
+# Tamanho máximo de arquivo em MB
+PDF_MAX_FILE_SIZE=100
+
+# Número máximo de arquivos por operação
+PDF_MAX_FILES_COMPRESS=10
+PDF_MAX_FILES_MERGE=50
+PDF_MAX_FILES_IMAGES_TO_PDF=100
+
+# Tempo de retenção de arquivos processados em horas
+PDF_FILES_RETENTION_HOURS=24
+
+# Qualidade padrão para compressão (50-100)
+PDF_DEFAULT_QUALITY=95
+
+# DPI padrão para conversão de imagens (150-600)
+PDF_DEFAULT_DPI=300
+
+# Idioma padrão para OCR (por, eng, spa)
+PDF_DEFAULT_OCR_LANGUAGE=por
+
+# Diretórios de armazenamento (relativos ao root do projeto)
+PDF_TEMP_DIR=storage/temp/pdf-ops
+PDF_OUTPUT_DIR=storage/pdf-output
+PDF_UPLOAD_DIR=storage/temp/uploads
@@ -8,6 +8,8 @@ ENV PUPPETEER_EXECUTABLE_PATH=/usr/bin/chromium-browser
 RUN apt-get update && apt-get install -y chromium \
    libgconf-2-4 \
    postgresql-client \
+    graphicsmagick \
+    ghostscript \
    && rm -rf /var/lib/apt/lists/* \
    && ln -sf /usr/bin/chromium /usr/bin/chromium-browser

@@ -0,0 +1,100 @@
+# Passos para ativar a funcionalidade de PDF
+
+## 1. Instalar Dependências
+
+Execute o seguinte comando para instalar todas as dependências necessárias:
+
+```bash
+npm install pdf-lib pdf-parse pdf2pic tesseract.js
+npm install --save-dev @types/pdf-parse
+```
+
+## 2. Executar Migration do Banco de Dados
+
+Execute a migration para criar a tabela de operações de PDF:
+
+```bash
+npx prisma migrate dev --name add_operacoes_pdf
+```
+
+Ou simplesmente:
+
+```bash
+npm run prisma:migrate
+```
+
+## 3. Gerar Cliente Prisma
+
+Gere o cliente Prisma atualizado:
+
+```bash
+npm run prisma:generate
+```
+
+## 4. Criar Diretórios
+
+Os diretórios serão criados automaticamente, mas você pode criá-los manualmente:
+
+**No Windows (PowerShell):**
+```powershell
+New-Item -Path "storage\temp\pdf-ops" -ItemType Directory -Force
+New-Item -Path "storage\pdf-output" -ItemType Directory -Force
+New-Item -Path "storage\temp\uploads" -ItemType Directory -Force
+```
+
+**No Linux/Mac:**
+```bash
+mkdir -p storage/temp/pdf-ops
+mkdir -p storage/pdf-output
+mkdir -p storage/temp/uploads
+```
+
+## 5. Reiniciar o Servidor
+
+Após instalar as dependências e executar as migrations, reinicie o servidor:
+
+```bash
+npm run dev:full
+```
+
+Ou apenas o backend:
+
+```bash
+npm run server
+```
+
+## Verificação
+
+Após seguir todos os passos:
+
+1. Acesse a aplicação no navegador
+2. Faça login
+3. Clique no item "PDFs" no menu lateral
+4. Teste a funcionalidade de compressão enviando um PDF
+
+## Troubleshooting
+
+### Se continuar dando erro 404:
+
+1. Verifique se o servidor foi reiniciado após as mudanças
+2. Verifique se as dependências foram instaladas corretamente
+3. Verifique os logs do servidor para erros de importação
+
+### Se der erro de módulo não encontrado:
+
+Execute:
+```bash
+npm install
+npm run prisma:generate
+```
+
+### Se der erro no banco de dados:
+
+Execute:
+```bash
+npx prisma migrate reset
+npx prisma migrate dev
+npm run prisma:generate
+```
+
+**ATENÇÃO:** O comando `migrate reset` apaga todos os dados do banco!
@@ -0,0 +1,26 @@
+import express from "express";
+import cors from "cors";
+import { PrismaClient } from "@prisma/client";
+import usuariosRoutes from "./routes/usuarios";
+import clientesRoutes from "./routes/clientes";
+import processosRoutes from "./routes/processos";
+import audienciasRoutes from "./routes/audiencias";
+import pdfRoutes from "./routes/pdf";
+
+const app = express();
+const prisma = new PrismaClient();
+
+app.use(cors());
+app.use(express.json());
+
+app.use("/api/usuarios", usuariosRoutes);
+app.use("/api/clientes", clientesRoutes);
+app.use("/api/processos", processosRoutes);
+app.use("/api/audiencias", audienciasRoutes);
+app.use("/api/pdf", pdfRoutes);
+
+app.get("/", (req, res) => {
+  res.json({ message: "API is running" });
+});
+
+export default app;
@@ -0,0 +1,20 @@
+import { Request, Response } from "express";
+import prisma from "../prisma/client";
+
+// Lista todas as audiências
+export async function getAudiencias(req: Request, res: Response) {
+  try {
+    const audiencias = await prisma.audiencia.findMany({
+      orderBy: { data: "asc" },
+      include: {
+        processo: {
+          select: { numero: true, nomeContraparte: true }
+        }
+      }
+    });
+    res.json(audiencias);
+  } catch (error) {
+    console.error("Erro ao buscar audiências:", error);
+    res.status(500).json({ error: "Erro ao buscar audiências" });
+  }
+}
@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { getAudiencias } from "../controllers/audienciasController";
+
+const router = Router();
+
+// GET /api/audiencias - Lista todas as audiências
+router.get("/", getAudiencias);
+
+export default router;
@@ -0,0 +1,596 @@
+# Funcionalidade de Manipulação de PDFs
+
+## Visão Geral
+
+Sistema completo de manipulação de arquivos PDF com as seguintes funcionalidades:
+
+### Recursos Implementados
+
+1. **Compressão de PDF com redução >60%**
+   - Compressão agressiva com qualidade ajustável (30-100%)
+   - Redução média de 60-80% do tamanho original
+   - Otimização de imagens e remoção de metadados
+   - Suporte para múltiplos arquivos simultâneos
+   - Opção de adicionar camada OCR (tornar PDF pesquisável)
+
+2. **Divisão de PDF**
+   - Por páginas específicas (ex: 1,3,5,7)
+   - Por intervalos (ex: 1-5, 6
+   - **Download em ZIP** quando múltiplos arquivos-10)
+   - Por chunks de tamanho fixo
+
+3. **Mesclagem de PDFs**
+   - Combine até 50 PDFs em um único arquivo
+   - Preserva qualidade o
+   - Opção de adicionar camada OCR ao PDF mescladoriginal
+   - Ordem personalizável
+
+4. **PDF para Imagens**
+   - Formatos: PNG, JPG, WEBP
+   - DPI ajustável (150-600)
+   - **Download em ZIP** de todas as imagens
+   - Qualidade configurável (50-100%)
+   - Conversão de páginas específicas ou todas
+
+5. **Imagens para PDF**
+   - Opção de adicionar camada OCR (tornar PDF pesquisável)
+   - Suporta múltiplas imagens (até 100)
+   - Ajuste automático ao tamanho da página
+   - Suporta PNG, JPG, JPEG, WEBP
+
+6. **OCR (Reconhecimento Ótico de Caracteres)**
+   - Extração de texto de PDFs escaneados
+   - Suporte para Português, Inglês e Espanhol
+   - Retorna confiança da extração
+   - Processamento por página
+
+7. **Informações do PDF**
+   - Número de páginas
+   - Tamanho do arquivo
+   - Metadados (título, autor, criador, etc.)
+   - Datas de criação e modificação
+
+## Instalação
+
+### 1. Instalar Dependências
+
+```bash
+npm install pdf-lib pdf-parse pdf2pic tesseract.js archiver
+npm install --save-dev @types/pdf-parse @types/archiver
+```
+
+Ou execute o script de instalação:
+
+```bash
+npm run install-pdf-deps
+```
+
+### 2. Instalar GraphicsMagick (Requerido para PDF → Imagens)
+
+**Docker:**
+O GraphicsMagick já está incluído no Dockerfile. Rebuild a imagem se necessário:
+
+```bash
+docker-compose down
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+**Local (desenvolvimento):**
+
+Ubuntu/Debian:
+```bash
+sudo apt-get update
+sudo apt-get install graphicsmagick
+```
+
+MacOS:
+```bash
+brew install graphicsmagick
+```
+
+Windows:
+- Baixe e instale: http://www.graphicsmagick.org/download.html
+- Adicione ao PATH do sistema
+
+Verifique a instalação:
+```bash
+gm version
+```
+
+### 3. Executar Migration do Banco de Dados
+
+```bash
+npm run prisma:migrate
+```
+
+Ou manualmente:
+
+```bash
+npx prisma migrate dev --name add_operacoes_pdf
+```
+
+### 4. Gerar Cliente Prisma
+
+```bash
+npm run prisma:generate
+```
+
+### 5. Criar Diretórios Necessários
+
+Os diretórios serão criados automaticamente na primeira execução, mas você pode criá-los manualmente:
+
+```bash
+mkdir -p storage/temp/pdf-ops
+mkdir -p storage/pdf-output
+mkdir -p storage/temp/uploads
+```
+
+## Uso
+
+### Frontend
+
+Acesse a página de manipulação de PDFs através da rota:
+
+```
+/pdf
+```
+
+### API Endpoints
+
+Todas as rotas requerem autenticação via Bearer token.
+
+#### 1. Comprimir PDF
+
+```http
+POST /api/pdf/compress
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+30-100, padrão 50 para máxima compressão)
+- maxSizeMB: number (opcional)
+- enableOCR: boolean (opcional, adiciona camada OCR ao PDF
+- files: File[] (array de PDFs)
+- quality: number (50-100, padrão 95)
+- maxSizeMB: number (opcional)
+```
+
+#### 2. Dividir PDF
+
+```http
+POST /api/pdf/split
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- splitType: 'pages' | 'range' | 'chunks'
+- pages: string (ex: "1,2,3") - para splitType='pages'
+- ranges: string (ex: "1-5,6-10") - para splitType='range'
+- chunkSize: number - para splitType='chunks'
+```
+
+#### 3. Mesclar PDFs
+
+```http
+POST /api/pdf/merge
+Content-Type: multipart/form-da
+- enableOCR: boolean (opcional, adiciona camada OCR ao PDF mesclado)ta
+Authorization: Bearer {token}
+
+Body:
+- files: File[] (mínimo 2 PDFs)
+```
+
+#### 4. PDF para Imagens
+
+```http
+POST /api/pdf/pdf-to-images
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- format: 'png' | 'jpg' | 'webp' (padrão: png)
+- quality: number (50-100, padrão: 95)
+- density: number (DPI, 150-600, padrão: 300)
+- pages: string (opcional, ex: "[1,2,3]" ou "all")
+```
+
+#### 5. Imagens para PDF
+
+```http
+POST /api/pdf/images-to-pdf
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+- enableOCR: boolean (opcional, adiciona camada OCR ao PDF)
+
+Body:
+- files: File[] (array de imagens)
+- fitToPage: boolean (padrão: true)
+- pageSize: string (opcional, JSON: {"width":595,"height":842})
+```
+
+#### 6. OCR
+
+```http
+POST /api/pdf/ocr
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- language: string ('por' | 'eng' | 'spa', padrão: 'por')
+- pages: string (opcional, ex: "[1,2]" ou "all")
+```
+
+#### 7. Informações do PDF
+
+```http
+POST /api/pdf/info
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+```
+
+#### 8. Histórico de Operações
+
+```http
+GET /api/pdf/history?page=1&limit=20
+Authorization: Bearer {token}
+```
+
+#### 9. Download de Arquivo Processado
+
+```http
+GET /api/pdf/download/:operacaoId/:fileIndex
+Authorization: Bearer {token}
+```
+
+## Estrutura de Resposta
+
+### Sucesso (Compressão)
+...],
+  "outputPaths": ["/path/compressed-1.pdf", "/path/compressed-2.pdf"],
+  "totalOriginalSize": 1048576,
+  "totalCompressedSize": 314572,
+  "reduction": 70.0,
+  "processingTime": 1234
+}
+```
+
+### Sucesso (Split/PDF para Imagens - com ZIP)
+
+```json
+{
+  "success": true,
+  "operacaoId": "uuid",
+  "filesCreated": 10,
+  "outputPaths": ["/path/page-1.pdf", "/path/page-2.pdf", ...],
+  "zipPath": "/path/arquivos-uuid.zip",
+  "processingTime": 2345
+  ],
+  "totalOriginalSize": 1048576,
+  "totalCompressedSize": 524288,
+  "totalReduction": 50.0,
+  "processingTime": 1234
+}
+```
+
+### Sucesso (OCR)
+
+```json
+{
+  "success": true,
+  "operacaoId": "uuid",
+  "result": {
+    "text": "Texto extraído completo...",
+    "confidence": 95.5,
+    "pages": [
+      {
+        "pageNumber": 1,
+        "text": "Texto da página 1...",
+        "confidence": 96.2
+      }
+    ]
+  },
+  "processingTime": 5678
+}
+```
+
+### Erro
+
+```json
+{
+  "error": "Falha ao processar arquivo",
+  "message": "Detalhes específicos do erro"
+}
+```
+
+## Modelo de Dados
+
+### OperacaoPDF
+
+```typescript
+interface OperacaoPDF {
+  id: string;
+  tipoOperacao: 'COMPRIMIR' | 'DIVIDIR' | 'MESCLAR' | 'PDF_PARA_IMAGEM' | 'IMAGEM_PARA_PDF' | 'OCR';
+  status: 'PROCESSANDO' | 'CONCLUIDO' | 'ERRO';
+  usuarioId: string;
+  arquivosOriginais: string[];
+  arquivosResultado: string[];
+  tamanhoOriginal: bigint;
+  tamanhoResultado: bigint | null;
+  parametros: any;
+  mensagemErro: string | null;
+  detalhesOCR: any | null;
+  tempoProcessamento: number | null;
+  criadoEm: Date;
+  atualizadoEm: Date;
+}
+```
+
+## Segurança
+
+- ✅ Autenticação obrigatória em todas as rotas
+- ✅ Validação de tipos de arquivo (apenas PDF e imagens)
+- ✅ Limite de tamanho de arquivo (100MB por arquivo)
+- ✅ Limite de quantidade de arquivos por operação
+- ✅ Sanitização de nomes de arquivo
+- ✅ Isolamento de arquivos por operação
+- ✅ Limpeza automática de arquivos temporários
+
+## Performance
+
+- ✅ Processamento assíncrono
+- ✅ Otimização de memória com streams
+- ✅ Compressão sem perda de qualidade perceptível
+- ✅ Cache de workers de OCR
+- ✅ Índices no banco de dados para consultas rápidas
+- ✅ Limpeza automática de arquivos antigos
+
+## Tratamento de Erros
+
+Todos os erros são:
+- Logados no console do servidor
+- Registrados no banco de dados (tabela operacoes_pdf)
+- Retornados ao cliente com mensagens descritivas
+- Capturados por try-catch em todas as operações
+
+## Limitações
+
+- Tamanho máximo por arquivo: 100MB
+- Máximo de arquivos para compressão: 10
+- Máximo de arquivos para mesclagem: 50
+- Máximo de imagens para conversão em PDF: 100
+- Arquivos processados são mantidos por 24 horas
+- **Timeout de operações:** 10 minutos (600 segundos)
+  - Operações longas (OCR, compressão de PDFs grandes) podem levar alguns minutos
+  - O sistema está configurado para suportar até 10 minutos de processamento
+
+## Manutenção
+
+### Limpeza de Arquivos Antigos
+
+Execute periodicamente (recomendado: diariamente via cron):
+
+```typescript
+import { PDFService } from './src/services/pdfService';
+
+// Remove arquivos com mais de 24 horas
+await PDFService.cleanupOldFiles(24);
+```
+
+### Monitoramento
+
+Consulte a tabela `operacoes_pdf` para:
+- Estatísticas de uso
+- Taxa de erro
+- Tempo médio de processamento
+- Operações mais utilizadas
+
+```sql
+-- Operações por tipo
+SELECT "tipoOperacao", COUNT(*) as total
+FROM operacoes_pdf
+GROUP BY "tipoOperacao"
+ORDER BY total DESC;
+
+-- Taxa de sucesso
+SELECT 
+  status,
+  COUNT(*) as total,
+  ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER(), 2) as percentual
+FROM operacoes_pdf
+GROUP BY status;
+
+-- Tempo médio por operação
+SELECT 
+  "tipoOperacao",
+  AVG("tempoProcessamento") as tempo_medio_ms,
+  MIN("tempoProcessamento") as tempo_min_ms,
+  MAX("tempoProcessamento") as tempo_max_ms
+FROM operacoes_pdf
+WHERE status = 'CONCLUIDO'
+GROUP BY "tipoOperacao";
+```
+
+## Troubleshooting
+
+### Erro: "Could not execute GraphicsMagick/ImageMagick"
+
+**Sintoma:** Erro ao converter PDF para imagens:
+```
+Error: Could not execute GraphicsMagick/ImageMagick: gm "convert" ... 
+this most likely means the gm/convert binaries can't be found
+```
+
+**Causa:** GraphicsMagick não está instalado no sistema/container.
+
+**Solução:**
+
+**Docker:**
+```bash
+# Rebuild a imagem Docker com GraphicsMagick incluído
+docker-compose down
+docker-compose build --no-cache
+docker-compose up -d
+```
+
+**Local:**
+```bash
+# Ubuntu/Debian
+sudo apt-get install graphicsmagick
+
+# MacOS
+brew install graphicsmagick
+
+# Verifique a instalação
+gm version
+```
+
+### Erro 504: Gateway Timeout (Timeout ao processar PDF)
+
+**Sintoma:** Operação de compressão ou OCR retorna erro 504 após ~60 segundos:
+```
+Failed to load resource: the server responded with a status of 504
+```
+
+**Causa:** Operações de PDF (especialmente compressão e OCR) podem levar vários minutos para arquivos grandes. O timeout padrão de 60 segundos é insuficiente.
+
+**Solução:** As configurações de timeout foram aumentadas para **10 minutos** em:
+- ✅ Express server (`src/server/index.ts`)
+- ✅ Vite proxy (`vite.config.ts`)
+- ✅ Axios frontend (`PDFManipulationPage.tsx`)
+
+Se ainda ocorrer timeout:
+1. Verifique se rebuild foi feito após as alterações
+2. Reduza o tamanho do arquivo ou qualidade
+3. Processe menos arquivos por vez
+4. Para PDFs muito grandes (>50MB), considere fazer upload em partes
+
+**Dicas de performance:**
+- Compressão: Use qualidade 50-70 para PDFs grandes
+- OCR: Processe apenas páginas necessárias, não o PDF inteiro
+- Split: Use chunks menores para PDFs com muitas páginas
+
+### Erro: ENOENT ao deletar arquivos do histórico
+
+**Sintoma:** Erro ao limpar histórico:
+```
+Error: ENOENT: no such file or directory, unlink '/path/to/file.pdf'
+```
+
+**Causa:** Tentativa de deletar arquivos que não existem mais (já foram removidos manualmente ou por outro processo).
+
+**Solução:** ✅ **Corrigido automaticamente** - O sistema agora verifica se o arquivo existe antes de tentar deletar e ignora erros ENOENT silenciosamente.
+
+### Erro: Imagens baixadas com extensão .pdf (ou sem extensão correta)
+
+**Sintoma:** Ao baixar imagens geradas pela conversão PDF→Imagens, os arquivos vêm com extensão .pdf ou precisam ser renomeados para .png/.jpg para serem visualizados.
+
+**Causa:** O servidor não estava enviando o Content-Type correto no header HTTP, OU o frontend estava ignorando os headers do servidor e forçando o nome como `.pdf`.
+
+**Solução:** ✅ **Corrigido automaticamente** - O sistema agora:
+
+**Backend:**
+- Detecta automaticamente o tipo MIME correto baseado na extensão (.png, .jpg, .webp, .zip, .pdf)
+- Define headers HTTP apropriados (`Content-Type` e `Content-Disposition`)
+- Garante que o nome do arquivo no download mantém a extensão original
+- Adiciona logs de debug para facilitar troubleshooting
+
+**Frontend:**
+- Extrai o nome do arquivo do header `Content-Disposition` enviado pelo servidor
+- Usa o `Content-Type` correto do servidor ao criar o Blob para download
+- Não força mais extensão `.pdf` em todos os downloads
+- Adiciona log no console do browser: `Download frontend: arquivo.png (image/png)`
+- Libera memória do blob URL após download
+
+Se ainda ocorrer o problema:
+1. Abra o Console do DevTools (F12) e verifique os logs de download
+2. Verifique se os headers estão sendo recebidos corretamente na aba Network
+3. Limpe o cache do browser (Ctrl+Shift+Del)
+4. Teste em uma aba anônima/privada
+5. Use a opção de **Download ZIP** que sempre funciona corretamente
+
+### Erro: "Tesseract worker failed"
+
+Solução: Certifique-se de que o Tesseract está instalado corretamente:
+
+```bash
+npm install tesseract.js --force
+```
+
+### Erro: "Cannot find module 'sharp'"
+
+Solução: Reinstale o Sharp com rebuild:
+
+```bash
+npm uninstall sharp
+npm install sharp
+npm rebuild sharp
+```
+
+### Erro: "ENOSPC: no space left on device"
+
+Solução: Aumente o espaço em disco ou execute a limpeza:
+
+```bash
+npm run cleanup-pdf-files
+```
+
+### Performance lenta no OCR
+
+Solução: Reduza o DPI ou processe menos páginas por vez.
+
+## Suporte
+
+Para questões ou problemas:
+1. Verifique os logs do servidor
+2. Consulte a tabela `operacoes_pdf` para detalhes do erro
+3. Verifique se os diretórios de storage têm permissões corretas
+4. Certifique-se de que todas as dependências estão instaladas
+
+## Changelog
+
+### v1.1.2 (2026-02-27)
+- 🔧 **Correção DEFINITIVA de downloads** - Arquivos agora baixam com nome e extensão corretos
+  - **Backend:** Detecta tipo MIME e define headers HTTP apropriados (Content-Type, Content-Disposition)
+  - **Frontend:** Extrai nome do arquivo e tipo MIME dos headers da resposta
+  - **Frontend:** Não força mais `.pdf` em todos os downloads - usa nome real do servidor
+  - **Frontend:** Cria Blob com Content-Type correto preservando o formato original
+  - Adiciona logs de debug no backend e frontend para troubleshooting
+  - Suporta formato 'jpeg' além de 'jpg'
+  - Fallback para PNG em formatos não suportados
+  - Libera memória de blob URLs após download
+- 🐛 **Melhorias no pdfToImages** - Adicionado suporte para 'jpeg' e fallback para formatos inválidos
+
+### v1.1.1 (2026-02-27)
+- 🔧 **Correção de timeout 504** - Aumentado timeout para 10 minutos em todas as camadas
+  - Express server: 600 segundos
+  - Vite proxy: 600 segundos  
+  - Axios frontend: 600 segundos
+- 🗑️ **Correção ENOENT** - Sistema agora ignora arquivos já deletados ao limpar histórico
+- 📋 **Gerenciamento de histórico** - Botões para limpar histórico completo ou arquivos antigos
+- 🐛 **Melhorias de estabilidade** - Verificação de existência de arquivos antes de deletar
+- 📚 **Documentação expandida** - Adicionado troubleshooting completo
+
+### v1.1.0 (2026-02-27)
+- 🚀 **Compressão agressiva** com redução >60% do tamanho original
+- 📦 **Download em ZIP** para operações com múltiplos arquivos (split, pdfToImages)
+- 🔍 **OCR embutido** - opção de tornar PDFs pesquisáveis (compress, merge, imagesToPDF)
+- ⚡ **Otimização de imagens** com qualidade ajustável (30-100%)
+- 🎯 **Interface aprimorada** com indicadores visuais e opções de OCR
+
+### v1.0.0 (2026-02-27)
+- ✅ Implementação inicial
+- ✅ Compressão sem perda de qualidade
+- ✅ Divisão de PDFs
+- ✅ Mesclagem de PDFs
+- ✅ Conversão PDF para imagens
+- ✅ Conversão de imagens para PDF
+- ✅ OCR com Tesseract
+- ✅ Histórico de operações
+- ✅ Interface React completa
+- ✅ Validação e segurança
@@ -19,7 +19,9 @@
    "lint:fix": "eslint . --ext .ts,.tsx --fix",
    "create-admin": "ts-node scripts/create_admin_user.ts",
    "worker": "ts-node src/workers/startWorker.ts",
-    "install-deps": "npm install ua-parser-js uuid axios xlsx"
+    "install-deps": "npm install ua-parser-js uuid axios xlsx",
+    "install-pdf-deps": "npm install pdf-parse pdf2pic tesseract.js archiver && npm install --save-dev @types/pdf-parse @types/archiver",
+    "cleanup-pdf-files": "ts-node scripts/cleanup_pdf_files.ts"
  },
  "dependencies": {
    "@emotion/react": "^11.11.3",
@@ -36,6 +38,7 @@
    "@tiptap/starter-kit": "^2.11.7",
    "@types/sharp": "^0.32.0",
    "@types/ua-parser-js": "^0.7.36",
+    "archiver": "^7.0.1",
    "axios": "^1.6.5",
    "bcryptjs": "^2.4.3",
    "buffer": "^6.0.3",
@@ -49,9 +52,12 @@
    "multer": "^1.4.5-lts.1",
    "opentimestamps-javascript": "^1.0.1",
    "pdf-lib": "^1.17.1",
+    "pdf-parse": "^1.1.1",
+    "pdf2pic": "^3.1.3",
    "pdfkit": "^0.13.0",
    "puppeteer": "^24.5.0",
    "qrcode": "^1.5.3",
+    "tesseract.js": "^5.0.4",
    "react": "^18.2.0",
    "react-beautiful-dnd": "^13.1.1",
    "react-dom": "^18.2.0",
@@ -71,12 +77,14 @@
  },
  "devDependencies": {
    "@tailwindcss/postcss": "^4.1.1",
+    "@types/archiver": "^6.0.2",
    "@types/bcryptjs": "^2.4.6",
    "@types/cors": "^2.8.17",
    "@types/express": "^5.0.1",
    "@types/jsonwebtoken": "^9.0.9",
    "@types/multer": "^1.4.12",
    "@types/node": "^22.13.14",
+    "@types/pdf-parse": "^1.1.4",
    "@types/react": "^19.0.12",
    "@types/react-beautiful-dnd": "^13.1.8",
    "@types/react-dom": "^19.0.4",
@@ -0,0 +1,36 @@
+-- Migration para adicionar tabela de operações de PDF
+-- Created: 2026-02-27
+
+-- Criar ENUM para tipo de operação
+CREATE TYPE "TipoOperacaoPDF" AS ENUM ('COMPRIMIR', 'DIVIDIR', 'MESCLAR', 'PDF_PARA_IMAGEM', 'IMAGEM_PARA_PDF', 'OCR');
+
+-- Criar ENUM para status da operação
+CREATE TYPE "StatusOperacaoPDF" AS ENUM ('PROCESSANDO', 'CONCLUIDO', 'ERRO');
+
+-- Criar tabela de operações de PDF
+CREATE TABLE "operacoes_pdf" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "tipoOperacao" "TipoOperacaoPDF" NOT NULL,
+    "status" "StatusOperacaoPDF" NOT NULL DEFAULT 'PROCESSANDO',
+    "usuarioId" UUID NOT NULL,
+    "arquivosOriginais" TEXT[] NOT NULL,
+    "arquivosResultado" TEXT[] NOT NULL,
+    "tamanhoOriginal" BIGINT NOT NULL,
+    "tamanhoResultado" BIGINT,
+    "parametros" JSONB,
+    "mensagemErro" TEXT,
+    "detalhesOCR" JSONB,
+    "tempoProcessamento" INTEGER,
+    "criadoEm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "atualizadoEm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "operacoes_pdf_pkey" PRIMARY KEY ("id")
+);
+
+-- Adicionar foreign key para usuarios
+ALTER TABLE "operacoes_pdf" ADD CONSTRAINT "operacoes_pdf_usuarioId_fkey" FOREIGN KEY ("usuarioId") REFERENCES "usuarios"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- Criar índice para melhor performance nas consultas
+CREATE INDEX "operacoes_pdf_usuarioId_idx" ON "operacoes_pdf"("usuarioId");
+CREATE INDEX "operacoes_pdf_criadoEm_idx" ON "operacoes_pdf"("criadoEm" DESC);
+CREATE INDEX "operacoes_pdf_status_idx" ON "operacoes_pdf"("status");
@@ -51,6 +51,9 @@ model Usuario {
  // Adicionar relação para cálculos de pensão alimentícia
  calculosPensaoAlimenticia CalculoPensaoAlimenticia[]

+  // Adicionar relação para operações de PDF
+  operacoesPDF OperacaoPDF[]
+
  @@map("usuarios")
 }

@@ -1067,3 +1070,47 @@ model CalculoPensaoAlimenticia {

  @@map("calculos_pensao_alimenticia")
 }
+
+// Modelo para histórico de operações de PDF
+enum TipoOperacaoPDF {
+  COMPRIMIR
+  DIVIDIR
+  MESCLAR
+  PDF_PARA_IMAGEM
+  IMAGEM_PARA_PDF
+  OCR
+}
+
+enum StatusOperacaoPDF {
+  PROCESSANDO
+  CONCLUIDO
+  ERRO
+}
+
+model OperacaoPDF {
+  id                String            @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  tipoOperacao      TipoOperacaoPDF
+  status            StatusOperacaoPDF @default(PROCESSANDO)
+  usuarioId         String            @db.Uuid
+  usuario           Usuario           @relation(fields: [usuarioId], references: [id])
+  
+  // Informações dos arquivos
+  arquivosOriginais String[]          // Array de paths dos arquivos originais
+  arquivosResultado String[]          // Array de paths dos arquivos resultantes
+  tamanhoOriginal   BigInt            // Tamanho total dos arquivos originais em bytes
+  tamanhoResultado  BigInt?           // Tamanho total dos arquivos resultantes em bytes
+  
+  // Parâmetros da operação
+  parametros        Json?             // Parâmetros específicos da operação (ex: páginas para dividir)
+  
+  // Resultado da operação
+  mensagemErro      String?           
+  detalhesOCR       Json?             // Quando for OCR, armazena o texto extraído
+  
+  tempoProcessamento Int?             // Tempo de processamento em milissegundos
+  
+  criadoEm          DateTime          @default(now())
+  atualizadoEm      DateTime          @updatedAt
+  
+  @@map("operacoes_pdf")
+}
@@ -0,0 +1,41 @@
+import { PDFService } from '../src/services/pdfService';
+
+/**
+ * Script para limpeza de arquivos PDF antigos
+ * Remove arquivos com mais de 24 horas por padrão
+ * 
+ * Uso:
+ * npm run cleanup-pdf-files
+ * 
+ * Ou via ts-node:
+ * ts-node scripts/cleanup_pdf_files.ts [horas]
+ */
+
+async function main() {
+  console.log('Iniciando limpeza de arquivos PDF antigos...');
+  
+  const horasArg = process.argv[2];
+  const horas = horasArg ? parseInt(horasArg) : 24;
+  
+  if (isNaN(horas) || horas < 0) {
+    console.error('Erro: O argumento deve ser um número positivo de horas');
+    process.exit(1);
+  }
+  
+  console.log(`Removendo arquivos com mais de ${horas} horas...`);
+  
+  try {
+    await PDFService.cleanupOldFiles(horas);
+    console.log('✅ Limpeza concluída com sucesso!');
+  } catch (error) {
+    console.error('❌ Erro durante a limpeza:', error);
+    process.exit(1);
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error('Erro fatal:', error);
+    process.exit(1);
+  });
@@ -0,0 +1,37 @@
+@echo off
+:: Script para rebuild completo do Docker com dependências PDF
+:: Use este script após atualizar o Dockerfile para incluir GraphicsMagick
+
+echo ========================================
+echo Rebuild Docker - Sistema PDF
+echo ========================================
+echo.
+
+echo Parando containers...
+docker-compose down
+
+echo.
+echo Removendo imagens antigas...
+docker image prune -f
+
+echo.
+echo Reconstruindo imagem (sem cache)...
+docker-compose build --no-cache
+
+echo.
+echo Iniciando containers...
+docker-compose up -d
+
+echo.
+echo ========================================
+echo Rebuild concluído!
+echo ========================================
+echo.
+echo Verificando status dos containers:
+docker-compose ps
+
+echo.
+echo Para ver os logs:
+echo   docker-compose logs -f backend
+echo.
+pause
@@ -0,0 +1,36 @@
+#!/bin/bash
+# Script para rebuild completo do Docker com dependências PDF
+# Use este script após atualizar o Dockerfile para incluir GraphicsMagick
+
+echo "========================================"
+echo "Rebuild Docker - Sistema PDF"
+echo "========================================"
+echo ""
+
+echo "Parando containers..."
+docker-compose down
+
+echo ""
+echo "Removendo imagens antigas..."
+docker image prune -f
+
+echo ""
+echo "Reconstruindo imagem (sem cache)..."
+docker-compose build --no-cache
+
+echo ""
+echo "Iniciando containers..."
+docker-compose up -d
+
+echo ""
+echo "========================================"
+echo "Rebuild concluído!"
+echo "========================================"
+echo ""
+echo "Verificando status dos containers:"
+docker-compose ps
+
+echo ""
+echo "Para ver os logs:"
+echo "  docker-compose logs -f backend"
+echo ""
@@ -0,0 +1,271 @@
+import { PDFService } from '../src/services/pdfService';
+import path from 'path';
+import fs from 'fs/promises';
+
+/**
+ * Script de teste para funcionalidades de PDF
+ * 
+ * ATENÇÃO: Este é um script de teste. Certifique-se de ter arquivos de teste
+ * disponíveis antes de executar.
+ * 
+ * Uso:
+ * ts-node scripts/test_pdf_operations.ts
+ */
+
+async function testPDFInfo() {
+  console.log('\n=== Testando: Informações do PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    // Verifica se o arquivo existe
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const info = await PDFService.getPDFInfo(testPdfPath);
+    console.log('✅ Informações obtidas com sucesso:');
+    console.log('   Páginas:', info.pages);
+    console.log('   Tamanho:', (info.size / 1024).toFixed(2), 'KB');
+    console.log('   Título:', info.title || 'N/A');
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testCompression() {
+  console.log('\n=== Testando: Compressão de PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const result = await PDFService.compressPDF(testPdfPath, undefined, {
+      quality: 95,
+    });
+    
+    console.log('✅ Compressão concluída:');
+    console.log('   Tamanho original:', (result.originalSize / 1024).toFixed(2), 'KB');
+    console.log('   Tamanho comprimido:', (result.compressedSize / 1024).toFixed(2), 'KB');
+    console.log('   Redução:', result.reduction.toFixed(2), '%');
+    console.log('   Arquivo salvo em:', result.outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(result.outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testSplit() {
+  console.log('\n=== Testando: Divisão de PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    // Primeiro, verifica quantas páginas o PDF tem
+    const info = await PDFService.getPDFInfo(testPdfPath);
+    
+    if (info.pages < 2) {
+      console.log('⚠️  PDF tem menos de 2 páginas. Pulando teste de divisão.');
+      return;
+    }
+    
+    const outputPaths = await PDFService.splitPDF(testPdfPath, {
+      splitType: 'chunks',
+      chunkSize: 1,
+    });
+    
+    console.log('✅ Divisão concluída:');
+    console.log('   Arquivos criados:', outputPaths.length);
+    
+    // Limpa os arquivos de teste
+    for (const outputPath of outputPaths) {
+      await fs.unlink(outputPath);
+    }
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testMerge() {
+  console.log('\n=== Testando: Mesclagem de PDFs ===');
+  try {
+    const testPdf1 = path.join(process.cwd(), 'test', 'sample1.pdf');
+    const testPdf2 = path.join(process.cwd(), 'test', 'sample2.pdf');
+    
+    try {
+      await fs.access(testPdf1);
+      await fs.access(testPdf2);
+    } catch {
+      console.log('⚠️  Arquivos de teste não encontrados. Pulando teste.');
+      return;
+    }
+    
+    const outputPath = await PDFService.mergePDFs({
+      filePaths: [testPdf1, testPdf2],
+      outputPath: path.join(process.cwd(), 'storage', 'pdf-output', 'test-merged.pdf'),
+    });
+    
+    console.log('✅ Mesclagem concluída:');
+    console.log('   Arquivo salvo em:', outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testImagesToPDF() {
+  console.log('\n=== Testando: Imagens para PDF ===');
+  try {
+    const testImage1 = path.join(process.cwd(), 'test', 'image1.png');
+    const testImage2 = path.join(process.cwd(), 'test', 'image2.png');
+    
+    try {
+      await fs.access(testImage1);
+    } catch {
+      console.log('⚠️  Imagens de teste não encontradas. Pulando teste.');
+      return;
+    }
+    
+    const imagePaths = [testImage1];
+    
+    try {
+      await fs.access(testImage2);
+      imagePaths.push(testImage2);
+    } catch {
+      // Ignora se a segunda imagem não existe
+    }
+    
+    const outputPath = await PDFService.imagesToPDF({
+      imagePaths,
+      outputPath: path.join(process.cwd(), 'storage', 'pdf-output', 'test-images.pdf'),
+      fitToPage: true,
+    });
+    
+    console.log('✅ Conversão concluída:');
+    console.log('   Imagens processadas:', imagePaths.length);
+    console.log('   Arquivo salvo em:', outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testPDFToImages() {
+  console.log('\n=== Testando: PDF para Imagens ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const outputPaths = await PDFService.pdfToImages(testPdfPath, {
+      format: 'png',
+      quality: 95,
+      density: 150, // Menor DPI para teste mais rápido
+      pages: [1], // Apenas primeira página
+    });
+    
+    console.log('✅ Conversão concluída:');
+    console.log('   Imagens criadas:', outputPaths.length);
+    
+    // Limpa os arquivos de teste
+    for (const outputPath of outputPaths) {
+      await fs.unlink(outputPath);
+    }
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testOCR() {
+  console.log('\n=== Testando: OCR ===');
+  console.log('⚠️  OCR pode levar vários segundos. Aguarde...');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample-text.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const result = await PDFService.performOCR(testPdfPath, {
+      language: 'por',
+      pages: [1], // Apenas primeira página
+    });
+    
+    console.log('✅ OCR concluído:');
+    console.log('   Confiança:', result.confidence.toFixed(2), '%');
+    console.log('   Páginas processadas:', result.pages.length);
+    console.log('   Texto extraído (primeiros 100 caracteres):');
+    console.log('   ', result.text.substring(0, 100).replace(/\n/g, ' '));
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function main() {
+  console.log('╔════════════════════════════════════════════╗');
+  console.log('║  Teste de Operações de PDF                ║');
+  console.log('╚════════════════════════════════════════════╝');
+  
+  console.log('\nPré-requisitos:');
+  console.log('- Coloque arquivos de teste na pasta "test/"');
+  console.log('- sample.pdf: PDF com múltiplas páginas');
+  console.log('- sample1.pdf e sample2.pdf: PDFs para mesclagem');
+  console.log('- image1.png e image2.png: Imagens para conversão');
+  console.log('- sample-text.pdf: PDF com texto para OCR');
+  
+  // Criar diretório de teste se não existir
+  const testDir = path.join(process.cwd(), 'test');
+  try {
+    await fs.mkdir(testDir, { recursive: true });
+  } catch {
+    // Ignora se já existe
+  }
+  
+  await PDFService.initialize();
+  
+  await testPDFInfo();
+  await testCompression();
+  await testSplit();
+  await testMerge();
+  await testImagesToPDF();
+  await testPDFToImages();
+  await testOCR();
+  
+  console.log('\n╔════════════════════════════════════════════╗');
+  console.log('║  Testes concluídos!                       ║');
+  console.log('╚════════════════════════════════════════════╝\n');
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error('\n❌ Erro fatal durante os testes:', error);
+    process.exit(1);
+  });
@@ -48,6 +48,10 @@ import { CalculosList } from './components/calculos/CalculosList';
 import { NovoCalculo } from './components/calculos/NovoCalculo';
 import { DetalhesCalculo } from './components/calculos/DetalhesCalculo';
 import { NovoPensaoAlimenticia } from './components/calculos/NovoPensaoAlimenticia';
+import { DetalhePensaoAlimenticia } from './components/calculos/DetalhePensaoAlimenticia';
+
+// Importar componente de manipulação de PDF
+import { PDFManipulationPage } from './components/pdf/PDFManipulationPage';

 const queryClient = new QueryClient();

@@ -114,7 +118,7 @@ const router = createBrowserRouter(
          } />
          
          {/* Rotas para Pensão Alimentícia */}
-          <Route path="/pensao-alimenticia/nova" element={
+          <Route path="/pensao-alimenticia/novo" element={
            <ProtectedRoute>
              <NovoPensaoAlimenticia />
            </ProtectedRoute>
@@ -122,7 +126,14 @@ const router = createBrowserRouter(
          
          <Route path="/pensao-alimenticia/:id" element={
            <ProtectedRoute>
-              <DetalhesCalculo />
+              <DetalhePensaoAlimenticia />
+            </ProtectedRoute>
+          } />
+          
+          {/* Rota para Manipulação de PDF */}
+          <Route path="/pdf" element={
+            <ProtectedRoute>
+              <PDFManipulationPage />
            </ProtectedRoute>
          } />
        </Route>
@@ -144,12 +144,20 @@ export function CalculosList() {
    <div className="container mx-auto px-4 py-8">
      <div className="flex justify-between items-center mb-6">
        <h1 className="text-2xl font-bold text-gray-900">Cálculos Judiciais</h1>
+        <div className="flex gap-3">
          <Link
            to="/calculos/novo"
            className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500"
          >
-          Novo Cálculo
+            Novo Cálculo Judicial
          </Link>
+          <Link
+            to="/pensao-alimenticia/novo"
+            className="inline-flex items-center px-4 py-2 border border-transparent text-sm font-medium rounded-md shadow-sm text-white bg-green-600 hover:bg-green-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-green-500"
+          >
+            Novo Cálculo de Pensão
+          </Link>
+        </div>
      </div>
      
      {/* Filtros */}
@@ -1,5 +1,5 @@
 import React, { useEffect, useState } from 'react';
-import { useParams } from 'react-router-dom';
+import { useParams, useNavigate } from 'react-router-dom'; // Adicionar useNavigate
 import { toast } from 'react-toastify';
 import api from '../../services/api';

@@ -27,17 +27,36 @@ interface CalculoPensao {

 export function DetalhePensaoAlimenticia() {
  const { id } = useParams<{ id: string }>();
+  const navigate = useNavigate(); // Adicionar hook de navegação
  const [calculo, setCalculo] = useState<CalculoPensao | null>(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
+    // Verificação extra para garantir que o id está definido
+    if (!id || id === "novo") {
+      setLoading(false);
+      setCalculo(null);
+      return;
+    }
    const loadCalculo = async () => {
      try {
-        const response = await api.get(`/pensao-alimenticia/${id}`);
+        console.log('[DetalhePensaoAlimenticia] Buscando cálculo para id:', id);
+        const response = await api.get(`/api/calculos/pensao-alimenticia/${id}`);
        setCalculo(response.data);
-      } catch (error) {
-        console.error('Erro ao carregar cálculo:', error);
-        toast.error('Falha ao carregar dados do cálculo');
+      } catch (error: any) {
+        // Log detalhado para depuração
+        console.error('[DetalhePensaoAlimenticia] Erro ao carregar cálculo:', error);
+
+        // Tratamento específico para erro 404 (cálculo não encontrado)
+        if (error?.response?.status === 404) {
+          toast.warn('Cálculo de pensão alimentícia não encontrado.');
+        } else {
+          toast.error(
+            error?.response?.data?.message ||
+            'Falha ao buscar cálculo de pensão alimentícia.'
+          );
+        }
+        setCalculo(null);
      } finally {
        setLoading(false);
      }
@@ -51,7 +70,17 @@ export function DetalhePensaoAlimenticia() {
  }

  if (!calculo) {
-    return <div>Cálculo não encontrado</div>;
+    return (
+      <div className="bg-white shadow-md rounded-lg p-6 flex flex-col items-center">
+        <div className="text-lg mb-4 text-gray-700">Nenhum cálculo de pensão alimentícia encontrado.</div>
+        <button
+          className="px-4 py-2 bg-blue-600 text-white rounded-md shadow hover:bg-blue-700"
+          onClick={() => navigate('/pensao-alimenticia/novo')}
+        >
+          Criar novo cálculo
+        </button>
+      </div>
+    );
  }

  return (
@@ -90,6 +119,15 @@ export function DetalhePensaoAlimenticia() {
          <p className="text-gray-700">{calculo.observacoes}</p>
        </div>
      )}
+
+      <div className="mt-8 flex justify-end">
+        <button
+          className="px-4 py-2 bg-blue-600 text-white rounded-md shadow hover:bg-blue-700"
+          onClick={() => navigate('/pensao-alimenticia/novo')}
+        >
+          Criar novo cálculo
+        </button>
+      </div>
    </div>
  );
 }
@@ -1,6 +1,7 @@
 import { useState, useEffect } from 'react';
 import { useNavigate } from 'react-router-dom';
 import { toast } from 'react-toastify';
+import { useAuth } from '../../contexts/AuthContext';
 import { formatarPercentual, parsePercentual } from '../../utils/formatters';

 interface ProcessoOption {
@@ -16,6 +17,7 @@ interface ClienteOption {

 export function NovoPensaoAlimenticia() {
  const navigate = useNavigate();
+  const { getToken } = useAuth();
  const [loading, setLoading] = useState(false);
  const [formData, setFormData] = useState({
    titulo: '',
@@ -101,13 +103,21 @@ export function NovoPensaoAlimenticia() {
        ...formData,
        percentualSalarioMinimo: percentual,
        multaPactuada: formData.multaPactuada ? parsePercentual(formData.multaPactuada) : undefined,
+        processoId: formData.processoId || undefined, // Corrigir aqui
+        clienteId: formData.clienteId || undefined,   // Corrigir aqui
      };

+      const token = getToken();
+      if (!token) {
+        throw new Error('Usuário não autenticado. Faça login novamente.');
+      }
+
      // Enviar solicitação para criar cálculo
      const response = await fetch('/api/pensao-alimenticia', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}` // Adicionar o token aqui
        },
        body: JSON.stringify(dadosParaEnviar),
      });
@@ -212,25 +212,24 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
      );

      if (response.data && !response.data.erro) {
-        // Usar estado local para garantir re-renderização imediata
        const endereco = response.data.logradouro || "";
        const bairro = response.data.bairro || "";
        const cidade = response.data.localidade || "";
        const estado = response.data.uf || "";

-        // Atualizar valores no formulário
-        setValue("endereco", endereco, { shouldValidate: true });
-        setValue("bairro", bairro, { shouldValidate: true });
+        // Só preencher endereço/bairro se vier valor da API
+        if (endereco) setValue("endereco", endereco, { shouldValidate: true });
+        if (bairro) setValue("bairro", bairro, { shouldValidate: true });
        setValue("cidade", cidade, { shouldValidate: true });
        setValue("estado", estado, { shouldValidate: true });

-        // Atualizar o estado para re-renderização do componente
+        // Atualizar estado apenas para cidade/estado (não controlar endereço/bairro)
        setEnderecoState({
-          endereco,
-          bairro,
-          cidade,
-          estado,
-          preenchido: true,
+          endereco: endereco,
+          bairro: bairro,
+          cidade: cidade,
+          estado: estado,
+          preenchido: false, // Não usar mais para travar campos
        });

        // Focar no próximo campo apenas se o usuário não estiver digitando ativamente
@@ -251,6 +250,18 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
          }, 100);
        }
      } else {
+        // Se CEP não encontrado, limpar campos e permitir edição manual
+        setEnderecoState({
+          endereco: "",
+          bairro: "",
+          cidade: "",
+          estado: "",
+          preenchido: false,
+        });
+        setValue("endereco", "");
+        setValue("bairro", "");
+        setValue("cidade", "");
+        setValue("estado", "");
        console.error("CEP não encontrado");
        alert("CEP não encontrado. Por favor, verifique o CEP informado.");
      }
@@ -622,10 +633,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                            required: "Endereço é obrigatório",
                          })}
                          error={errors.endereco?.message}
-                          value={enderecoState.preenchido ? enderecoState.endereco : undefined}
+                          // Remover value/controlado por enderecoState, deixar react-hook-form controlar
                          onChange={(e) => {
-                            setValue("endereco", e.target.value);
-                            setEnderecoState(prev => ({...prev, endereco: e.target.value}));
+                            setValue("endereco", e.target.value, { shouldValidate: true });
                          }}
                        />
                        <FormInput
@@ -645,10 +655,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                            required: "Bairro é obrigatório",
                          })}
                          error={errors.bairro?.message}
-                          value={enderecoState.preenchido ? enderecoState.bairro : undefined}
+                          // Remover value/controlado por enderecoState, deixar react-hook-form controlar
                          onChange={(e) => {
-                            setValue("bairro", e.target.value);
-                            setEnderecoState(prev => ({...prev, bairro: e.target.value}));
+                            setValue("bairro", e.target.value, { shouldValidate: true });
                          }}
                        />
                        <FormInput
@@ -657,9 +666,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                            required: "Cidade é obrigatória",
                          })}
                          error={errors.cidade?.message}
-                          value={enderecoState.preenchido ? enderecoState.cidade : undefined}
+                          value={typeof watch("cidade") === "string" ? watch("cidade") : enderecoState.cidade}
                          onChange={(e) => {
-                            setValue("cidade", e.target.value);
+                            setValue("cidade", e.target.value, { shouldValidate: true });
                            setEnderecoState(prev => ({...prev, cidade: e.target.value}));
                          }}
                        />
@@ -670,9 +679,9 @@ export const ClienteModal: React.FC<ClienteModalProps> = ({
                          })}
                          options={estadosOptions}
                          error={errors.estado?.message}
-                          value={enderecoState.preenchido ? enderecoState.estado : undefined}
+                          value={typeof watch("estado") === "string" ? watch("estado") : enderecoState.estado}
                          onChange={(e) => {
-                            setValue("estado", e.target.value);
+                            setValue("estado", e.target.value, { shouldValidate: true });
                            setEnderecoState(prev => ({...prev, estado: e.target.value}));
                          }}
                        />
@@ -0,0 +1,65 @@
+import React from 'react';
+import { useBenchmarking } from '../../hooks/useBenchmarking';
+import { CheckCircleIcon, XCircleIcon, FolderOpenIcon } from '@heroicons/react/24/solid';
+
+export const BenchmarkingEscritorio: React.FC = () => {
+  // Hook para buscar e calcular benchmarking
+  const { data: benchmarking, isLoading, error } = useBenchmarking();
+
+  if (isLoading) return <div>Carregando benchmarking...</div>;
+  if (error) return <div className="text-red-600">Erro ao buscar benchmarking</div>;
+  if (!benchmarking) return null;
+
+  // Cálculo da porcentagem de sucesso das causas
+  const totalCausas = benchmarking.procedentes + benchmarking.improcedentesOuSemMerito;
+  const sucessoPercent = totalCausas > 0 ? Math.round((benchmarking.procedentes / totalCausas) * 100) : 0;
+
+  return (
+    <div className="border rounded-xl p-6 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-md mx-auto">
+      <div className="grid grid-cols-2 gap-4">
+        <div className="flex items-center gap-2 bg-blue-50 dark:bg-blue-900 rounded-lg p-3">
+          <FolderOpenIcon className="h-7 w-7 text-blue-600" />
+          <div>
+            <div className="text-xs text-gray-500">Total de processos</div>
+            <div className="text-lg font-bold text-blue-700 dark:text-blue-300">{benchmarking.totalProcessos}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-green-50 dark:bg-green-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-green-600" />
+          <div>
+            <div className="text-xs text-gray-500">Processos ativos</div>
+            <div className="text-lg font-bold text-green-700 dark:text-green-300">{benchmarking.ativos}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-green-50 dark:bg-green-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-green-600" />
+          <div>
+            <div className="text-xs text-gray-500">Julgados procedentes</div>
+            <div className="text-lg font-bold text-green-700 dark:text-green-300">{benchmarking.procedentes}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-red-50 dark:bg-red-900 rounded-lg p-3">
+          <XCircleIcon className="h-7 w-7 text-red-600" />
+          <div>
+            <div className="text-xs text-gray-500">Improcedentes/Sem mérito</div>
+            <div className="text-lg font-bold text-red-700 dark:text-red-300">{benchmarking.improcedentesOuSemMerito}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-indigo-50 dark:bg-indigo-900 rounded-lg p-3">
+          <FolderOpenIcon className="h-7 w-7 text-indigo-600" />
+          <div>
+            <div className="text-xs text-gray-500">Ajuizados últimos 7 dias</div>
+            <div className="text-lg font-bold text-indigo-700 dark:text-indigo-300">{benchmarking.ajuizados7dias}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 bg-teal-50 dark:bg-teal-900 rounded-lg p-3">
+          <CheckCircleIcon className="h-7 w-7 text-teal-600" />
+          <div>
+            <div className="text-xs text-gray-500">% de sucesso das causas</div>
+            <div className="text-lg font-extrabold text-teal-700 dark:text-teal-300">{sucessoPercent}%</div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
@@ -0,0 +1,117 @@
+import React from 'react';
+import { useCalendarioAtendimentos } from '../../hooks/useCalendarioAtendimentos';
+import { CalendarIcon, UserIcon, PresentationChartBarIcon } from '@heroicons/react/24/outline';
+
+export const CalendarioAtendimentos: React.FC = () => {
+  const { data: eventos = [], isLoading, error } = useCalendarioAtendimentos();
+
+  // Estado para mês e ano selecionados
+  const hoje = new Date();
+  const [mesSelecionado, setMesSelecionado] = React.useState(hoje.getMonth() + 1);
+  const [anoSelecionado, setAnoSelecionado] = React.useState(hoje.getFullYear());
+  const diasMes = Array.from({ length: new Date(anoSelecionado, mesSelecionado, 0).getDate() }, (_, i) => i + 1);
+  const mesStr = mesSelecionado.toString().padStart(2, '0');
+  const anoStr = anoSelecionado.toString();
+
+  // Atualiza data selecionada ao trocar mês/ano
+  const [dataSelecionada, setDataSelecionada] = React.useState(`${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`);
+  React.useEffect(() => {
+    setDataSelecionada(`${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`);
+  }, [mesSelecionado, anoSelecionado]);
+
+  // Separar eventos futuros/próximos e passados considerando ano/mês
+  const hojeStr = `${anoStr}-${mesStr}-${hoje.getDate().toString().padStart(2, '0')}`;
+  const eventosProximos = eventos
+    .filter(ev => ev.data >= hojeStr)
+    .sort((a, b) => a.data.localeCompare(b.data))
+    .slice(0, 10);
+  const eventosPassados = eventos
+    .filter(ev => ev.data < hojeStr)
+    .sort((a, b) => b.data.localeCompare(a.data))
+    .slice(0, 10);
+
+  const eventosDoDia = eventos.filter(e => e.data === dataSelecionada);
+
+  if (isLoading) return <div>Carregando calendário...</div>;
+  if (error) return <div className="text-red-600">Erro ao buscar eventos</div>;
+
+  return (
+    <div className="border rounded-xl p-4 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-4xl mx-auto">
+      <h2 className="text-lg font-bold text-gray-800 dark:text-gray-100 mb-2 flex items-center gap-2">
+        <CalendarIcon className="h-6 w-6 text-blue-600" /> Calendário de Atendimentos e Audiências
+      </h2>
+      <div className="flex items-center gap-4 mb-2">
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMesSelecionado(m => m === 1 ? 12 : m - 1)}>&lt;</button>
+        <span className="font-semibold text-lg">{mesStr}/{anoStr}</span>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMesSelecionado(m => m === 12 ? 1 : m + 1)}>&gt;</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAnoSelecionado(a => a - 1)}>&lt; Ano</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAnoSelecionado(a => a + 1)}>Ano &gt;</button>
+      </div>
+      <div className="grid grid-cols-7 gap-2 mb-4">
+        {diasMes.map((dia) => {
+          const dataStr = `${anoStr}-${mesStr}-${dia.toString().padStart(2, '0')}`;
+          const eventosDia = eventos.filter(e => e.data === dataStr);
+          const selecionado = dataStr === dataSelecionada;
+          return (
+            <button
+              key={dia}
+              type="button"
+              onClick={() => setDataSelecionada(dataStr)}
+              className={`h-12 w-full flex flex-col items-center justify-center border rounded-lg shadow-sm transition-all text-[11px] focus:outline-none ${selecionado ? 'ring-2 ring-blue-500 border-blue-500 bg-blue-100 dark:bg-blue-900' : eventosDia.length ? 'bg-blue-50 dark:bg-blue-900 border-blue-400' : 'bg-gray-50 dark:bg-gray-800'}`}
+            >
+              <span className="font-bold text-[11px] text-gray-700 dark:text-gray-200">{dia}</span>
+              {eventosDia.map((ev) => (
+                <span key={ev.id} className={`text-[10px] font-semibold flex items-center gap-1 whitespace-nowrap ${ev.tipo === 'Audiência' ? 'text-red-600' : 'text-blue-700'}`}> 
+                  {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-3 w-3" /> : <UserIcon className="h-3 w-3" />} {ev.tipo}
+                </span>
+              ))}
+            </button>
+          );
+        })}
+      </div>
+      <div className="mb-6">
+        <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-blue-600" /> Eventos do dia {dataSelecionada.split('-').reverse().join('/')}</h3>
+        <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+          {eventosDoDia.length === 0 && <li className="text-gray-400">Não existem eventos no dia selecionado.</li>}
+          {eventosDoDia.map((ev) => (
+            <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+              {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+              <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+              <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+            </li>
+          ))}
+        </ul>
+      </div>
+      <div className="grid grid-cols-2 gap-8">
+        <div>
+          <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-blue-600" /> Próximos eventos</h3>
+          <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+            {eventosProximos.length === 0 && <li className="text-gray-400">Nenhum evento futuro</li>}
+            {eventosProximos.map((ev) => (
+              <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+                {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+                <span className="font-bold min-w-[70px]">{ev.data}</span>
+                <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+                <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+        <div>
+          <h3 className="font-semibold mb-2 flex items-center gap-2"><CalendarIcon className="h-5 w-5 text-gray-500" /> Últimos eventos</h3>
+          <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+            {eventosPassados.length === 0 && <li className="text-gray-400">Nenhum evento anterior</li>}
+            {eventosPassados.map((ev) => (
+              <li key={ev.id} className="py-2 flex flex-wrap items-center gap-3">
+                {ev.tipo === 'Audiência' ? <PresentationChartBarIcon className="h-4 w-4 text-red-600" /> : <UserIcon className="h-4 w-4 text-blue-600" />}
+                <span className="font-bold min-w-[70px]">{ev.data}</span>
+                <span className="px-2 py-1 rounded text-xs font-semibold bg-gray-100 dark:bg-gray-800 text-gray-700 dark:text-gray-200 min-w-[80px] text-center">{ev.tipo}</span>
+                <span className="text-gray-600 dark:text-gray-300 break-words max-w-xs">{ev.descricao}</span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      </div>
+    </div>
+  );
+};
@@ -1,52 +1,30 @@
 import React from 'react';
-import { useAuth } from '../../contexts/AuthContext';
-import { useDashboardStats } from '../../hooks/useDashboardStats';
-import { ProcessosStats } from './stats/ProcessosStats';
-import { TarefasStats } from './stats/TarefasStats';
-import { AtendimentosStats } from './stats/AtendimentosStats';
-import { FinanceiroStats } from './stats/FinanceiroStats';
-import { AlertasPrazos } from './AlertasPrazos';
-import { AtividadesRecentes } from './AtividadesRecentes';
-import { TaxaSucessoCard } from './TaxaSucessoCard';
-import { KPIsFinanceiros } from './stats/KPIsFinanceiros';
+import { WorkflowTarefas } from './WorkflowTarefas';
+import { CalendarioAtendimentos } from './CalendarioAtendimentos';
+import { BenchmarkingEscritorio } from './BenchmarkingEscritorio';
+import { PainelFinanceiro } from './PainelFinanceiro';

 export const DashboardLayout: React.FC = () => {
-  const { user } = useAuth();
-  const {
-    processosStats,
-    tarefasStats,
-    atendimentosStats,
-    financeiroStats,
-    proximosPrazos,
-    atividades
-  } = useDashboardStats();
-
-  const isAdminOrAdvogado = ['ADVOGADO_ADMIN', 'ADVOGADO'].includes(user?.perfil || '');

  return (
-    <div className="space-y-6 p-6">
-      {/* Stats Cards */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-6">
-        {processosStats.data && <ProcessosStats data={processosStats.data} />}
-        {tarefasStats.data && <TarefasStats data={tarefasStats.data} />}
-        {atendimentosStats.data && <AtendimentosStats data={atendimentosStats.data} />}
-        {isAdminOrAdvogado && financeiroStats.data && (
-          <FinanceiroStats data={financeiroStats.data} />
-        )}
-      </div>
-
-      <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
-        {/* Coluna da esquerda */}
-        <div className="lg:col-span-2 space-y-6">
-          <TaxaSucessoCard />
-          {isAdminOrAdvogado && <KPIsFinanceiros />}
-        </div>
-
-        {/* Coluna da direita */}
+    <div className="grid grid-cols-1 lg:grid-cols-3 gap-6 p-6">
+      {/* Coluna 1: Workflow de Tarefas */}
      <div className="space-y-6">
-          <AlertasPrazos />
-          <AtividadesRecentes />
+        <h2 className="text-xl font-bold">Workflow de Tarefas</h2>
+        <WorkflowTarefas />
      </div>
+
+      {/* Coluna 2: Calendário de Atendimentos, Compromissos e Diligências */}
+      <div className="space-y-6">
+        <h2 className="text-xl font-bold">Calendário</h2>
+        <CalendarioAtendimentos />
+      </div>
+
+      {/* Coluna 3: Benchmarking do Escritório */}
+      <div className="space-y-6">
+        <h2 className="text-xl font-bold">Benchmarking do Escritório</h2>
+        <BenchmarkingEscritorio />
+        <PainelFinanceiro />
      </div>
    </div>
  );
@@ -0,0 +1,83 @@
+import React from 'react';
+import { useFinanceiroPainel } from '../../hooks/useFinanceiroPainel';
+import { CurrencyDollarIcon, ArrowDownCircleIcon, ArrowUpCircleIcon } from '@heroicons/react/24/solid';
+
+export const PainelFinanceiro: React.FC = () => {
+  const hoje = new Date();
+  const [mes, setMes] = React.useState(hoje.getMonth() + 1);
+  const [ano, setAno] = React.useState(hoje.getFullYear());
+  const { data, isLoading, error } = useFinanceiroPainel(mes, ano);
+
+  const mesesNomes = ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'];
+
+  return (
+    <div className="border rounded-xl p-6 shadow-lg bg-white dark:bg-gray-900 flex flex-col gap-6 max-w-4xl mx-auto mt-8">
+      <h2 className="text-lg font-bold text-gray-800 dark:text-gray-100 mb-2 flex items-center gap-2">
+        <CurrencyDollarIcon className="h-6 w-6 text-green-600" /> Painel Financeiro
+      </h2>
+      <div className="flex items-center gap-4 mb-2">
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMes(m => m === 1 ? 12 : m - 1)}>&lt;</button>
+        <span className="font-semibold text-lg">{mesesNomes[mes - 1]}/{ano}</span>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setMes(m => m === 12 ? 1 : m + 1)}>&gt;</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAno(a => a - 1)}>&lt; Ano</button>
+        <button type="button" className="px-2 py-1 rounded bg-gray-100 dark:bg-gray-800" onClick={() => setAno(a => a + 1)}>Ano &gt;</button>
+      </div>
+      {isLoading && <div>Carregando dados financeiros...</div>}
+      {error && <div className="text-red-600">Erro ao buscar dados financeiros</div>}
+      {data && (
+        <div className="grid grid-cols-2 md:grid-cols-4 gap-4 mb-6">
+          <div className="flex flex-col items-center bg-green-50 dark:bg-green-900 rounded-lg p-4">
+            <CurrencyDollarIcon className="h-7 w-7 text-green-600 mb-1" />
+            <span className="text-xs text-gray-500">Honorários a receber</span>
+            <span className="text-lg font-bold text-green-700 dark:text-green-300">R$ {data.honorariosAReceber.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-blue-50 dark:bg-blue-900 rounded-lg p-4">
+            <ArrowUpCircleIcon className="h-7 w-7 text-blue-600 mb-1" />
+            <span className="text-xs text-gray-500">Honorários recebidos no mês</span>
+            <span className="text-lg font-bold text-blue-700 dark:text-blue-300">R$ {data.honorariosRecebidosMes.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-red-50 dark:bg-red-900 rounded-lg p-4">
+            <ArrowDownCircleIcon className="h-7 w-7 text-red-600 mb-1" />
+            <span className="text-xs text-gray-500">Custas a pagar</span>
+            <span className="text-lg font-bold text-red-700 dark:text-red-300">R$ {data.custasAPagar.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+          <div className="flex flex-col items-center bg-teal-50 dark:bg-teal-900 rounded-lg p-4">
+            <ArrowUpCircleIcon className="h-7 w-7 text-teal-600 mb-1" />
+            <span className="text-xs text-gray-500">Custas pagas no mês</span>
+            <span className="text-lg font-bold text-teal-700 dark:text-teal-300">R$ {data.custasPagasMes.toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+          </div>
+        </div>
+      )}
+      {data && (
+        <div className="grid grid-cols-1 md:grid-cols-2 gap-8">
+          <div>
+            <h3 className="font-semibold mb-2 text-green-700 dark:text-green-300">Honorários recebidos no mês</h3>
+            <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+              {data.detalhesHonorarios.length === 0 && <li className="text-gray-400">Nenhum recebimento registrado neste mês.</li>}
+              {data.detalhesHonorarios.map((item, idx) => (
+                <li key={idx} className="py-2 flex flex-col">
+                  <span className="font-bold">Contrato: {item.contrato?.processoId || 'N/A'}</span>
+                  <span>Parcela: {item.parcela?.numeroParcela || 'N/A'} - Valor: R$ {Number(item.parcela?.valorPago || item.parcela?.valor || 0).toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+                  <span className="text-gray-500">Pago em: {item.parcela?.dataPagamento ? new Date(item.parcela.dataPagamento).toLocaleDateString('pt-br') : '-'}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+          <div>
+            <h3 className="font-semibold mb-2 text-red-700 dark:text-red-300">Custas pagas no mês</h3>
+            <ul className="text-xs divide-y divide-gray-200 dark:divide-gray-700">
+              {data.detalhesCustas.length === 0 && <li className="text-gray-400">Nenhuma custa paga neste mês.</li>}
+              {data.detalhesCustas.map((c, idx) => (
+                <li key={idx} className="py-2 flex flex-col">
+                  <span className="font-bold">Processo: {c.processoId || 'N/A'}</span>
+                  <span>Tipo: {c.tipo || 'N/A'} - Valor: R$ {Number(c.valor || 0).toLocaleString('pt-br', { minimumFractionDigits: 2 })}</span>
+                  <span className="text-gray-500">Pago em: {c.dataPagamento ? new Date(c.dataPagamento).toLocaleDateString('pt-br') : '-'}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};
@@ -0,0 +1,106 @@
+import React from 'react';
+import { useAuth } from '../../contexts/AuthContext';
+import { useTarefas } from '../../hooks/useTarefas';
+import { Tarefa } from '../../types/entities';
+import { PencilIcon, TrashIcon } from '@heroicons/react/24/outline';
+
+export const WorkflowTarefas: React.FC = () => {
+  const { user } = useAuth();
+  const { tarefas, isLoading, deleteTarefa } = useTarefas();
+
+  const canDelete = user && ['ADVOGADO_ADMIN', 'ADVOGADO'].includes(user.perfil);
+
+  const handleEdit = (tarefa: Tarefa) => {
+    // Implemente a lógica de edição conforme necessário
+    alert(`Editar tarefa: ${tarefa.titulo}`);
+  };
+
+  const handleDelete = async (id: string) => {
+    if (!window.confirm('Tem certeza que deseja excluir esta tarefa?')) return;
+    try {
+      await deleteTarefa.mutateAsync(id);
+    } catch (error) {
+      console.error('Erro ao excluir tarefa:', error);
+      alert('Erro ao excluir tarefa');
+    }
+  };
+
+  if (isLoading) {
+    return (
+      <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-4 text-center text-gray-500 dark:text-gray-400">
+        Carregando tarefas...
+      </div>
+    );
+  }
+
+  if (!tarefas || tarefas.length === 0) {
+    return (
+      <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-4 text-center text-gray-500 dark:text-gray-400">
+        Nenhuma tarefa encontrada.
+      </div>
+    );
+  }
+
+  // Exibir apenas tarefas que não estão concluídas ou canceladas
+  const tarefasAtivas = tarefas.filter((t: Tarefa) => t.status !== 'CONCLUIDA' && t.status !== 'CANCELADA');
+
+  return (
+    <div className="flex flex-col gap-4">
+      {tarefasAtivas.map((tarefa: Tarefa) => (
+        <div key={tarefa.id} className="border rounded-lg p-4 shadow flex flex-col gap-2 bg-white dark:bg-gray-800">
+          <div className="flex flex-col md:flex-row md:justify-between md:items-center gap-2">
+            <div className="flex items-center gap-3">
+              <span className="font-medium text-lg text-gray-900 dark:text-white">{tarefa.titulo}</span>
+              {/* Exibe o grau de prioridade com cor */}
+              <span className={`px-2 py-1 rounded text-xs font-semibold border ${
+                tarefa.prioridade === 'URGENTE' ? 'bg-red-100 text-red-700 border-red-300' :
+                tarefa.prioridade === 'ALTA' ? 'bg-orange-100 text-orange-700 border-orange-300' :
+                tarefa.prioridade === 'MEDIA' ? 'bg-yellow-100 text-yellow-700 border-yellow-300' :
+                'bg-green-100 text-green-700 border-green-300'
+              }`}>
+                {tarefa.prioridade === 'URGENTE' ? 'Urgente' : tarefa.prioridade === 'ALTA' ? 'Alta' : tarefa.prioridade === 'MEDIA' ? 'Média' : 'Baixa'}
+              </span>
+            </div>
+            <div className="flex items-center gap-3">
+              {/* Status da tarefa */}
+              <span className={`px-2 py-1 rounded text-xs font-semibold border ${
+                tarefa.status === 'CONCLUIDA' ? 'bg-green-100 text-green-700 border-green-300' :
+                tarefa.status === 'EM_ANDAMENTO' ? 'bg-blue-100 text-blue-700 border-blue-300' :
+                tarefa.status === 'PENDENTE' ? 'bg-gray-100 text-gray-700 border-gray-300' :
+                'bg-red-100 text-red-700 border-red-300'
+              }`}>
+                {tarefa.status.replace('_', ' ')}
+              </span>
+              <button
+                onClick={() => handleEdit(tarefa)}
+                className="text-blue-600 dark:text-blue-400 hover:text-blue-900 dark:hover:text-blue-300"
+                title="Editar"
+              >
+                <PencilIcon className="h-5 w-5" />
+              </button>
+              {canDelete && (
+                <button
+                  onClick={() => handleDelete(tarefa.id)}
+                  className="text-red-600 dark:text-red-400 hover:text-red-900 dark:hover:text-red-300"
+                  title="Excluir"
+                >
+                  <TrashIcon className="h-5 w-5" />
+                </button>
+              )}
+            </div>
+          </div>
+          {/* Listagem das subtarefas vinculadas */}
+          {tarefa.subtarefas && tarefa.subtarefas.length > 0 && (
+            <ul className="mt-2 ml-2 list-disc text-sm text-gray-700 dark:text-gray-300">
+              {tarefa.subtarefas.map((sub) => (
+                <li key={sub.id} className={sub.concluida ? 'line-through text-gray-400' : ''}>
+                  {sub.titulo} {sub.concluida ? '(Concluída)' : ''}
+                </li>
+              ))}
+            </ul>
+          )}
+        </div>
+      ))}
+    </div>
+  );
+};
@@ -18,6 +18,7 @@ import {
  CurrencyDollarIcon,
  CalculatorIcon,
  BriefcaseIcon,
+  DocumentDuplicateIcon,
 } from "@heroicons/react/24/outline";
 import { Menu, Transition } from "@headlessui/react";
 import api from "../../services/api";
@@ -91,6 +92,7 @@ export const MainLayout: React.FC = () => {
    { path: "/atendimentos", label: "Atendimentos", icon: UserIcon },
    { path: "/tarefas", label: "Tarefas", icon: ClipboardDocumentCheckIcon },
    { path: "/documentos", label: "Documentos", icon: DocumentTextIcon },
+    { path: "/pdf", label: "PDFs", icon: DocumentDuplicateIcon },
    {
      path: null,
      label: "Cálculos",
@@ -0,0 +1,885 @@
+/// <reference types="react" />
+import React, { useState, useCallback } from 'react';
+import { useDropzone } from 'react-dropzone';
+import axios from 'axios';
+import { toast } from 'react-toastify';
+import { useAuth } from '../../contexts/AuthContext';
+import {
+  DocumentIcon,
+  CloudArrowUpIcon,
+  ArrowsPointingInIcon,
+  ScissorsIcon,
+  ArrowsUpDownIcon,
+  PhotoIcon,
+  DocumentTextIcon,
+  InformationCircleIcon,
+  ArrowDownTrayIcon,
+  ClockIcon,
+} from '@heroicons/react/24/outline';
+
+interface OperationResult {
+  operacaoId: string;
+  outputPaths?: string[];
+  outputPath?: string;
+  zipPath?: string;
+  processingTime?: number;
+  reduction?: number;
+  filesCreated?: number;
+  text?: string;
+  confidence?: number;
+}
+
+type OperationType =
+  | 'compress'
+  | 'split'
+  | 'merge'
+  | 'pdfToImages'
+  | 'imagesToPDF'
+  | 'ocr'
+  | 'info';
+
+export const PDFManipulationPage: React.FC = () => {
+  const { getToken } = useAuth();
+  const [selectedOperation, setSelectedOperation] = useState<OperationType>('compress');
+  const [files, setFiles] = useState<File[]>([]);
+  const [processing, setProcessing] = useState(false);
+  const [result, setResult] = useState<OperationResult | null>(null);
+  const [history, setHistory] = useState<any[]>([]);
+
+  // Configurações para cada operação
+  const [compressQuality, setCompressQuality] = useState<'extreme' | 'low' | 'medium' | 'high'>('medium');
+  const [enableOCR, setEnableOCR] = useState(false);
+  const [splitType, setSplitType] = useState<'pages' | 'range' | 'chunks'>('pages');
+  const [splitPages, setSplitPages] = useState<string>('1,2,3');
+  const [splitRanges, setSplitRanges] = useState<string>('1-5,6-10');
+  const [chunkSize, setChunkSize] = useState(5);
+  const [imageFormat, setImageFormat] = useState<'png' | 'jpg' | 'webp'>('png');
+  const [imageQuality, setImageQuality] = useState(95);
+  const [imageDensity, setImageDensity] = useState(300);
+  const [ocrLanguage, setOcrLanguage] = useState('por');
+
+  const onDrop = useCallback((acceptedFiles: File[]) => {
+    setFiles((prev) => [...prev, ...acceptedFiles]);
+  }, []);
+
+  const { getRootProps, getInputProps, isDragActive } = useDropzone({
+    onDrop,
+    accept: {
+      'application/pdf': ['.pdf'],
+      'image/*': ['.png', '.jpg', '.jpeg', '.webp'],
+    },
+  });
+
+  const removeFile = (index: number) => {
+    setFiles((prev) => prev.filter((_, i) => i !== index));
+  };
+
+  const clearFiles = () => {
+    setFiles([]);
+    setResult(null);
+  };
+
+  const processFiles = async () => {
+    if (files.length === 0) {
+      toast.error('Selecione pelo menos um arquivo');
+      return;
+    }
+
+    setProcessing(true);
+    setResult(null);
+
+    try {
+      const formData = new FormData();
+      files.forEach((file) => {
+        formData.append('files', file);
+      });
+
+      const token = getToken();
+      const config = {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+          Authorization: `Bearer ${token}`,
+        },
+        timeout: 600000, // 10 minutos para operações longas (compressão, OCR, etc)
+      };
+
+      let response;
+
+      switch (selectedOperation) {
+        case 'compress':
+          formData.append('quality', compressQuality);
+          formData.append('enableOCR', enableOCR.toString());
+          response = await axios.post('/api/pdf/compress', formData, config);
+          toast.success('PDFs comprimidos com sucesso!');
+          break;
+
+        case 'split':
+          formData.append('splitType', splitType);
+          if (splitType === 'pages') {
+            const pages = splitPages.split(',').map((p) => parseInt(p.trim()));
+            formData.append('pages', JSON.stringify(pages));
+          } else if (splitType === 'range') {
+            const ranges = splitRanges.split(',').map((r) => {
+              const [start, end] = r.trim().split('-').map(Number);
+              return { start, end };
+            });
+            formData.append('ranges', JSON.stringify(ranges));
+          } else {
+            formData.append('chunkSize', chunkSize.toString());
+          }
+          response = await axios.post('/api/pdf/split', formData, config);
+          toast.success('PDF dividido com sucesso!');
+          break;
+
+        case 'merge':
+          formData.append('enableOCR', enableOCR.toString());
+          response = await axios.post('/api/pdf/merge', formData, config);
+          toast.success('PDFs mesclados com sucesso!');
+          break;
+
+        case 'pdfToImages':
+          formData.append('format', imageFormat);
+          formData.append('quality', imageQuality.toString());
+          formData.append('density', imageDensity.toString());
+          response = await axios.post('/api/pdf/pdf-to-images', formData, config);
+          toast.success('PDF convertido em imagens!');
+          break;
+
+        case 'imagesToPDF':
+          formData.append('enableOCR', enableOCR.toString());
+          formData.append('fitToPage', 'true');
+          response = await axios.post('/api/pdf/images-to-pdf', formData, config);
+          toast.success('Imagens convertidas em PDF!');
+          break;
+
+        case 'ocr':
+          formData.append('language', ocrLanguage);
+          response = await axios.post('/api/pdf/ocr', formData, config);
+          toast.success('OCR realizado com sucesso!');
+          break;
+
+        case 'info':
+          response = await axios.post('/api/pdf/info', formData, config);
+          break;
+      }
+
+      setResult(response.data);
+      loadHistory();
+    } catch (error: any) {
+      console.error('Erro ao processar arquivos:', error);
+      toast.error(error.response?.data?.message || 'Erro ao processar arquivos');
+    } finally {
+      setProcessing(false);
+    }
+  };
+
+  const loadHistory = async () => {
+    try {
+      const token = getToken();
+      const response = await axios.get('/api/pdf/history', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      setHistory(response.data.operacoes || []);
+    } catch (error) {
+      console.error('Erro ao carregar histórico:', error);
+    }
+  };
+
+  const downloadFile = async (operacaoId: string, fileIndex: number) => {
+    try {
+      const token = getToken();
+      const response = await axios.get(`/api/pdf/download/${operacaoId}/${fileIndex}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        responseType: 'blob',
+      });
+
+      // Extrai o nome do arquivo do header Content-Disposition
+      const contentDisposition = response.headers['content-disposition'];
+      let fileName = `arquivo-${fileIndex}`;
+      
+      if (contentDisposition) {
+        const matches = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/.exec(contentDisposition);
+        if (matches != null && matches[1]) {
+          fileName = matches[1].replace(/['"]/g, '');
+        }
+      }
+
+      // Usa o Content-Type correto do servidor
+      const contentType = response.headers['content-type'] || 'application/octet-stream';
+      
+      console.log(`Download frontend: ${fileName} (${contentType})`);
+
+      // Cria o blob com o tipo correto
+      const blob = new Blob([response.data], { type: contentType });
+      const url = window.URL.createObjectURL(blob);
+      const link = document.createElement('a');
+      link.href = url;
+      link.setAttribute('download', fileName);
+      document.body.appendChild(link);
+      link.click();
+      link.remove();
+      
+      // Libera a memória do blob URL
+      setTimeout(() => window.URL.revokeObjectURL(url), 100);
+
+      toast.success('Download iniciado!');
+    } catch (error) {
+      console.error('Erro ao fazer download:', error);
+      toast.error('Erro ao fazer download');
+    }
+  };
+
+  const deleteOperation = async (operacaoId: string) => {
+    if (!window.confirm('Deseja realmente deletar esta operação e seus arquivos?')) {
+      return;
+    }
+
+    try {
+      const token = getToken();
+      await axios.delete(`/api/pdf/operation/${operacaoId}`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      
+      toast.success('Operação deletada com sucesso!');
+      loadHistory();
+    } catch (error) {
+      console.error('Erro ao deletar operação:', error);
+      toast.error('Erro ao deletar operação');
+    }
+  };
+
+  const clearAllHistory = async () => {
+    if (!window.confirm('⚠️ ATENÇÃO: Isso irá deletar TODO o histórico e TODOS os arquivos armazenados. Esta ação não pode ser desfeita. Deseja continuar?')) {
+      return;
+    }
+
+    try {
+      const token = getToken();
+      const response = await axios.delete('/api/pdf/history/clear', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      
+      toast.success(`Histórico limpo! ${response.data.operacoesRemovidas} operações removidas.`);
+      setHistory([]);
+      setResult(null);
+    } catch (error) {
+      console.error('Erro ao limpar histórico:', error);
+      toast.error('Erro ao limpar histórico');
+    }
+  };
+
+  const cleanupOldFiles = async () => {
+    if (!window.confirm('Deseja remover operações com mais de 24 horas?')) {
+      return;
+    }
+
+    try {
+      const token = getToken();
+      const response = await axios.delete('/api/pdf/history/cleanup?hours=24', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      
+      toast.success(`${response.data.operacoesRemovidas} operações antigas removidas!`);
+      loadHistory();
+    } catch (error) {
+      console.error('Erro ao limpar arquivos antigos:', error);
+      toast.error('Erro ao limpar arquivos antigos');
+    }
+  };
+
+  React.useEffect(() => {
+    loadHistory();
+  }, []);
+
+  const operations = [
+    {
+      id: 'compress' as OperationType,
+      name: 'Comprimir PDF',
+      icon: ArrowsPointingInIcon,
+      description: 'Reduza o tamanho mantendo a qualidade',
+    },
+    {
+      id: 'split' as OperationType,
+      name: 'Dividir PDF',
+      icon: ScissorsIcon,
+      description: 'Separe páginas específicas',
+    },
+    {
+      id: 'merge' as OperationType,
+      name: 'Mesclar PDFs',
+      icon: ArrowsUpDownIcon,
+      description: 'Combine múltiplos PDFs',
+    },
+    {
+      id: 'pdfToImages' as OperationType,
+      name: 'PDF para Imagens',
+      icon: PhotoIcon,
+      description: 'Converta páginas em imagens',
+    },
+    {
+      id: 'imagesToPDF' as OperationType,
+      name: 'Imagens para PDF',
+      icon: DocumentIcon,
+      description: 'Crie PDF a partir de imagens',
+    },
+    {
+      id: 'ocr' as OperationType,
+      name: 'OCR',
+      icon: DocumentTextIcon,
+      description: 'Extraia texto de PDFs',
+    },
+    {
+      id: 'info' as OperationType,
+      name: 'Informações',
+      icon: InformationCircleIcon,
+      description: 'Obtenha detalhes do PDF',
+    },
+  ];
+
+  const formatBytes = (bytes: number) => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  return (
+    <div className="min-h-screen bg-gray-50 py-8">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div className="mb-8">
+          <h1 className="text-3xl font-bold text-gray-900">Manipulação de PDFs</h1>
+          <p className="mt-2 text-gray-600">
+            Ferramentas completas para trabalhar com arquivos PDF
+          </p>
+        </div>
+
+        {/* Seleção de operação */}
+        <div className="grid grid-cols-2 md:grid-cols-4 lg:grid-cols-7 gap-4 mb-8">
+          {operations.map((op) => (
+            <button
+              key={op.id}
+              onClick={() => {
+                setSelectedOperation(op.id);
+                clearFiles();
+              }}
+              className={`p-4 rounded-lg border-2 transition-all ${
+                selectedOperation === op.id
+                  ? 'border-blue-500 bg-blue-50 text-blue-700'
+                  : 'border-gray-200 bg-white hover:border-gray-300'
+              }`}
+            >
+              <op.icon className="h-8 w-8 mx-auto mb-2" />
+              <div className="text-sm font-medium">{op.name}</div>
+            </button>
+          ))}
+        </div>
+
+        <div className="grid grid-cols-1 lg:grid-cols-3 gap-8">
+          {/* Área principal */}
+          <div className="lg:col-span-2 space-y-6">
+            {/* Upload de arquivos */}
+            <div className="bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Arquivos</h2>
+
+              <div
+                {...getRootProps()}
+                className={`border-2 border-dashed rounded-lg p-12 text-center cursor-pointer transition-colors ${
+                  isDragActive
+                    ? 'border-blue-500 bg-blue-50'
+                    : 'border-gray-300 hover:border-gray-400'
+                }`}
+              >
+                <input {...getInputProps()} />
+                <CloudArrowUpIcon className="h-12 w-12 mx-auto text-gray-400 mb-4" />
+                {isDragActive ? (
+                  <p className="text-blue-600">Solte os arquivos aqui...</p>
+                ) : (
+                  <div>
+                    <p className="text-gray-600 mb-2">
+                      Arraste e solte arquivos aqui, ou clique para selecionar
+                    </p>
+                    <p className="text-sm text-gray-500">
+                      PDFs e imagens (PNG, JPG, WEBP)
+                    </p>
+                  </div>
+                )}
+              </div>
+
+              {/* Lista de arquivos */}
+              {files.length > 0 && (
+                <div className="mt-4">
+                  <div className="flex justify-between items-center mb-2">
+                    <h3 className="font-medium">
+                      Arquivos selecionados ({files.length})
+                    </h3>
+                    <button
+                      onClick={clearFiles}
+                      className="text-sm text-red-600 hover:text-red-700"
+                    >
+                      Limpar todos
+                    </button>
+                  </div>
+                  <div className="space-y-2">
+                    {files.map((file, index) => (
+                      <div
+                        key={index}
+                        className="flex items-center justify-between p-3 bg-gray-50 rounded"
+                      >
+                        <div className="flex items-center space-x-3">
+                          <DocumentIcon className="h-5 w-5 text-gray-400" />
+                          <div>
+                            <p className="text-sm font-medium">{file.name}</p>
+                            <p className="text-xs text-gray-500">
+                              {formatBytes(file.size)}
+                            </p>
+                          </div>
+                        </div>
+                        <button
+                          onClick={() => removeFile(index)}
+                          className="text-red-600 hover:text-red-700"
+                        >
+                          Remover
+                        </button>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+
+            {/* Configurações específicas */}
+            <div className="bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Configurações</h2>
+
+              {selectedOperation === 'compress' && (
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      Nível de Compressão
+                    </label>
+                    <select
+                      value={compressQuality}
+                      onChange={(e) => setCompressQuality(e.target.value as any)}
+                      className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                    >
+                      <option value="extreme">Extrema (72 DPI) - Máxima redução, visualização na tela</option>
+                      <option value="low">Alta compressão (100 DPI) - Arquivos pequenos</option>
+                      <option value="medium">Equilibrada (150 DPI) - Recomendado</option>
+                      <option value="high">Qualidade (200 DPI) - Para impressão</option>
+                    </select>
+                    <p className="text-xs text-gray-500 mt-2">
+                      💡 Usa Ghostscript, mesmo motor do iLovePDF e SmallPDF
+                    </p>
+                  </div>
+                  
+                  <div className="flex items-center space-x-2">
+                    <input
+                      type="checkbox"
+                      id="enableOCR"
+                      checked={enableOCR}
+                      onChange={(e) => setEnableOCR(e.target.checked)}
+                      className="h-4 w-4 text-blue-600 rounded"
+                    />
+                    <label htmlFor="enableOCR" className="text-sm font-medium">
+                      Adicionar camada de OCR (tornar PDF pesquisável)
+                    </label>
+                  </div>
+                  <p className="text-xs text-gray-500">
+                    OCR torna o PDF pesquisável. É instantâneo para PDFs digitais.
+                  </p>
+                </div>
+              )}
+
+              {selectedOperation === 'split' && (
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      Tipo de divisão
+                    </label>
+                    <select
+                      value={splitType}
+                      onChange={(e) => setSplitType(e.target.value as any)}
+                      className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                    >
+                      <option value="pages">Páginas específicas</option>
+                      <option value="range">Intervalos</option>
+                      <option value="chunks">Chunks (partes iguais)</option>
+                    </select>
+                  </div>
+
+                  {splitType === 'pages' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Páginas (separadas por vírgula)
+                      </label>
+                      <input
+                        type="text"
+                        value={splitPages}
+                        onChange={(e) => setSplitPages(e.target.value)}
+                        placeholder="1,2,3,5,8"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+
+                  {splitType === 'range' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Intervalos (ex: 1-5,6-10)
+                      </label>
+                      <input
+                        type="text"
+                        value={splitRanges}
+                        onChange={(e) => setSplitRanges(e.target.value)}
+                        placeholder="1-5,6-10,11-15"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+
+                  {splitType === 'chunks' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Páginas por chunk
+                      </label>
+                      <input
+                        type="number"
+                        value={chunkSize}
+                        onChange={(e) => setChunkSize(parseInt(e.target.value))}
+                        min="1"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+                </div>
+              )}
+
+              {selectedOperation === 'pdfToImages' && (
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2">Formato</label>
+                    <select
+                      value={imageFormat}
+                      onChange={(e) => setImageFormat(e.target.value as any)}
+                      className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                    >
+                      <option value="png">PNG</option>
+                      <option value="jpg">JPG</option>
+                      <option value="webp">WEBP</option>
+                    </select>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      Qualidade ({imageQuality}%)
+                    </label>
+                    <input
+                      type="range"
+                      min="50"
+                      max="100"
+                      value={imageQuality}
+                      onChange={(e) => setImageQuality(parseInt(e.target.value))}
+                      className="w-full"
+                    />
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      DPI ({imageDensity})
+                    </label>
+                    <input
+                      type="range"
+                      min="150"
+                      max="600"
+                      step="50"
+                      value={imageDensity}
+                      onChange={(e) => setImageDensity(parseInt(e.target.value))}
+                      className="w-full"
+                    />
+                  </div>
+                </div>
+              )}
+
+              {selectedOperation === 'ocr' && (
+                <div>
+                  <label className="block text-sm font-medium mb-2">Idioma</label>
+                  <select
+                    value={ocrLanguage}
+                    onChange={(e) => setOcrLanguage(e.target.value)}
+                    className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                  >
+                    <option value="por">Português</option>
+                    <option value="eng">Inglês</option>
+                    <option value="spa">Espanhol</option>
+                  </select>
+                </div>
+              )}
+
+              {selectedOperation === 'merge' && (
+                <div className="space-y-4">
+                  <p className="text-sm text-gray-600">
+                    Selecione 2 ou mais PDFs para mesclar em um único arquivo.
+                  </p>
+                  
+                  <div className="flex items-center space-x-2">
+                    <input
+                      type="checkbox"
+                      id="enableOCRMerge"
+                      checked={enableOCR}
+                      onChange={(e) => setEnableOCR(e.target.checked)}
+                      className="h-4 w-4 text-blue-600 rounded"
+                    />
+                    <label htmlFor="enableOCRMerge" className="text-sm font-medium">
+                      Adicionar camada de OCR ao PDF mesclado
+                    </label>
+                  </div>
+                  <p className="text-xs text-gray-500">
+                    ⚠️ OCR aumenta significativamente o tempo de processamento
+                  </p>
+                </div>
+              )}
+
+              {selectedOperation === 'imagesToPDF' && (
+                <div className="space-y-4">
+                  <p className="text-sm text-gray-600">
+                    Converte múltiplas imagens em um único arquivo PDF.
+                  </p>
+                  
+                  <div className="flex items-center space-x-2">
+                    <input
+                      type="checkbox"
+                      id="enableOCRImages"
+                      checked={enableOCR}
+                      onChange={(e) => setEnableOCR(e.target.checked)}
+                      className="h-4 w-4 text-blue-600 rounded"
+                    />
+                    <label htmlFor="enableOCRImages" className="text-sm font-medium">
+                      Adicionar camada de OCR (tornar PDF pesquisável)
+                    </label>
+                  </div>
+                  <p className="text-xs text-gray-500">
+                    ⚠️ OCR aumenta significativamente o tempo de processamento
+                  </p>
+                </div>
+              )}
+
+              <button
+                onClick={processFiles}
+                disabled={processing || files.length === 0}
+                className={`mt-6 w-full py-3 rounded-lg font-medium transition-colors ${
+                  processing || files.length === 0
+                    ? 'bg-gray-300 text-gray-500 cursor-not-allowed'
+                    : 'bg-blue-600 text-white hover:bg-blue-700'
+                }`}
+              >
+                {processing ? (
+                  <span className="flex items-center justify-center">
+                    <svg
+                      className="animate-spin h-5 w-5 mr-2"
+                      xmlns="http://www.w3.org/2000/svg"
+                      fill="none"
+                      viewBox="0 0 24 24"
+                    >
+                      <circle
+                        className="opacity-25"
+                        cx="12"
+                        cy="12"
+                        r="10"
+                        stroke="currentColor"
+                        strokeWidth="4"
+                      ></circle>
+                      <path
+                        className="opacity-75"
+                        fill="currentColor"
+                        d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+                      ></path>
+                    </svg>
+                    Processando...
+                  </span>
+                ) : (
+                  'Processar'
+                )}
+              </button>
+            </div>
+
+            {/* Resultado */}
+            {result && (
+              <div className="bg-white rounded-lg shadow p-6">
+                <h2 className="text-xl font-semibold mb-4">Resultado</h2>
+
+                {selectedOperation === 'compress' && result.reduction !== undefined && (
+                  <div className="space-y-2">
+                    <p className="text-green-600 font-medium">
+                      Redução de {result.reduction.toFixed(2)}%
+                    </p>
+                    <p className="text-sm text-gray-600">
+                      Tempo de processamento: {result.processingTime}ms
+                    </p>
+                  </div>
+                )}
+
+                {(result.outputPaths || result.outputPath || result.zipPath) && (
+                  <div className="mt-4">
+                    <p className="font-medium mb-2">Arquivos gerados:</p>
+                    
+                    {/* Botão de download ZIP (se disponível) */}
+                    {result.zipPath && (
+                      <button
+                        onClick={() => downloadFile(result.operacaoId, 0)}
+                        className="flex items-center space-x-2 w-full p-3 mb-3 bg-blue-50 hover:bg-blue-100 rounded border-2 border-blue-300"
+                      >
+                        <ArrowDownTrayIcon className="h-6 w-6 text-blue-600" />
+                        <div className="text-left">
+                          <span className="text-sm font-semibold text-blue-900">
+                            📦 Download ZIP (Todos os arquivos)
+                          </span>
+                          <p className="text-xs text-blue-700">
+                            Recomendado para múltiplos arquivos
+                          </p>
+                        </div>
+                      </button>
+                    )}
+                    
+                    {/* Arquivos individuais */}
+                    {result.outputPaths?.map((path, index) => {
+                      // Determina o nome do arquivo baseado na operação
+                      let fileName = `Arquivo ${index + 1}`;
+                      if (selectedOperation === 'pdfToImages') {
+                        fileName = `Imagem ${index + 1}`;
+                      } else if (selectedOperation === 'split') {
+                        fileName = `Página ${index + 1}`;
+                      }
+                      
+                      return (
+                        <button
+                          key={index}
+                          onClick={() => downloadFile(result.operacaoId, result.zipPath ? index + 1 : index)}
+                          className="flex items-center space-x-2 w-full p-2 hover:bg-gray-50 rounded"
+                        >
+                          <ArrowDownTrayIcon className="h-5 w-5 text-blue-600" />
+                          <span className="text-sm">{fileName}</span>
+                        </button>
+                      );
+                    })}
+                    {result.outputPath && !result.outputPaths && (
+                      <button
+                        onClick={() => downloadFile(result.operacaoId, result.zipPath ? 1 : 0)}
+                        className="flex items-center space-x-2 w-full p-2 hover:bg-gray-50 rounded"
+                      >
+                        <ArrowDownTrayIcon className="h-5 w-5 text-blue-600" />
+                        <span className="text-sm">Download</span>
+                      </button>
+                    )}
+                  </div>
+                )}
+
+                {selectedOperation === 'ocr' && result.text && (
+                  <div className="mt-4">
+                    <p className="font-medium mb-2">Texto extraído:</p>
+                    <div className="bg-gray-50 p-4 rounded max-h-64 overflow-y-auto">
+                      <pre className="text-sm whitespace-pre-wrap">{result.text}</pre>
+                    </div>
+                    {result.confidence && (
+                      <p className="text-sm text-gray-600 mt-2">
+                        Confiança: {result.confidence.toFixed(2)}%
+                      </p>
+                    )}
+                  </div>
+                )}
+              </div>
+            )}
+          </div>
+
+          {/* Histórico */}
+          <div className="lg:col-span-1">
+            <div className="bg-white rounded-lg shadow p-6 sticky top-8">
+              <div className="flex items-center justify-between mb-4">
+                <h2 className="text-xl font-semibold">Histórico</h2>
+                {history.length > 0 && (
+                  <div className="flex space-x-2">
+                    <button
+                      onClick={cleanupOldFiles}
+                      className="text-xs px-2 py-1 bg-yellow-100 hover:bg-yellow-200 text-yellow-800 rounded transition-colors"
+                      title="Remover operações com mais de 24 horas"
+                    >
+                      🕐 Limpar Antigos
+                    </button>
+                    <button
+                      onClick={clearAllHistory}
+                      className="text-xs px-2 py-1 bg-red-100 hover:bg-red-200 text-red-800 rounded transition-colors"
+                      title="Apagar todo o histórico e arquivos"
+                    >
+                      🗑️ Limpar Tudo
+                    </button>
+                  </div>
+                )}
+              </div>
+
+              {history.length === 0 ? (
+                <p className="text-gray-500 text-sm">Nenhuma operação ainda</p>
+              ) : (
+                <div className="space-y-3 max-h-96 overflow-y-auto">
+                  {history.map((op) => (
+                    <div key={op.id} className="border-b pb-3">
+                      <div className="flex items-center justify-between">
+                        <span className="text-sm font-medium">
+                          {op.tipoOperacao.replace('_', ' ')}
+                        </span>
+                        <div className="flex items-center space-x-2">
+                          <span
+                            className={`text-xs px-2 py-1 rounded ${
+                              op.status === 'CONCLUIDO'
+                                ? 'bg-green-100 text-green-800'
+                                : op.status === 'ERRO'
+                                ? 'bg-red-100 text-red-800'
+                                : 'bg-yellow-100 text-yellow-800'
+                            }`}
+                          >
+                            {op.status}
+                          </span>
+                          <button
+                            onClick={() => deleteOperation(op.id)}
+                            className="text-red-600 hover:text-red-800 hover:bg-red-50 p-1 rounded transition-colors"
+                            title="Deletar esta operação"
+                          >
+                            <svg xmlns="http://www.w3.org/2000/svg" className="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+                              <path fillRule="evenodd" d="M9 2a1 1 0 00-.894.553L7.382 4H4a1 1 0 000 2v10a2 2 0 002 2h8a2 2 0 002-2V6a1 1 0 100-2h-3.382l-.724-1.447A1 1 0 0011 2H9zM7 8a1 1 0 012 0v6a1 1 0 11-2 0V8zm5-1a1 1 0 00-1 1v6a1 1 0 102 0V8a1 1 0 00-1-1z" clipRule="evenodd" />
+                            </svg>
+                          </button>
+                        </div>
+                      </div>
+                      <div className="flex items-center text-xs text-gray-500 mt-1">
+                        <ClockIcon className="h-3 w-3 mr-1" />
+                        {new Date(op.criadoEm).toLocaleString('pt-BR')}
+                      </div>
+                      {op.tempoProcessamento && (
+                        <p className="text-xs text-gray-500 mt-1">
+                          {op.tempoProcessamento}ms
+                        </p>
+                      )}
+                      {op.status === 'CONCLUIDO' && op.arquivosResultado && op.arquivosResultado.length > 0 && (
+                        <div className="mt-2 space-y-1">
+                          {op.arquivosResultado.map((arquivo: string, index: number) => (
+                            <button
+                              key={index}
+                              onClick={() => downloadFile(op.id, index)}
+                              className="flex items-center space-x-1 w-full text-xs text-blue-600 hover:text-blue-700 hover:bg-blue-50 p-1 rounded"
+                            >
+                              <ArrowDownTrayIcon className="h-3 w-3" />
+                              <span>Arquivo {index + 1}</span>
+                            </button>
+                          ))}
+                        </div>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};
@@ -3,6 +3,8 @@ import { useNavigate } from 'react-router-dom';
 import { useDropzone } from 'react-dropzone';
 import { toast } from 'react-toastify';

+// Página pública: NÃO requer autenticação do usuário
+
 export function ClientProvaUpload() {
  const [file, setFile] = useState<File | null>(null);
  const [uploading, setUploading] = useState(false);
@@ -43,9 +45,31 @@ export function ClientProvaUpload() {
    }
  }, []);

+  // Validação extra do arquivo antes do upload
+  function validateFile(file: File | null): string | null {
+    if (!file) return 'Nenhum arquivo selecionado.';
+    const allowedTypes = [
+      'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'application/pdf'
+    ];
+    if (!allowedTypes.includes(file.type)) {
+      return 'Tipo de arquivo não suportado. Use JPG, PNG, GIF, WEBP ou PDF.';
+    }
+    if (file.size > 10 * 1024 * 1024) {
+      return 'Arquivo excede o tamanho máximo de 10MB.';
+    }
+    return null;
+  }
+
  const onDrop = useCallback(async (acceptedFiles: File[]) => {
    if (acceptedFiles.length > 0) {
      const selectedFile = acceptedFiles[0];
+      const validationError = validateFile(selectedFile);
+      if (validationError) {
+        toast.error(validationError);
+        setFile(null);
+        setFilePreview(null);
+        return;
+      }
      setFile(selectedFile);
      
      // Criar preview para imagens
@@ -77,6 +101,12 @@ export function ClientProvaUpload() {
        toast.error('Por favor, selecione um arquivo primeiro');
        return;
      }
+      // Validação extra antes do envio
+      const validationError = validateFile(file);
+      if (validationError) {
+        toast.error(validationError);
+        return;
+      }

      setUploading(true);
      setUploadProgress(0);
@@ -120,7 +150,7 @@ export function ClientProvaUpload() {
      // Adicionar timestamp preciso do cliente
      formData.append('client_timestamp', new Date().toISOString());

-      // Criar simulação de progresso
+      // Simulação de progresso
      const progressInterval = setInterval(() => {
        setUploadProgress(prev => {
          if (prev >= 95) {
@@ -131,10 +161,18 @@ export function ClientProvaUpload() {
        });
      }, 300);

-      const response = await fetch('/api/provas/upload', {
+      // Upload sem autenticação (página pública)
+      let response: Response;
+      try {
+        response = await fetch('/api/provas/upload', {
          method: 'POST',
          body: formData,
        });
+      } catch (networkError) {
+        clearInterval(progressInterval);
+        setUploadProgress(0);
+        throw new Error('Erro de conexão. Verifique sua internet e tente novamente.');
+      }

      clearInterval(progressInterval);
      setUploadProgress(100);
@@ -155,9 +193,14 @@ export function ClientProvaUpload() {
      }

      // Ler o corpo da resposta
-      const result = await response.json();
+      let result: any;
+      try {
+        result = await response.json();
+      } catch {
+        throw new Error('Resposta inesperada do servidor.');
+      }

-      if (result.id) {
+      if (result && result.id) {
        toast.success('Arquivo enviado com sucesso!');
        // Navegar para a página de status
        navigate(`/public/provas/status/${result.id}`);
@@ -165,10 +208,10 @@ export function ClientProvaUpload() {
        throw new Error('ID do documento não encontrado na resposta');
      }
      
-    } catch (error) {
+    } catch (error: any) {
      console.error('Erro detalhado no upload:', error);
      setError(error.message || 'Erro ao enviar arquivo. Por favor, tente novamente.');
-      toast.error('Falha no upload: ' + error.message);
+      toast.error('Falha no upload: ' + (error.message || 'Erro desconhecido'));
    } finally {
      setUploading(false);
    }
@@ -168,6 +168,18 @@ export const TarefaModal: React.FC<TarefaModalProps> = ({ isOpen, onClose, taref
                        <option value="URGENTE">Urgente</option>
                      </select>

+                      {/* Campo para alterar o status da tarefa conforme banco de dados */}
+                      <select
+                        {...register('status')}
+                        className="w-full p-2 rounded-lg border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-700 text-gray-900 dark:text-white"
+                      >
+                        <option value="PENDENTE">Pendente</option>
+                        {/* Exibe 'Em andamento' sem underline */}
+                        <option value="EM_ANDAMENTO">Em andamento</option>
+                        <option value="CONCLUIDA">Concluída</option>
+                        <option value="CANCELADA">Cancelada</option>
+                      </select>
+
                      <select
                        {...register('responsavelId')}
                        className="w-full p-2 rounded-lg border border-gray-300 dark:border-gray-600 bg-white dark:bg-gray-700 text-gray-900 dark:text-white"
@@ -1,5 +1,6 @@
-import { useMutation, useQueryClient } from "react-query";
+import { useMutation, useQuery, useQueryClient } from "react-query";
 import axios from "axios";
+import api from "../services/api";

 export function useAudiencias(processoId: string) {
  const queryClient = useQueryClient();
@@ -49,9 +50,15 @@ export function useAudiencias(processoId: string) {
    },
  );

+  const { data: audiencias } = useQuery("audiencias", async () => {
+    const { data } = await api.get("/audiencias");
+    return data;
+  });
+
  return {
    addAudiencia: addAudiencia.mutateAsync,
    updateAudiencia: updateAudiencia.mutateAsync,
    deleteAudiencia: deleteAudiencia.mutateAsync,
+    audiencias,
  };
 }
@@ -0,0 +1,44 @@
+import { useQuery } from 'react-query';
+import { Processo } from '../types/entities';
+import api from '../services/api';
+
+interface Benchmarking {
+  totalProcessos: number;
+  ativos: number;
+  procedentes: number;
+  improcedentesOuSemMerito: number;
+  ajuizados7dias: number;
+}
+
+// Hook para calcular benchmarking do escritório
+export function useBenchmarking() {
+  return useQuery<Benchmarking>('benchmarking', async () => {
+    // Buscar todos os processos
+    const res = await api.get<Processo[]>('/processos');
+    const processos = res.data;
+
+    // Total de processos
+    const totalProcessos = processos.length;
+    // Total de processos ativos
+    const ativos = processos.filter(p => p.statusAtividade === 'ATIVO').length;
+    // Julgados procedentes
+    const procedentes = processos.filter(p => p.resultado === 'PROCEDENTE').length;
+    // Julgados improcedentes ou sem análise de mérito
+    const improcedentesOuSemMerito = processos.filter(p => p.resultado === 'IMPROCEDENTE' || p.resultado === 'SEM_ANALISE_MERITO').length;
+    // Processos ajuizados nos últimos 7 dias
+    const seteDiasAtras = new Date();
+    seteDiasAtras.setDate(seteDiasAtras.getDate() - 7);
+    const ajuizados7dias = processos.filter(p => {
+      const criacao = p.dataCriacao ? new Date(p.dataCriacao) : null;
+      return criacao && criacao >= seteDiasAtras;
+    }).length;
+
+    return {
+      totalProcessos,
+      ativos,
+      procedentes,
+      improcedentesOuSemMerito,
+      ajuizados7dias,
+    };
+  });
+}
@@ -0,0 +1,41 @@
+import { useQuery } from 'react-query';
+import api from '../services/api';
+
+export interface EventoCalendario {
+  id: string;
+  data: string;
+  tipo: string;
+  descricao: string;
+}
+
+// Hook para buscar atendimentos e audiências do calendário
+export function useCalendarioAtendimentos() {
+  return useQuery<EventoCalendario[]>('calendarioAtendimentos', async () => {
+    // Buscar atendimentos
+    const atendimentosRes = await api.get('/atendimentos');
+    const atendimentos = atendimentosRes.data.map((a: any) => ({
+      id: a.id,
+      data: a.dataAtendimento?.slice(0, 10),
+      tipo: 'Atendimento',
+      descricao: a.titulo || 'Atendimento',
+    }));
+
+    // Buscar audiências, tratar erro 404
+    let audiencias: EventoCalendario[] = [];
+    try {
+      const audienciasRes = await api.get('/audiencias');
+      audiencias = audienciasRes.data.map((a: any) => ({
+        id: a.id,
+        data: a.data?.slice(0, 10),
+        tipo: 'Audiência',
+        descricao: a.tipo || 'Audiência',
+      }));
+    } catch (error: any) {
+      if (error?.response?.status !== 404) throw error;
+      // Se for 404, ignora audiências
+    }
+
+    // Junta todos eventos
+    return [...atendimentos, ...audiencias];
+  });
+}
@@ -0,0 +1,31 @@
+import { useQuery } from 'react-query';
+import api from '../services/api';
+
+export interface FinanceiroResumo {
+  honorariosAReceber: number;
+  honorariosRecebidosMes: number;
+  custasAPagar: number;
+  custasPagasMes: number;
+  detalhesHonorarios: any[];
+  detalhesCustas: any[];
+}
+
+// Hook para buscar dados financeiros do painel diretamente do backend
+export function useFinanceiroPainel(mes: number, ano: number) {
+  return useQuery<FinanceiroResumo>(['financeiroPainel', mes, ano], async () => {
+    try {
+      const res = await api.get(`/financeiro-painel?mes=${mes}&ano=${ano}`);
+      return res.data;
+    } catch (error: any) {
+      // Se der erro, retorna tudo zerado
+      return {
+        honorariosAReceber: 0,
+        honorariosRecebidosMes: 0,
+        custasAPagar: 0,
+        custasPagasMes: 0,
+        detalhesHonorarios: [],
+        detalhesCustas: [],
+      };
+    }
+  });
+}
@@ -1,40 +0,0 @@
-import express from 'express';
-import bodyParser from 'body-parser';
-import cors from 'cors';
-import dotenv from 'dotenv';
-import path from 'path';
-import { PrismaClient } from '@prisma/client';
-import provasRoutes from './routes/provas';
-import calculosJudiciaisRoutes from './routes/calculosJudiciais';
-import indicesMonetariosRoutes from './routes/indicesMonetarios';
-import pensaoAlimenticiaRoutes from './routes/pensaoAlimenticia';
-
-dotenv.config();
-
-const app = express();
-const prisma = new PrismaClient();
-
-// Configurar para confiar em proxies, permitindo a leitura de X-Forwarded-For
-// Isso é necessário se sua aplicação estiver atrás de um balanceador de carga, 
-// proxy reverso ou Cloudflare
-app.set('trust proxy', true);
-
-app.use(cors());
-app.use(bodyParser.json());
-app.use(bodyParser.urlencoded({ extended: true }));
-
-app.use('/api/provas', provasRoutes);
-app.use('/api/calculos', calculosJudiciaisRoutes);
-app.use('/api/indices', indicesMonetariosRoutes);
-app.use('/api/pensao-alimenticia', pensaoAlimenticiaRoutes);
-
-app.use(express.static(path.join(__dirname, 'public')));
-app.set('trust proxy', true); // Importante para obter o IP real em ambientes com proxy
-
-const PORT = process.env.PORT || 5000;
-
-app.listen(PORT, () => {
-  console.log(`Server is running on port ${PORT}`);
-});
-
-export { app, prisma };
@@ -0,0 +1,20 @@
+import { Request, Response } from "express";
+import { prisma } from "../prismaClient";
+
+// Função para listar todas as audiências
+export async function getAudiencias(req: Request, res: Response) {
+  try {
+    const audiencias = await prisma.audiencia.findMany({
+      orderBy: { data: "asc" },
+      include: {
+        processo: {
+          select: { numero: true, nomeContraparte: true }
+        }
+      }
+    });
+    res.json(audiencias);
+  } catch (error) {
+    console.error("Erro ao buscar audiências:", error);
+    res.status(500).json({ error: "Erro ao buscar audiências" });
+  }
+}
@@ -24,7 +24,12 @@ import processosAdministrativosRoutes from './routes/processosAdministrativos';
 import provasRouter from './routes/provas';
 import calculosJudiciaisRoutes from './routes/calculosJudiciais';
 import indicesMonetariosRoutes from './routes/indicesMonetarios';
-import pensaoAlimenticiaRoutes from './routes/pensaoAlimenticia';
+import pensaoAlimenticiaRouter from './routes/pensaoAlimenticia'; // Importar router de pensão alimentícia
+import financeiroPainelRoutes from './routes/financeiroPainel'; // Importar rotas do financeiro painel
+import audienciasRoutes from './routes/audiencias'; // Importar rotas de audiências
+import pdfRoutes from './routes/pdf'; // Importar rotas de PDF
+import { PDFService } from '../services/pdfService'; // Importar serviço de PDF para warmup OCR
+

 const app = express();
 const port = process.env.PORT || 5000;
@@ -47,7 +52,8 @@ app.use((req, res, next) => {
  next();
 });

-app.use(express.json());
+app.use(express.json({ limit: '20mb' }));
+app.use(express.urlencoded({ extended: true, limit: '20mb' }));

 const clienteRepository = new ClienteRepository();
 const processoRepository = new ProcessoRepository();
@@ -1425,8 +1431,26 @@ app.use(
  },
 );

-app.listen(port, () => {
+// Aumentar timeout do servidor para operações longas (ex: PDF, OCR)
+const server = app.listen(port, () => {
  console.log(`🚀 Servidor rodando em http://localhost:${port}`);
+
+  // Pré-aquece o worker Tesseract OCR em background (elimina delay na primeira operação)
+  PDFService.warmupOCR('por').catch(() => {});
+});
+server.timeout = 600000; // 10 minutos (600 segundos)
+
+// Encerra workers Tesseract ao desligar o servidor
+process.on('SIGTERM', async () => {
+  console.log('Encerrando workers OCR...');
+  await PDFService.terminateWorkers();
+  process.exit(0);
+});
+
+process.on('SIGINT', async () => {
+  console.log('Encerrando workers OCR...');
+  await PDFService.terminateWorkers();
+  process.exit(0);
 });

 process.on("unhandledRejection", (err) => {
@@ -1475,4 +1499,7 @@ app.use('/api/documentos-modelos', documentosModelosRouter);
 app.use('/api/processos-administrativos', processosAdministrativosRoutes);
 app.use('/api/calculos', calculosJudiciaisRoutes);
 app.use('/api/indices', indicesMonetariosRoutes);
-app.use('/api/pensao-alimenticia', pensaoAlimenticiaRoutes);
+app.use('/api/pensao-alimenticia', pensaoAlimenticiaRouter);
+app.use('/api/financeiro-painel', financeiroPainelRoutes); // Adicionar uso das rotas do financeiro painel
+app.use('/api/audiencias', audienciasRoutes); // Adicionar uso das rotas de audiências
+app.use('/api/pdf', pdfRoutes); // Adicionar uso das rotas de PDF
@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { getAudiencias } from "../controllers/audienciasController";
+
+const router = Router();
+
+// GET /api/audiencias - Lista todas as audiências
+router.get("/", getAudiencias);
+
+export default router;
@@ -83,11 +83,9 @@ router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const calculo = await calculoService.buscarCalculo(id);
-    
    if (!calculo) {
      return res.status(404).json({ error: 'Cálculo não encontrado' });
    }
-    
    res.json(calculo);
  } catch (error) {
    console.error('Erro ao buscar cálculo:', error);
@@ -0,0 +1,99 @@
+import express from 'express';
+import { prisma } from '../prismaClient';
+
+const router = express.Router();
+
+// GET /api/financeiro-painel?mes=6&ano=2024
+router.get('/', async (req, res) => {
+  try {
+    const mes = parseInt(req.query.mes as string) || (new Date().getMonth() + 1);
+    const ano = parseInt(req.query.ano as string) || (new Date().getFullYear());
+    if (isNaN(mes) || isNaN(ano)) {
+      return res.status(400).json({ error: 'Parâmetros de mês e ano inválidos.' });
+    }
+    // Datas para filtro
+    const dataInicio = new Date(ano, mes - 1, 1);
+    const dataFim = new Date(ano, mes, 1);
+
+    // Honorários a receber: parcelas pendentes ou vencidas
+    const honorariosAReceber = await prisma.parcelaHonorario.aggregate({
+      _sum: { valor: true },
+      where: {
+        OR: [{ status: 'PENDENTE' }, { status: 'VENCIDO' }],
+      },
+    });
+
+    // Honorários recebidos no mês
+    const honorariosRecebidosMes = await prisma.parcelaHonorario.aggregate({
+      _sum: { valorPago: true },
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+    });
+
+    // Detalhes das parcelas recebidas no mês
+    const detalhesHonorarios = await prisma.parcelaHonorario.findMany({
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+      include: { honorario: true },
+      orderBy: { dataPagamento: 'desc' },
+      take: 10,
+    });
+
+    // Custas a pagar
+    const custasAPagar = await prisma.custaProcessual.aggregate({
+      _sum: { valor: true },
+      where: {
+        OR: [{ status: 'PENDENTE' }, { status: 'VENCIDO' }],
+      },
+    });
+
+    // Custas pagas no mês
+    const custasPagasMes = await prisma.custaProcessual.aggregate({
+      _sum: { valor: true },
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+    });
+
+    // Detalhes das custas pagas no mês
+    const detalhesCustas = await prisma.custaProcessual.findMany({
+      where: {
+        status: 'PAGO',
+        dataPagamento: {
+          gte: dataInicio,
+          lt: dataFim,
+        },
+      },
+      orderBy: { dataPagamento: 'desc' },
+      take: 10,
+    });
+
+    res.json({
+      honorariosAReceber: honorariosAReceber._sum.valor || 0,
+      honorariosRecebidosMes: honorariosRecebidosMes._sum.valorPago || 0,
+      custasAPagar: custasAPagar._sum.valor || 0,
+      custasPagasMes: custasPagasMes._sum.valor || 0,
+      detalhesHonorarios,
+      detalhesCustas,
+    });
+  } catch (error) {
+    console.error('Erro no financeiroPainel:', error);
+    res.status(500).json({ error: 'Erro ao buscar dados financeiros.' });
+  }
+});
+
+export default router;
@@ -0,0 +1,103 @@
+import express from 'express';
+import { PDFController, uploadMiddleware } from '../controllers/pdfController';
+import { authMiddleware } from '../../middleware/auth';
+
+const router = express.Router();
+
+/**
+ * Rotas para manipulação de PDF
+ * Todas as rotas requerem autenticação
+ */
+
+// Comprime PDFs
+router.post(
+  '/compress',
+  authMiddleware,
+  uploadMiddleware.array('files', 10),
+  PDFController.compress
+);
+
+// Divide PDF
+router.post(
+  '/split',
+  authMiddleware,
+  uploadMiddleware.array('files', 1),
+  PDFController.split
+);
+
+// Mescla PDFs
+router.post(
+  '/merge',
+  authMiddleware,
+  uploadMiddleware.array('files', 50),
+  PDFController.merge
+);
+
+// Converte PDF para imagens
+router.post(
+  '/pdf-to-images',
+  authMiddleware,
+  uploadMiddleware.array('files', 1),
+  PDFController.pdfToImages
+);
+
+// Converte imagens para PDF
+router.post(
+  '/images-to-pdf',
+  authMiddleware,
+  uploadMiddleware.array('files', 100),
+  PDFController.imagesToPDF
+);
+
+// Realiza OCR em PDF
+router.post(
+  '/ocr',
+  authMiddleware,
+  uploadMiddleware.array('files', 1),
+  PDFController.performOCR
+);
+
+// Obtém informações de um PDF
+router.post(
+  '/info',
+  authMiddleware,
+  uploadMiddleware.array('files', 1),
+  PDFController.getInfo
+);
+
+// Obtém histórico de operações
+router.get(
+  '/history',
+  authMiddleware,
+  PDFController.getHistory
+);
+
+// Download de arquivo processado
+router.get(
+  '/download/:operacaoId/:fileIndex',
+  authMiddleware,
+  PDFController.downloadFile
+);
+
+// Deleta uma operação específica
+router.delete(
+  '/operation/:operacaoId',
+  authMiddleware,
+  PDFController.deleteOperation
+);
+
+// Limpa todo o histórico
+router.delete(
+  '/history/clear',
+  authMiddleware,
+  PDFController.clearHistory
+);
+
+// Limpa operações antigas
+router.delete(
+  '/history/cleanup',
+  authMiddleware,
+  PDFController.cleanupOldOperations
+);
+
+export default router;
@@ -55,7 +55,7 @@ router.post('/', async (req, res) => {
 router.get('/:id', async (req, res) => {
  try {
    const { id } = req.params;
-    
+    console.log('[pensaoAlimenticia] Buscando cálculo por ID:', id); // Log para depuração
    const calculo = await prisma.calculoPensaoAlimenticia.findUnique({
      where: { id },
      include: {
@@ -70,15 +70,14 @@ router.get('/:id', async (req, res) => {
        }
      }
    });
-
    if (!calculo) {
+      console.warn('[pensaoAlimenticia] Cálculo não encontrado para ID:', id); // Log para depuração
      return res.status(404).json({ error: 'Cálculo não encontrado' });
    }
-
    res.json(calculo);
  } catch (error) {
-    console.error('Erro ao buscar cálculo:', error);
-    res.status(500).json({ error: 'Falha ao buscar cálculo' });
+    console.error('[pensaoAlimenticia] Erro ao buscar cálculo:', error);
+    res.status(500).json({ error: 'Falha ao buscar cálculo', details: error.message });
  }
 });

@@ -1,634 +0,0 @@
-import puppeteer from 'puppeteer';
-import { prisma } from '../prismaClient';
-import { PDFDocument, rgb, StandardFonts } from 'pdf-lib';
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Serviço para geração e manipulação de arquivos PDF
- */
-export class PdfService {
-  /**
-   * Cria um documento PDF básico
-   * @returns Documento PDF
-   */
-  async criarDocumento() {
-    return await PDFDocument.create();
-  }
-  
-  /**
-   * Carrega um documento PDF existente
-   * @param pdfBytes - Bytes do PDF
-   * @returns Documento PDF
-   */
-  async carregarDocumento(pdfBytes: Uint8Array) {
-    return await PDFDocument.load(pdfBytes);
-  }
-  
-  /**
-   * Adiciona uma página ao documento
-   * @param doc - Documento PDF
-   * @param tamanho - Tamanho da página (padrão: A4)
-   * @returns Página adicionada
-   */
-  adicionarPagina(doc: any, tamanho = [595.28, 841.89]) {
-    return doc.addPage(tamanho);
-  }
-  
-  /**
-   * Salva o documento como buffer
-   * @param doc - Documento PDF
-   * @returns Buffer do PDF
-   */
-  async salvarComoBuffer(doc: any): Promise<Buffer> {
-    const pdfBytes = await doc.save();
-    return Buffer.from(pdfBytes);
-  }
-  
-  /**
-   * Carrega uma fonte padrão
-   * @param doc - Documento PDF
-   * @param fonte - Nome da fonte padrão
-   * @returns Fonte carregada
-   */
-  async carregarFonte(doc: any, fonte: StandardFonts) {
-    return await doc.embedFont(fonte);
-  }
-  
-  /**
-   * Desenha texto em uma página
-   * @param pagina - Página do PDF
-   * @param texto - Texto a ser desenhado
-   * @param x - Posição X
-   * @param y - Posição Y
-   * @param fonte - Fonte a ser usada
-   * @param tamanho - Tamanho da fonte
-   * @param cor - Cor do texto (padrão: preto)
-   */
-  desenharTexto(
-    pagina: any,
-    texto: string,
-    x: number,
-    y: number,
-    fonte: any,
-    tamanho: number,
-    cor = rgb(0, 0, 0)
-  ) {
-    pagina.drawText(texto, {
-      x,
-      y,
-      font: fonte,
-      size: tamanho,
-      color: cor,
-    });
-  }
-  
-  /**
-   * Cria um cabeçalho para o documento
-   * @param pagina - Página do PDF
-   * @param titulo - Título do cabeçalho
-   * @param fonte - Fonte a ser usada
-   * @param margemSuperior - Margem superior
-   * @param margem - Margem lateral
-   * @returns Posição Y após o cabeçalho
-   */
-  criarCabecalho(
-    pagina: any,
-    titulo: string,
-    fonte: any,
-    margemSuperior: number,
-    margem: number
-  ): number {
-    const yPos = pagina.getHeight() - margemSuperior;
-    
-    this.desenharTexto(
-      pagina,
-      titulo,
-      margem,
-      yPos,
-      fonte,
-      18,
-      rgb(0, 0, 0.7)
-    );
-    
-    // Linha separadora
-    pagina.drawLine({
-      start: { x: margem, y: yPos - 10 },
-      end: { x: pagina.getWidth() - margem, y: yPos - 10 },
-      thickness: 1,
-      color: rgb(0, 0, 0.5),
-    });
-    
-    return yPos - 30; // Retorna a posição Y após o cabeçalho
-  }
-  
-  /**
-   * Cria um rodapé para o documento
-   * @param pagina - Página do PDF
-   * @param texto - Texto do rodapé
-   * @param fonte - Fonte a ser usada
-   * @param margem - Margem
-   */
-  criarRodape(pagina: any, texto: string, fonte: any, margem: number) {
-    const yPos = margem / 2;
-    
-    this.desenharTexto(
-      pagina,
-      texto,
-      margem,
-      yPos,
-      fonte,
-      8,
-      rgb(0.5, 0.5, 0.5)
-    );
-  }
-
-  private async getConfiguracao() {
-    try {
-      // Buscar configuração ou usar valores padrão
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' },
-        select: {
-          id: true,
-          timbradoUrl: true,
-          timbradoMarginTop: true,
-          timbradoMarginBottom: true,
-          timbradoMarginLeft: true,
-          timbradoMarginRight: true,
-          templatePadrao: true,
-          margensTemplate: true,
-          criadoEm: true
-        }
-      });
-
-      console.log('Configuração encontrada:', config); // Debug
-
-      // Retornar configuração padrão se não existir
-      return {
-        // Valores padrão
-        cabecalhoHtml: `
-          <div style="text-align: center; padding: 20px;">
-            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
-          </div>
-        `,
-        rodapeHtml: `
-          <div style="text-align: center; font-size: 10pt;">
-            {{escritorio.endereco}}<br>
-            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
-          </div>
-        `,
-        // Campos que existem no modelo
-        timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop || 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
-        timbradoMarginRight: config?.timbradoMarginRight || 50,
-        templatePadrao: config?.templatePadrao || null,
-        margensTemplate: config?.margensTemplate || null
-      };
-    } catch (error) {
-      console.error('Erro ao buscar configuração:', error);
-      // Retornar configuração padrão para não interromper o fluxo
-      return {
-        cabecalhoHtml: `<div style="text-align: center; padding: 20px;"><h2 style="margin:0;font-size:14pt">Documento</h2></div>`,
-        rodapeHtml: `<div style="text-align: center; font-size: 10pt;">Documento gerado pelo sistema</div>`,
-        timbradoUrl: '',
-        timbradoMarginTop: 100,
-        timbradoMarginBottom: 50,
-        timbradoMarginLeft: 50,
-        timbradoMarginRight: 50,
-        templatePadrao: null,
-        margensTemplate: null
-      };
-    }
-  }
-
-  /**
-   * Gera um PDF a partir do conteúdo HTML simples (apenas texto) e dados do escritório,
-   * encaixando o texto sobre o timbrado (PDF de fundo) em todas as páginas.
-   * Não usa Puppeteer, apenas PDF-LIB.
-   */
-  async gerarPDF(conteudo: string, escritorio: any = {}): Promise<Buffer> {
-    try {
-      console.log('Buscando configurações do documento...');
-      const config = await this.getConfiguracao();
-
-      // Verificar se temos um timbrado para usar
-      const temTimbrado = !!config.timbradoUrl;
-      let timbradoPath = '';
-      let timbradoExists = false;
-
-      if (temTimbrado) {
-        if (config.timbradoUrl.startsWith('/uploads')) {
-          timbradoPath = path.join(process.cwd(), 'public', config.timbradoUrl);
-        } else {
-          timbradoPath = path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
-        }
-        try {
-          await fs.access(timbradoPath);
-          timbradoExists = true;
-        } catch (e) {
-          timbradoExists = false;
-        }
-      }
-
-      // Margens
-      const margens = config.margensTemplate || {
-        top: config.timbradoMarginTop || 100,
-        left: config.timbradoMarginLeft || 50,
-        right: config.timbradoMarginRight || 50,
-        bottom: config.timbradoMarginBottom || 50
-      };
-
-      // Parâmetros de página
-      const PAGE_WIDTH = 595.28; // A4
-      const PAGE_HEIGHT = 841.89; // A4
-      const FONT_SIZE = 12;
-      const LINE_HEIGHT = FONT_SIZE * 1.5;
-      const MAX_WIDTH = PAGE_WIDTH - margens.left - margens.right;
-
-      // Crie o PDFDocument ANTES de tentar usar pdfDoc para embedFont!
-      let pdfDoc: PDFDocument = await PDFDocument.create();
-
-      // Fonte padrão do pdf-lib: TimesRoman, TimesBold, TimesItalic
-      const font = await pdfDoc.embedFont('Times-Roman');
-      const fontBold = await pdfDoc.embedFont('Times-Bold');
-      const fontItalic = await pdfDoc.embedFont('Times-Italic');
-      const fontBoldItalic = fontBold;
-
-      // Função para decodificar entidades HTML comuns (acentuação, símbolos, º, etc)
-      function decodeHtmlEntities(str: string): string {
-        if (!str) return '';
-        return str
-          // Acentos minúsculos e maiúsculos
-          .replace(/&Aacute;/g, 'Á').replace(/&aacute;/g, 'á')
-          .replace(/&Eacute;/g, 'É').replace(/&eacute;/g, 'é')
-          .replace(/&Iacute;/g, 'Í').replace(/&iacute;/g, 'í')
-          .replace(/&Oacute;/g, 'Ó').replace(/&oacute;/g, 'ó')
-          .replace(/&Uacute;/g, 'Ú').replace(/&uacute;/g, 'ú')
-          .replace(/&Agrave;/g, 'À').replace(/&agrave;/g, 'à')
-          .replace(/&Egrave;/g, 'È').replace(/&egrave;/g, 'è')
-          .replace(/&Igrave;/g, 'Ì').replace(/&igrave;/g, 'ì')
-          .replace(/&Ograve;/g, 'Ò').replace(/&ograve;/g, 'ò')
-          .replace(/&Ugrave;/g, 'Ù').replace(/&ugrave;/g, 'ù')
-          .replace(/&Acirc;/g, 'Â').replace(/&acirc;/g, 'â')
-          .replace(/&Ecirc;/g, 'Ê').replace(/&ecirc;/g, 'ê')
-          .replace(/&Icirc;/g, 'Î').replace(/&icirc;/g, 'î')
-          .replace(/&Ocirc;/g, 'Ô').replace(/&ocirc;/g, 'ô')
-          .replace(/&Ucirc;/g, 'Û').replace(/&ucirc;/g, 'û')
-          .replace(/&Atilde;/g, 'Ã').replace(/&atilde;/g, 'ã')
-          .replace(/&Otilde;/g, 'Õ').replace(/&otilde;/g, 'õ')
-          .replace(/&Ccedil;/g, 'Ç').replace(/&ccedil;/g, 'ç')
-          .replace(/&Ntilde;/g, 'Ñ').replace(/&ntilde;/g, 'ñ')
-          .replace(/&Uuml;/g, 'Ü').replace(/&uuml;/g, 'ü')
-          // Símbolos comuns
-          .replace(/&ordm;/gi, 'º')
-          .replace(/&ordf;/gi, 'ª')
-          .replace(/&sect;/gi, '§')
-          .replace(/&deg;/gi, '°')
-          .replace(/&copy;/gi, '©')
-          .replace(/&reg;/gi, '®')
-          .replace(/&para;/gi, '¶')
-          .replace(/&bull;/gi, '•')
-          .replace(/&ndash;/gi, '–')
-          .replace(/&mdash;/gi, '—')
-          .replace(/&laquo;/gi, '«')
-          .replace(/&raquo;/gi, '»')
-          .replace(/&lsquo;/gi, '‘')
-          .replace(/&rsquo;/gi, '’')
-          .replace(/&ldquo;/gi, '“')
-          .replace(/&rdquo;/gi, '”')
-          .replace(/&euro;/gi, '€')
-          .replace(/&yen;/gi, '¥')
-          .replace(/&pound;/gi, '£')
-          .replace(/&cent;/gi, '¢')
-          .replace(/&nbsp;/gi, ' ')
-          .replace(/&amp;/gi, '&')
-          .replace(/&quot;/gi, '"')
-          .replace(/&#39;/g, "'")
-          .replace(/&lt;/gi, '<')
-          .replace(/&gt;/gi, '>')
-          // Numéricos
-          .replace(/&#(\d+);/g, (m, code) => String.fromCharCode(code));
-      }
-
-      // Função para remover todas as tags HTML, exceto as de formatação suportadas
-      function stripUnsupportedTags(html: string): string {
-        // Remove todas as tags, exceto <b>, <strong>, <i>, <em>, <u>, <br>, <p>, <span style="text-indent:2em;">, <span style="text-align:center;">
-        // Remove atributos de <span> exceto text-indent e text-align
-        return html
-          // Mantém apenas <span> com text-indent ou text-align:center
-          .replace(/<span\b(?:(?!text-indent|text-align)[^>])*?>/gi, '')
-          // Remove atributos de <b>, <strong>, <i>, <em>, <u>, <p>
-          .replace(/<(b|strong|i|em|u|p)[^>]*>/gi, '<$1>')
-          // Remove todas as outras tags e atributos
-          .replace(/<(?!\/?(b|strong|i|em|u|br|p|span)[ >])[^>]+>/gi, '')
-          // Remove spans sem text-indent ou text-align
-          .replace(/<span>(.*?)<\/span>/gi, '$1')
-          // Remove comentários HTML
-          .replace(/<!--[\s\S]*?-->/g, '');
-      }
-
-      // Função para renderizar texto com formatação inline (negrito, itálico, sublinhado) e controle de quebra de linha e recuo
-      function renderInlineFormattedParagraph(
-        page,
-        text: string,
-        x: number,
-        y: number,
-        font,
-        fontBold,
-        fontItalic,
-        fontBoldItalic,
-        fontSize: number,
-        color,
-        align: string,
-        maxWidth: number,
-        indent: boolean,
-        topMargin: number,
-        bottomMargin: number,
-        pageHeight: number
-      ) {
-        let regex = /(<\/?(b|strong|i|em|u)>)/gi;
-        let tokens: { text: string, bold: boolean, italic: boolean, underline: boolean }[] = [];
-        let lastIndex = 0;
-        let match;
-        let currentStyle = { bold: false, italic: false, underline: false };
-        while ((match = regex.exec(text)) !== null) {
-          if (match.index > lastIndex) {
-            tokens.push({
-              text: text.substring(lastIndex, match.index),
-              bold: currentStyle.bold,
-              italic: currentStyle.italic,
-              underline: currentStyle.underline
-            });
-          }
-          if (/^<(b|strong)>$/i.test(match[0])) currentStyle.bold = true;
-          if (/^<\/(b|strong)>$/i.test(match[0])) currentStyle.bold = false;
-          if (/^<(i|em)>$/i.test(match[0])) currentStyle.italic = true;
-          if (/^<\/(i|em)>$/i.test(match[0])) currentStyle.italic = false;
-          if (/^<u>$/i.test(match[0])) currentStyle.underline = true;
-          if (/^<\/u>$/i.test(match[0])) currentStyle.underline = false;
-          lastIndex = regex.lastIndex;
-        }
-        if (lastIndex < text.length) {
-          tokens.push({
-            text: text.substring(lastIndex),
-            bold: currentStyle.bold,
-            italic: currentStyle.italic,
-            underline: currentStyle.underline
-          });
-        }
-
-        let words: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] = [];
-        for (const token of tokens) {
-          let usedFont = font;
-          if (token.bold && token.italic) usedFont = fontBoldItalic;
-          else if (token.bold) usedFont = fontBold;
-          else if (token.italic) usedFont = fontItalic;
-          // Corrige: split por espaço, mas preserva espaços como tokens separados
-          const split = token.text.split(/(\s+)/);
-          for (const part of split) {
-            words.push({ text: part, font: usedFont, underline: token.underline, bold: token.bold, italic: token.italic });
-          }
-        }
-
-        let lines: { tokens: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] }[] = [];
-        let currentTokens: { text: string, font: any, underline: boolean, bold: boolean, italic: boolean }[] = [];
-        let currentWidth = 0;
-
-        for (const [i, word] of words.entries()) {
-          const wordWidth = word.font.widthOfTextAtSize(word.text, fontSize);
-          if (currentWidth + wordWidth > maxWidth && currentTokens.length > 0) {
-            lines.push({ tokens: currentTokens });
-            currentTokens = [word];
-            currentWidth = wordWidth;
-          } else {
-            currentTokens.push(word);
-            currentWidth += wordWidth;
-          }
-        }
-        if (currentTokens.length > 0) {
-          lines.push({ tokens: currentTokens });
-        }
-
-        // Ajuste: Força alinhamento consistente para todas as linhas do parágrafo
-        // Se align === 'center', todas as linhas centralizadas
-        // Se align === 'justify', todas as linhas justificadas (exceto a última ou linhas curtas)
-        // Se align === 'left' ou outro, todas à esquerda
-
-        for (let i = 0; i < lines.length; i++) {
-          if (y < bottomMargin + fontSize * 1.5) {
-            return null;
-          }
-          let line = lines[i];
-          let drawX = x;
-
-          // Remove espaços no início e fim da linha para não justificar esses espaços
-          let trimmedTokens = [...line.tokens];
-          while (trimmedTokens.length && /^\s+$/.test(trimmedTokens[0].text)) trimmedTokens.shift();
-          while (trimmedTokens.length && /^\s+$/.test(trimmedTokens[trimmedTokens.length - 1].text)) trimmedTokens.pop();
-
-          let totalWidth = trimmedTokens.reduce((acc, t) => acc + t.font.widthOfTextAtSize(t.text, fontSize), 0);
-
-          // Corrige centralização: centraliza a linha inteira, inclusive se for a única linha do parágrafo
-          if (align === 'center') {
-            drawX = x + (maxWidth - totalWidth) / 2;
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: drawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: drawX, y: underlineY },
-                  end: { x: drawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              drawX += t.font.widthOfTextAtSize(t.text, fontSize);
-            }
-          } else if (align === 'justify' && i < lines.length - 1 && trimmedTokens.length > 2) {
-            // Justify: distribui espaço entre palavras, exceto na última linha ou linhas curtas
-            const spaces = trimmedTokens.filter(t => /^\s+$/.test(t.text));
-            const numSpaces = spaces.length;
-            const lineTextWidth = trimmedTokens.reduce((acc, t) => acc + t.font.widthOfTextAtSize(t.text, fontSize), 0);
-            const extraSpace = maxWidth - lineTextWidth;
-            let spaceWidth = 0;
-            // Só justifica se houver pelo menos 2 espaços e a linha não for muito curta
-            if (numSpaces > 0 && extraSpace > 0) {
-              spaceWidth = extraSpace / numSpaces;
-            }
-            let localDrawX = x;
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: localDrawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: localDrawX, y: underlineY },
-                  end: { x: localDrawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              if (/^\s+$/.test(t.text) && spaceWidth > 0) {
-                localDrawX += t.font.widthOfTextAtSize(t.text, fontSize) + spaceWidth;
-              } else {
-                localDrawX += t.font.widthOfTextAtSize(t.text, fontSize);
-              }
-            }
-          } else {
-            // Alinhamento à esquerda (padrão) ou última linha de parágrafo justificado
-            for (const t of trimmedTokens) {
-              page.drawText(t.text, {
-                x: drawX,
-                y,
-                size: fontSize,
-                font: t.font,
-                color
-              });
-              if (t.underline && t.text.trim() !== '') {
-                const underlineY = y - 1.5;
-                page.drawLine({
-                  start: { x: drawX, y: underlineY },
-                  end: { x: drawX + t.font.widthOfTextAtSize(t.text, fontSize), y: underlineY },
-                  thickness: 0.75,
-                  color
-                });
-              }
-              drawX += t.font.widthOfTextAtSize(t.text, fontSize);
-            }
-          }
-          y -= fontSize * 1.5;
-        }
-        return y;
-      }
-
-      const texto = decodeHtmlEntities(
-        stripUnsupportedTags(
-          this.processarTemplate(conteudo, escritorio)
-            .replace(/<br\s*\/?>/gi, '\n')
-            .replace(/<\/p>/gi, '\n\n')
-            .replace(/<p[^>]*>/gi, '') 
-            .replace(/<span[^>]*text-indent[^>]*>/gi, '§§INDENT§§')
-            .replace(/<span[^>]*text-align\s*:\s*center[^>]*>/gi, '§§CENTER§§')
-            .replace(/<\/span>/gi, '')
-            .replace(/\r\n/g, '\n')
-            .replace(/\r/g, '\n')
-            .replace(/\n{3,}/g, '\n\n')
-            .trim()
-        )
-      );
-
-      const paragrafos = texto.split(/\n{2,}/).map(p => p.trim()).filter(Boolean);
-
-      let timbradoPdf: PDFDocument | null = null;
-      let timbradoPageCount = 0;
-      let timbradoPages: any[] = [];
-      if (timbradoExists) {
-        const timbradoBytes = await fs.readFile(timbradoPath);
-        timbradoPdf = await PDFDocument.load(timbradoBytes);
-        timbradoPageCount = timbradoPdf.getPageCount();
-        timbradoPages = [];
-        for (let i = 0; i < timbradoPageCount; i++) {
-          const [embedded] = await pdfDoc.embedPages([timbradoPdf.getPage(i)]);
-          timbradoPages.push(embedded);
-        }
-      }
-
-      let currentPar = 0;
-      let pageIndex = 0;
-      while (currentPar < paragrafos.length) {
-        let page = pdfDoc.addPage([PAGE_WIDTH, PAGE_HEIGHT]);
-        if (timbradoPages.length > 0) {
-          const embedded = timbradoPages[pageIndex % timbradoPages.length];
-          page.drawPage(embedded, {
-            x: 0,
-            y: 0,
-            width: PAGE_WIDTH,
-            height: PAGE_HEIGHT
-          });
-        }
-        let y = PAGE_HEIGHT - margens.top;
-        while (currentPar < paragrafos.length) {
-          let indent = paragrafos[currentPar].startsWith('§§INDENT§§');
-          let center = paragrafos[currentPar].startsWith('§§CENTER§§');
-          let align: 'center' | 'justify' | 'left' = center ? 'center' : 'justify';
-          let text = paragrafos[currentPar].replace(/^§§INDENT§§/, '').replace(/^§§CENTER§§/, '').trim();
-
-          // Se o parágrafo for centralizado, força alinhamento center e ignora recuo
-          if (center) {
-            indent = false;
-            align = 'center';
-          }
-
-          text = decodeHtmlEntities(text);
-
-          let x = margens.left;
-          let parWidth = MAX_WIDTH;
-
-          let yAfter = renderInlineFormattedParagraph(
-            page,
-            text,
-            x,
-            y,
-            font,
-            fontBold,
-            fontItalic,
-            fontBoldItalic,
-            FONT_SIZE,
-            rgb(0, 0, 0),
-            align,
-            parWidth,
-            indent,
-            margens.top,
-            margens.bottom,
-            PAGE_HEIGHT
-          );
-          if (yAfter === null) {
-            pageIndex++;
-            break;
-          }
-          y = yAfter - FONT_SIZE * 0.5;
-          currentPar++;
-          if (y < margens.bottom + FONT_SIZE * 1.5) break;
-        }
-        pageIndex++;
-      }
-
-      const pdfBytes = await pdfDoc.save();
-      return Buffer.from(pdfBytes);
-    } catch (error) {
-      console.error('Erro geral ao gerar PDF:', error);
-      throw error;
-    }
-  }
-
-  private processarTemplate(template: string, dados: any): string {
-    return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
-      const keyParts = key.trim().split('.');
-      let value = dados;
-      
-      for (const part of keyParts) {
-        if (value && typeof value === 'object' && part in value) {
-          value = value[part];
-        } else {
-          value = undefined;
-          break;
-        }
-      }
-      
-      return value !== undefined ? value : match;
-    });
-  }
-}
@@ -1,219 +0,0 @@
-import puppeteer from 'puppeteer';
-import { PDFDocument } from 'pdf-lib';
-import fs from 'fs/promises';
-import path from 'path';
-import { prisma } from '../prismaClient';
-
-// Função utilitária para converter pixels em milímetros (1px ≈ 0.264583 mm)
-function pxToMm(px: number | null | undefined): string {
-  if (!px) return '0mm';
-  return (px * 0.264583).toFixed(2) + 'mm';
-}
-
-export class PdfService {
-  // Busca configuração do documento, usando apenas campos válidos do schema
-  private async getConfiguracao() {
-    try {
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' },
-        select: {
-          id: true,
-          timbradoUrl: true,
-          timbradoMarginTop: true,
-          timbradoMarginBottom: true,
-          timbradoMarginLeft: true,
-          timbradoMarginRight: true,
-          templatePadrao: true,
-          margensTemplate: true,
-          criadoEm: true
-        }
-      });
-      // Extrai recuo de primeira linha se existir em margensTemplate
-      let firstLineIndent = '0mm';
-      if (config?.margensTemplate) {
-        try {
-          const margens = typeof config.margensTemplate === 'string' ? JSON.parse(config.margensTemplate) : config.margensTemplate;
-          if (margens && margens.firstLineIndent) {
-            firstLineIndent = `${margens.firstLineIndent}mm`;
-          }
-        } catch (e) {
-          // Se der erro, ignora e usa padrão
-        }
-      }
-      return {
-        timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop ?? 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom ?? 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft ?? 50,
-        timbradoMarginRight: config?.timbradoMarginRight ?? 50,
-        templatePadrao: config?.templatePadrao || '',
-        firstLineIndent
-      };
-    } catch (error) {
-      console.error('Erro ao buscar configuração:', error);
-      throw new Error('Falha ao buscar configuração');
-    }
-  }
-
-  // Gera HTML com timbrado e margens
-  private gerarHTML(content: string, config: any) {
-    // Limpa espaços, quebras de linha e tags vazias do final do conteúdo
-    let cleanContent = content
-      .replace(/(\s|<br\s*\/?>|<p>\s*<\/p>)+$/gi, '')
-      .replace(/(<p>\s*<\/p>)+/gi, '');
-    const timbradoUrl = config.timbradoUrl
-      ? `${process.env.FRONTEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
-      : '';
-    // Adiciona log para debug
-    if (timbradoUrl) {
-      console.log('[PDF] Timbrado inserido no HTML:', timbradoUrl);
-    }
-    return `
-      <!DOCTYPE html>
-      <html>
-      <head>
-        <meta charset="UTF-8">
-        <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap" rel="stylesheet">
-        <style>
-          @page {
-            margin-top: ${pxToMm(config.timbradoMarginTop)};
-            margin-bottom: ${pxToMm(config.timbradoMarginBottom)};
-            margin-left: ${pxToMm(config.timbradoMarginLeft)};
-            margin-right: ${pxToMm(config.timbradoMarginRight)};
-            size: A4;
-          }
-          html, body {
-            height: 100%;
-            margin: 0;
-            padding: 0;
-            font-family: 'Fira Sans', Arial, sans-serif;
-            font-size: 11pt;
-            line-height: 1.5;
-            background: none;
-          }
-          body {
-            position: relative;
-            min-height: 100vh;
-            /* Remove background-image do body para evitar problemas no Puppeteer */
-          }
-          .timbrado-bg {
-            position: fixed;
-            top: 0;
-            left: 0;
-            width: 100vw;
-            height: 100vh;
-            z-index: 0;
-            ${timbradoUrl ? `background-image: url('${timbradoUrl}'); background-size: cover; background-position: center; background-repeat: no-repeat;` : ''}
-            pointer-events: none;
-          }
-          .content {
-            position: relative;
-            z-index: 1;
-            box-sizing: border-box;
-            width: 100%;
-            /* Removido padding-top e padding-bottom para evitar recuo duplo com as margens do PDF */
-            padding-left: ${pxToMm(config.timbradoMarginLeft)};
-            padding-right: ${pxToMm(config.timbradoMarginRight)};
-            overflow-wrap: break-word;
-            word-break: break-word;
-            /* Permite múltiplas páginas e evita corte de conteúdo */
-            break-inside: auto;
-            page-break-inside: auto;
-          }
-          .content p {
-            text-indent: ${config.firstLineIndent || '0mm'};
-          }
-          /* Corrige recuo exagerado apenas na primeira linha do primeiro parágrafo da primeira página */
-          .content p:first-child {
-            text-indent: 0mm !important;
-          }
-          /* Corrige recuo exagerado apenas na última linha do último parágrafo da última página */
-          .content p:last-child {
-            margin-bottom: 0 !important;
-            padding-bottom: 0 !important;
-          }
-        </style>
-      </head>
-      <body>
-        ${timbradoUrl ? '<div class="timbrado-bg"></div>' : ''}
-        <div class="content">
-          ${cleanContent}
-        </div>
-      </body>
-      </html>
-    `;
-  }
-
-  // Gera PDF a partir do HTML, depois sobrepõe o timbrado em cada página
-  async gerarPDF(conteudo: string) {
-    try {
-      const config = await this.getConfiguracao();
-      // Usa templatePadrao se não houver conteúdo
-      const html = this.gerarHTML(conteudo || config.templatePadrao, config);
-      const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
-      const page = await browser.newPage();
-      await page.setContent(html, {
-        waitUntil: ['networkidle0', 'load'],
-        timeout: 30000
-      });
-      const margin = {
-        top: pxToMm(config.timbradoMarginTop),
-        bottom: pxToMm(config.timbradoMarginBottom),
-        left: pxToMm(config.timbradoMarginLeft),
-        right: pxToMm(config.timbradoMarginRight)
-      };
-      const pdfBuffer = await page.pdf({
-        format: 'A4',
-        printBackground: true,
-        margin,
-        preferCSSPageSize: true
-      });
-      await browser.close();
-
-      // Se não houver timbrado, retorna direto
-      if (!config.timbradoUrl) {
-        return Buffer.from(pdfBuffer);
-      }
-
-      // Caminho absoluto do PDF de timbrado
-      const timbradoPath = config.timbradoUrl.startsWith('/uploads')
-        ? path.join(process.cwd(), 'public', config.timbradoUrl)
-        : path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
-      let timbradoBytes: Buffer;
-      try {
-        timbradoBytes = await fs.readFile(timbradoPath);
-      } catch (e) {
-        console.error('Timbrado não encontrado:', timbradoPath);
-        return Buffer.from(pdfBuffer);
-      }
-
-      // Mescla cada página do PDF gerado com o timbrado
-      const pdfDoc = await PDFDocument.load(pdfBuffer);
-      const timbradoDoc = await PDFDocument.load(timbradoBytes);
-      const timbradoPage = timbradoDoc.getPage(0);
-      const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
-      const pageCount = pdfDoc.getPageCount();
-      for (let i = 0; i < pageCount; i++) {
-        const page = pdfDoc.getPage(i);
-        page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
-      }
-      // Remove última página se estiver vazia (sem conteúdo visível)
-      if (pdfDoc.getPageCount() > 1) {
-        const lastPage = pdfDoc.getPage(pdfDoc.getPageCount() - 1);
-        const textContent = lastPage.getTextContent ? await lastPage.getTextContent() : null;
-        // pdf-lib não tem getTextContent, então alternativa: verifica se altura do conteúdo é mínima
-        if (lastPage.getHeight && lastPage.getWidth && lastPage.getHeight() > 0 && lastPage.getWidth() > 0) {
-          // Heurística: verifica se a página tem apenas o timbrado (sem outros objetos)
-          if (lastPage.node.Contents().size() === 0) {
-            pdfDoc.removePage(pdfDoc.getPageCount() - 1);
-          }
-        }
-      }
-      const mergedPdf = await pdfDoc.save();
-      return Buffer.from(mergedPdf);
-    } catch (error) {
-      console.error('Erro ao gerar PDF:', error);
-      throw new Error('Falha ao gerar PDF');
-    }
-  }
-}
@@ -1,47 +1,53 @@
 import puppeteer from 'puppeteer';
+import { PDFDocument } from 'pdf-lib';
+import fs from 'fs/promises';
+import path from 'path';
 import { prisma } from '../prismaClient';

+// Função utilitária para converter pixels em milímetros (1px ≈ 0.264583 mm)
+function pxToMm(px: number | null | undefined): string {
+  if (!px) return '0mm';
+  return (px * 0.264583).toFixed(2) + 'mm';
+}
+
 export class PdfService {
+  // Busca configuração do documento, usando apenas campos válidos do schema
  private async getConfiguracao() {
    try {
-      // Buscar configuração ou usar valores padrão
      const config = await prisma.configuracaoDocumento.findFirst({
        orderBy: { criadoEm: 'desc' },
        select: {
          id: true,
-          headerImageUrl: true,
-          footerImageUrl: true,
-          logoUrl: true,
          timbradoUrl: true,
          timbradoMarginTop: true,
          timbradoMarginBottom: true,
          timbradoMarginLeft: true,
          timbradoMarginRight: true,
+          templatePadrao: true,
+          margensTemplate: true,
          criadoEm: true
        }
      });
-
-      console.log('Configuração encontrada:', config); // Debug
-
-      // Retornar configuração padrão se não existir
+      // Extrai recuo de primeira linha se existir em margensTemplate
+      let firstLineIndent = '0mm';
+      if (config?.margensTemplate) {
+        try {
+          const margens = typeof config.margensTemplate === 'string' ? JSON.parse(config.margensTemplate) : config.margensTemplate;
+          if (margens && margens.firstLineIndent) {
+            firstLineIndent = `${margens.firstLineIndent}mm`;
+          }
+        } catch (e) {
+          // Se der erro, ignora e usa padrão
+        }
+      }
      return {
-        cabecalhoHtml: config?.cabecalhoHtml || `
-          <div style="text-align: center; padding: 20px;">
-            <h2 style="margin:0;font-size:14pt">{{escritorio.nome}}</h2>
-          </div>
-        `,
-        rodapeHtml: config?.rodapeHtml || `
-          <div style="text-align: center; font-size: 10pt;">
-            {{escritorio.endereco}}<br>
-            Tel: {{escritorio.telefone}} | Email: {{escritorio.email}}
-          </div>
-        `,
-        logoUrl: config?.logoUrl || '',
        timbradoUrl: config?.timbradoUrl || '',
-        timbradoMarginTop: config?.timbradoMarginTop || 100,
-        timbradoMarginBottom: config?.timbradoMarginBottom || 50,
-        timbradoMarginLeft: config?.timbradoMarginLeft || 50,
-        timbradoMarginRight: config?.timbradoMarginRight || 50
+        timbradoMarginTop: config?.timbradoMarginTop ?? 100,
+        timbradoMarginBottom: config?.timbradoMarginBottom ?? 50,
+        timbradoMarginLeft: config?.timbradoMarginLeft ?? 50,
+        timbradoMarginRight: config?.timbradoMarginRight ?? 50,
+        templatePadrao: config?.templatePadrao || '',
+        firstLineIndent
      };
    } catch (error) {
      console.error('Erro ao buscar configuração:', error);
@@ -49,13 +55,19 @@ export class PdfService {
    }
  }

+  // Gera HTML com timbrado e margens
  private gerarHTML(content: string, config: any) {
+    // Limpa espaços, quebras de linha e tags vazias do final do conteúdo
+    let cleanContent = content
+      .replace(/(\s|<br\s*\/?>|<p>\s*<\/p>)+$/gi, '')
+      .replace(/(<p>\s*<\/p>)+/gi, '');
    const timbradoUrl = config.timbradoUrl
-      ? `${process.env.BACKEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
+      ? `${process.env.FRONTEND_URL || 'http://localhost:5000'}${config.timbradoUrl}`
      : '';
-
-    console.log('Gerando PDF com timbrado:', timbradoUrl);
-
+    // Adiciona log para debug
+    if (timbradoUrl) {
+      console.log('[PDF] Timbrado inserido no HTML:', timbradoUrl);
+    }
    return `
      <!DOCTYPE html>
      <html>
@@ -64,87 +76,158 @@ export class PdfService {
        <link href="https://fonts.googleapis.com/css2?family=Fira+Sans:wght@400;500;600&display=swap" rel="stylesheet">
        <style>
          @page {
-            margin: 0;
+            margin-top: ${pxToMm(config.timbradoMarginTop)};
+            margin-bottom: ${pxToMm(config.timbradoMarginBottom)};
+            margin-left: ${pxToMm(config.timbradoMarginLeft)};
+            margin-right: ${pxToMm(config.timbradoMarginRight)};
            size: A4;
          }
-          
-          body { 
+          html, body {
+            height: 100%;
            margin: 0;
            padding: 0;
            font-family: 'Fira Sans', Arial, sans-serif;
            font-size: 11pt;
            line-height: 1.5;
+            background: none;
+          }
+          body {
            position: relative;
            min-height: 100vh;
+            /* Remove background-image do body para evitar problemas no Puppeteer */
          }
-
-          .page {
-            position: relative;
-            width: 21cm;
-            min-height: 29.7cm;
-            padding: ${config.timbradoMarginTop || 100}px ${config.timbradoMarginRight || 50}px ${config.timbradoMarginBottom || 50}px ${config.timbradoMarginLeft || 50}px;
-            background: ${timbradoUrl ? `url('${timbradoUrl}')` : 'none'};
-            background-size: cover;
-            background-position: center;
-            background-repeat: no-repeat;
-            box-sizing: border-box;
+          .timbrado-bg {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100vw;
+            height: 100vh;
+            z-index: 0;
+            ${timbradoUrl ? `background-image: url('${timbradoUrl}'); background-size: cover; background-position: center; background-repeat: no-repeat;` : ''}
+            pointer-events: none;
          }
-
          .content {
            position: relative;
            z-index: 1;
+            box-sizing: border-box;
+            width: 100%;
+            /* Removido padding-top e padding-bottom para evitar recuo duplo com as margens do PDF */
+            padding-left: ${pxToMm(config.timbradoMarginLeft)};
+            padding-right: ${pxToMm(config.timbradoMarginRight)};
+            overflow-wrap: break-word;
+            word-break: break-word;
+            /* Permite múltiplas páginas e evita corte de conteúdo */
+            break-inside: auto;
+            page-break-inside: auto;
+          }
+          .content p {
+            text-indent: ${config.firstLineIndent || '0mm'};
+          }
+          /* Corrige recuo exagerado apenas na primeira linha do primeiro parágrafo da primeira página */
+          .content p:first-child {
+            text-indent: 0mm !important;
+          }
+          /* Corrige recuo exagerado apenas na última linha do último parágrafo da última página */
+          .content p:last-child {
+            margin-bottom: 0 !important;
+            padding-bottom: 0 !important;
          }
        </style>
      </head>
      <body>
-        <div class="page">
+        ${timbradoUrl ? '<div class="timbrado-bg"></div>' : ''}
        <div class="content">
-            ${content}
-          </div>
+          ${cleanContent}
        </div>
      </body>
      </html>
    `;
  }

-  async gerarPDF(conteudo: string, escritorio: any) {
+  // Gera PDF a partir do HTML, depois sobrepõe o timbrado em cada página
+  async gerarPDF(conteudo: string) {
    try {
-      const config = await prisma.configuracaoDocumento.findFirst({
-        orderBy: { criadoEm: 'desc' }
-      });
-
-      console.log('Configuração do PDF:', config);
-      
-      const html = this.gerarHTML(conteudo, config);
-      
-      const browser = await puppeteer.launch({
-        headless: 'new',
-        args: ['--no-sandbox']
-      });
-
+      const config = await this.getConfiguracao();
+      // Usa templatePadrao se não houver conteúdo
+      const html = this.gerarHTML(conteudo || config.templatePadrao, config);
+      const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
      const page = await browser.newPage();
-      
-      await page.setViewport({
-        width: 794, // A4 width in pixels (72 dpi)
-        height: 1123,
-        deviceScaleFactor: 2
-      });
-
      await page.setContent(html, {
        waitUntil: ['networkidle0', 'load'],
        timeout: 30000
      });
-
+      const margin = {
+        top: pxToMm(config.timbradoMarginTop),
+        bottom: pxToMm(config.timbradoMarginBottom),
+        left: pxToMm(config.timbradoMarginLeft),
+        right: pxToMm(config.timbradoMarginRight)
+      };
      const pdfBuffer = await page.pdf({
        format: 'A4',
        printBackground: true,
-        margin: { top: '0', right: '0', bottom: '0', left: '0' },
+        margin,
        preferCSSPageSize: true
      });
-
      await browser.close();
-      return Buffer.from(pdfBuffer);

+      // Se não houver timbrado, retorna direto
+      if (!config.timbradoUrl) {
+        return Buffer.from(pdfBuffer);
+      }
+
+      // Caminho absoluto do PDF de timbrado
+      const timbradoPath = config.timbradoUrl.startsWith('/uploads')
+        ? path.join(process.cwd(), 'public', config.timbradoUrl)
+        : path.join(process.cwd(), 'public', 'uploads', path.basename(config.timbradoUrl));
+      let timbradoBytes: Buffer;
+      try {
+        timbradoBytes = await fs.readFile(timbradoPath);
+      } catch (e) {
+        console.error('Timbrado não encontrado:', timbradoPath);
+        return Buffer.from(pdfBuffer);
+      }
+
+      // Mescla cada página do PDF gerado com o timbrado
+      const pdfDoc = await PDFDocument.load(pdfBuffer);
+      const timbradoDoc = await PDFDocument.load(timbradoBytes);
+      const timbradoPage = timbradoDoc.getPage(0);
+      const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
+      const pageCount = pdfDoc.getPageCount();
+      for (let i = 0; i < pageCount; i++) {
+        const page = pdfDoc.getPage(i);
+        page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
+      }
+      // Após mesclar o timbrado
+      const pageCountBefore = pdfDoc.getPageCount();
+      if (pageCountBefore > 1) {
+        // Heurística aprimorada: remove a última página apenas se estiver realmente vazia (sem texto, imagens ou gráficos)
+        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
+        let isBlank = true;
+        // Verifica se há texto
+        const annotations = lastPage.node.Annots;
+        if (annotations && annotations.length > 0) {
+          isBlank = false;
+        }
+        // Verifica se há objetos gráficos (imagens, paths, etc.)
+        if (isBlank && typeof lastPage.node?.Resources === 'function') {
+          const resourcesDict = lastPage.node.Resources();
+          if (resourcesDict && typeof resourcesDict === 'object') {
+            // Corrige: usa PDFName para acessar o XObject
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { PDFName } = require('pdf-lib');
+            const xObject = resourcesDict.get(PDFName.of('XObject'));
+            if (xObject && typeof xObject === 'object' && Object.keys(xObject).length > 0) {
+              isBlank = false;
+            }
+          }
+        }
+        // Só remove se realmente não houver nada
+        if (isBlank) {
+          pdfDoc.removePage(pageCountBefore - 1);
+        }
+      }
+      const mergedPdf = await pdfDoc.save();
+      return Buffer.from(mergedPdf);
    } catch (error) {
      console.error('Erro ao gerar PDF:', error);
      throw new Error('Falha ao gerar PDF');
@@ -187,8 +187,32 @@ export class PdfService {
        return Buffer.from(pdfBuffer);
      }

-      // Mescla cada página do PDF gerado com o timbrado
-      const pdfDoc = await PDFDocument.load(pdfBuffer);
+      // Remove página vazia do final ANTES de mesclar o timbrado
+      let pdfDoc = await PDFDocument.load(pdfBuffer);
+      let pageCountBefore = pdfDoc.getPageCount();
+      if (pageCountBefore > 1) {
+        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
+        const contentStreams = (lastPage as any).node.Contents?.();
+        let isBlank = false;
+
+        if (!contentStreams) {
+          isBlank = true;
+        } else if (Array.isArray(contentStreams)) {
+          isBlank = contentStreams.every(
+            (stream: any) =>
+              !stream.contents ||
+              (typeof stream.contents.length === 'number' && stream.contents.length < 5)
+          );
+        } else if (contentStreams.contents && typeof contentStreams.contents.length === 'number') {
+          isBlank = contentStreams.contents.length < 5;
+        }
+
+        if (isBlank) {
+          pdfDoc.removePage(pageCountBefore - 1);
+        }
+      }
+
+      // Agora sim, mescle o timbrado nas páginas restantes
      const timbradoDoc = await PDFDocument.load(timbradoBytes);
      const timbradoPage = timbradoDoc.getPage(0);
      const [timbradoEmbed] = await pdfDoc.embedPages([timbradoPage]);
@@ -197,16 +221,7 @@ export class PdfService {
        const page = pdfDoc.getPage(i);
        page.drawPage(timbradoEmbed, { x: 0, y: 0, width: page.getWidth(), height: page.getHeight() });
      }
-      // Após mesclar o timbrado
-      const pageCountBefore = pdfDoc.getPageCount();
-      if (pageCountBefore > 1) {
-        // Heurística: remove a última página se ela estiver completamente em branco (sem texto)
-        const lastPage = pdfDoc.getPage(pageCountBefore - 1);
-        const text = await lastPage.getTextContent?.();
-        if (!text || (Array.isArray(text.items) && text.items.length === 0)) {
-          pdfDoc.removePage(pageCountBefore - 1);
-        }
-      }
+
      const mergedPdf = await pdfDoc.save();
      return Buffer.from(mergedPdf);
    } catch (error) {
@@ -35,7 +35,7 @@ export class AuthService {
        email: usuario.email,
      },
      process.env.JWT_SECRET || "default-secret",
-      { expiresIn: "1d" },
+      { expiresIn: "7d" }, // 7 dias para melhor UX
    );

    return {
@@ -1,5 +1,3 @@
-import { Request } from 'express';
-
 declare global {
  namespace Express {
    interface Request {
@@ -11,3 +9,5 @@ declare global {
    }
  }
 }
+
+export {};
@@ -17,6 +17,8 @@ export default defineConfig({
        target: 'http://localhost:5000',
        changeOrigin: true,
        secure: false,
+        timeout: 600000, // 10 minutos para operações longas (PDF, OCR)
+        proxyTimeout: 600000,
      }
    },
    hmr: {
Author	SHA1	Message	Date
rodrigo	8f826ab223	pdf: novo refator do compress Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-28 19:56:28 -03:00
rodrigo	cdc4134b16	pdf: refatorar compressPDF Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-28 19:15:54 -03:00
rodrigo	d381d17435	pdf: accelerate OCR Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-27 20:25:46 -03:00
rodrigo	ab73ea667e	pdf: accelerate OCR Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-27 20:20:07 -03:00
rodrigo	db7b832044	pdf: fix feature Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-27 20:15:07 -03:00
rodrigo	f4afe83db0	pdf: fix route Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-27 19:02:18 -03:00
rodrigo	61a1631519	pdf: add new feature Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>	2026-02-27 17:32:18 -03:00
rodrigo	a63aaeb655	remove arquivo desnecessario Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-27 18:58:13 -03:00
rodrigo	48ea0c7303	undo commit	2025-07-27 18:57:22 -03:00
rodrigo	89b06db89e	Limpeza de codigo Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-27 18:55:29 -03:00
rodrigo	928dfc0443	revert commit	2025-07-27 18:50:37 -03:00
rodrigo	24b5d04fbc	frontend; backend: adiciona sistema novo de gravacao de provas Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-27 18:47:48 -03:00
rodrigo	0750b26208	frontend: fix dashboard PainelFinanceiro Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-27 17:26:25 -03:00
rodrigo	47f2d08b9b	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 17:01:49 -03:00
rodrigo	19f23a540a	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:52:50 -03:00
rodrigo	3e561b46bb	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:43:00 -03:00
rodrigo	3ae50e75d4	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:24:08 -03:00
rodrigo	d69d5b1b0e	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:20:59 -03:00
rodrigo	3f012552e7	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:16:17 -03:00
rodrigo	ae71161860	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:14:08 -03:00
rodrigo	866a3fe539	calculo: fix pensaoalimenticia Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 16:10:18 -03:00
rodrigo	c37a0461bf	dashboard: fix audiencias Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 12:24:20 -03:00
rodrigo	21932e5372	dashboard: fix audiencias Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-16 12:23:27 -03:00
rodrigo	626137276f	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:47:28 -03:00
rodrigo	fc8e96cd58	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:46:08 -03:00
rodrigo	90a098e7db	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:43:12 -03:00
rodrigo	285d829c27	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:40:54 -03:00
rodrigo	0963cab395	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:08:05 -03:00
rodrigo	6300fb98a7	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 22:05:34 -03:00
rodrigo	0a67f95eaf	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:38:51 -03:00
rodrigo	c03c6d1b5a	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:37:02 -03:00
rodrigo	061156e5e7	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:24:46 -03:00
rodrigo	71f5a56cbd	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:21:33 -03:00
rodrigo	683da3264d	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:19:21 -03:00
rodrigo	0475c34d64	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:17:35 -03:00
rodrigo	167766fdfd	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 21:09:34 -03:00
rodrigo	a7c32aa128	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 20:45:55 -03:00
rodrigo	b3d9ebe999	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 20:42:58 -03:00
rodrigo	b713e24fbf	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 20:39:56 -03:00
rodrigo	a4206a7611	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 20:28:16 -03:00
rodrigo	3d919350c8	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:47:49 -03:00
rodrigo	4d22c07151	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:46:14 -03:00
rodrigo	80df7310f3	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:38:23 -03:00
rodrigo	9160939de2	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:32:09 -03:00
rodrigo	9c2df341ea	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:28:40 -03:00
rodrigo	3c00956cf4	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:22:59 -03:00
rodrigo	f5fb1e427d	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:21:28 -03:00
rodrigo	1e08f559ff	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:17:47 -03:00
rodrigo	1ab7bd8f36	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:14:01 -03:00
rodrigo	f782fb36ad	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:12:10 -03:00
rodrigo	af2f0ed649	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:08:55 -03:00
rodrigo	6b89a61dd7	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:07:35 -03:00
rodrigo	7e868dbc46	dashboard: reimaginacao Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo.sousa.577@gmail.com>	2025-07-15 19:06:00 -03:00
Rodrigo B. de Sousa Martins	b9e7de0ca0	backend: fix PDFService.ts	2025-06-11 11:57:33 -03:00
Rodrigo B. de Sousa Martins	0fef046d38	backend: fix PDFService.ts	2025-06-11 11:54:44 -03:00
Rodrigo B. de Sousa Martins	8f6b708d51	backend: fix PDFService.ts	2025-06-11 11:50:31 -03:00
Rodrigo B. de Sousa Martins	db7446f19a	frontend: possibilita edição manual do endereço do cliente Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo@martinsevieira.adv.br>	2025-05-26 13:32:38 -03:00
Rodrigo B. de Sousa Martins	59ea762227	frontend: fix PublicProvaUpload Signed-off-by: Rodrigo B. de Sousa Martins <rodrigo@martinsevieira.adv.br>	2025-05-26 13:08:32 -03:00
rodrigo	fe54b55af0	Fix - Size PDF Signed-off-by: Rodrigo Martins <rodrigo.sousa.577@gmail.com>	2025-04-23 16:01:24 -03:00