# Invalidação Inteligente de Cache após Sincronização

## Problema Identificado

Quando uma integração era executada manualmente, o banco de dados era atualizado imediatamente, mas a página levava até **5 minutos** para mostrar os novos dados devido ao cache do dashboard.

**Fluxo problemático:**
1. ✅ Integração executada → Banco atualizado
2. ⏳ Cache ainda válido (até 5 min) → Dados antigos exibidos
3. ⏳ Usuário espera 5 minutos...
4. ✅ Cache expira → Novos dados aparecem

## Solução Implementada

Agora o sistema **verifica se houve sincronização recente** e **invalida o cache automaticamente** antes de usá-lo.

### Como Funciona

**Novo fluxo inteligente:**
1. ✅ Integração executada → Banco atualizado
2. 🔍 Sistema verifica: "Houve sincronização há menos de 5 minutos?"
3. ✅ SIM → Cache invalidado imediatamente
4. 🔄 Dashboard recarregado com novos dados
5. ❌ NÃO → Usa cache normal (5 minutos)

## Arquivos Modificados

### 1. [app/lib/SimpleCache.php](../app/lib/SimpleCache.php)

Adicionado novo método público:

```php
/**
 * Verifica se houve sincronização recente e invalida cache se necessário
 * Se a última sincronização foi há menos de 5 minutos, o cache é expirado imediatamente
 * @param \PDO $pdo Conexão com banco de dados
 * @param int $cdempresa ID da empresa
 * @param int $minutosThreshold Threshold em minutos (padrão: 5)
 * @return bool True se cache foi invalidado, false caso contrário
 */
public static function checkRecentSyncAndInvalidate(\PDO $pdo, int $cdempresa, int $minutosThreshold = 5): bool
```

**Lógica:**
- Busca a **última sincronização bem-sucedida** na tabela `integracao_log`
- Calcula a diferença em minutos entre agora e a última sincronização
- Se diferença ≤ threshold (5 min): **invalida o cache**
- Retorna `true` se invalidou, `false` caso contrário

### 2. [app/modules/home.php](../app/modules/home.php)

Adicionada verificação **antes** de buscar o cache:

```php
// ⚡ NOVIDADE: Se houve sincronização recente (< 5 min), invalida cache automaticamente
SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresaSessao, 5);

$dados = SimpleCache::get($cacheKey);
```

## Comportamento

### Cenário 1: Dashboard normal (sem sincronizações recentes)
```
├─ Verifica: última sincronização > 5 min?
├─ SIM → Cache válido, usa dados em cache
├─ TTL: 5 minutos padrão
└─ Performance: ⚡ Rápido (sem query ao banco)
```

### Cenário 2: Dashboard após integração manual
```
├─ Verifica: última sincronização ≤ 5 min?
├─ SIM → Cache invalidado imediatamente
├─ Recarrega dados do banco (primeira vez)
├─ Novo cache gerado com TTL de 5 minutos
└─ Usuário vê dados atualizados: ✅ Imediato
```

### Cenário 3: Múltiplas integrações em sequência
```
1ª integração
├─ Verifica: última sincronização ≤ 5 min?
├─ SIM → Cache invalidado
└─ Dashboard recarregado

2ª integração (menos de 5 min depois)
├─ Verifica: última sincronização ≤ 5 min?
├─ SIM → Cache invalidado novamente
└─ Dashboard recarregado com dados mais novos
```

## Detalhes Técnicos

### Query executada

```sql
SELECT MAX(dthsinc) as ultima_sinc 
FROM back.integracao_log
WHERE cdempresa = :emp 
AND flstatus = 'sucesso'
LIMIT 1
```

- Busca **apenas sincronizações bem-sucedidas** (`flstatus = 'sucesso'`)
- Ignora sincronizações com erro, para não quebrar a experiência
- Usa índice: `idx_intlog_dthsinc`

### Parâmetro configurável

O método aceita um terceiro parâmetro para customizar o threshold:

```php
// Invalida cache se sincronização há menos de 10 minutos
SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresa, 10);

// Invalida cache se sincronização há menos de 1 minuto
SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresa, 1);
```

## Benefícios

| Benefício | Antes | Depois |
|-----------|-------|--------|
| **Integração manual** | 5 min de espera | ✅ Imediato |
| **Integração automática** | 5 min de espera | ✅ Imediato |
| **Performance** | Sempre em cache | ⚡ Inteligente |
| **Dados stale** | Sim (5 min) | ⏱️ Máximo 5 min |
| **Queries ao banco** | 1 a cada 5 min | Apenas quando necessário |

## Tratamento de Erros

O método é **seguro** e não quebra se houver erro:

```php
try {
    // Query ao banco
} catch (\Exception $e) {
    // Se falhar, apenas retorna false
    // Cache continua funcionando normalmente
    return false;
}
```

Isso significa:
- ✅ Conexão com banco indisponível? Continua usando cache
- ✅ Tabela não existe? Código não quebra
- ✅ Permissão negada? Cache mantém funcionando

## Próximos Passos (Opcional)

### Adicionar notificação visual
```php
if (SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresa, 5)) {
    // Cache foi invalidado - mostrar toast/notificação
    $_SESSION['cache_invalidated'] = true;
}
```

### Expandir para outros módulos
```php
// Em outros módulos que usem cache
SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresa, 5);
```

### Monitorar invalidações
```php
$start = microtime(true);
$invalidated = SimpleCache::checkRecentSyncAndInvalidate($pdo, $cdempresa);
$time = (microtime(true) - $start) * 1000;

if ($invalidated) {
    error_log("Cache invalidado em {$time}ms");
}
```

---

**Implementado em:** 23 de Janeiro de 2026  
**Status:** ✅ Produção
