Como Funciona o Monitoramento SEFAZ

┌─────────────────────────────────────────┐
│   MonitorWorker (Background Service)     │
│   Ciclo a cada 30 segundos               │
└─────────────────┬───────────────────────┘
                  │
        ┌─────────▼─────────┐
        │  Warmup Certificado│
        │  (Inicialização)   │
        └─────────┬─────────┘
                  │
        ┌─────────▼─────────────────────────┐
        │  Filtrar UFs Habilitadas           │
        │  (NFe, NFCe, CTe, DCe)            │
        └─────────┬─────────────────────────┘
                  │
        ┌─────────▼─────────────────────────┐
        │  Separar DCe das Outras Consultas │
        └─────────┬─────────────────────────┘
                  │
      ┌───────────┴───────────┐
      │                       │
┌─────▼─────┐         ┌──────▼──────┐
│  Processar│         │  Processar  │
│  DCe      │         │  NFe/NFCe/  │
│  (Único)  │         │  CTe        │
│           │         │  (Paralelo) │
└───────────┘         └─────────────┘

Content-Type: application/soap+xml; charset=utf-8; action="http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4/nfeStatusServicoNF"
SOAPAction: "http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4/nfeStatusServicoNF"

<?xml version="1.0" encoding="utf-8"?>
<soap12:Envelope xmlns:soap12="http://www.w3.org/2003/05/soap-envelope">
  <soap12:Body>
    <nfeDadosMsg xmlns="http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4">
      <consStatServ versao="4.00" xmlns="http://www.portalfiscal.inf.br/nfe">
        <tpAmb>1</tpAmb>          <!-- 1=Produção, 2=Homologação -->
        <cUF>32</cUF>              <!-- Código da UF (32=ES) -->
        <xServ>STATUS</xServ>      <!-- Serviço: STATUS -->
      </consStatServ>
    </nfeDadosMsg>
  </soap12:Body>
</soap12:Envelope>

var certificado = await certificateService.GetCertificateAsync();
// Certificado é usado para autenticação SSL na requisição HTTPS

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
  <soap:Body>
    <nfeResultMsg xmlns="http://www.portalfiscal.inf.br/nfe/wsdl/NFeStatusServico4">
      <retConsStatServ versao="4.00" xmlns="http://www.portalfiscal.inf.br/nfe">
        <tpAmb>1</tpAmb>
        <verAplic>SP_NFE_PL_009h</verAplic>
        <cStat>107</cStat>
        <xMotivo>Serviço em Operação</xMotivo>
        <cUF>35</cUF>
        <dhRecbto>2025-12-26T10:00:00-03:00</dhRecbto>
        <tMed>1000</tMed>
      </retConsStatServ>
    </nfeResultMsg>
  </soap:Body>
</soap:Envelope>

var stopwatch = Stopwatch.StartNew();
var resultado = await soapService.ConsultarStatusAsync(url, certificado, ambiente, codigoUf, ct);
stopwatch.Stop();
var latencyMs = stopwatch.ElapsedMilliseconds; // Tempo total em milissegundos

// Condições para tentar SVC:
bool deveTentarSvc = 
    (falhaConexao || avisoContingencia)  // cStat = "999" ou "113"
    && !IsSvcDisabled(resultado)          // SVC não está desabilitado (cStat != "114")
    && _options.TentarContingencia        // Configuração permite
    && helper.UsaServidorContingencia(uf); // UF suporta SVC

if (deveTentarSvc) {
    // Tenta servidor de contingência
    var resultadoSvc = await soapService.ConsultarStatusAsync(urlSvc, ...);
}

1. Consulta Servidor Principal
   ↓
2. Verifica cStat:
   - "999" (erro/timeout) → Tenta SVC
   - "113" (contingência) → Tenta SVC
   - "107" (operacional) → Retorna resultado
   ↓
3. Se necessário, consulta Servidor de Contingência (SVC)
   ↓
4. Retorna melhor resultado disponível

MonitorWorker (Background Service)
    ↓
CheckStatusWithRetryAsync (para cada UF)
    ↓
1. Verificar Cache (evita consultas desnecessárias)
    ↓
2. Consultar Status SEFAZ
    ├── SefazStatusService.ConsultarStatusAsync()
    │   ├── Determina tipo de serviço (NFe, NFCe, CTe, DCe)
    │   ├── Obtém URL do endpoint
    │   └── Executa consulta com contingência
    │       ├── ExecutarConsultaComContingenciaAsync()
    │       │   ├── Consulta servidor principal
    │       │   └── Tenta SVC se necessário
    │       └── Retorna SefazStatusResult
    ↓
3. Medir Latência (Stopwatch)
    ↓
4. Mapear Resultado (SefazResultMapper)
    ↓
5. Persistir no Redis (MonitorSefazUseCase)
    └── RedisStatusService.InsertResultAsync()

private async Task CheckStatusWithRetryAsync(UfConfig config, CancellationToken token)
{
    // 1. Verificar cache (evita chamadas desnecessárias)
    if (await redis.HasRecentUpdateAsync(config.UF, serviceName))
        return;

    // 2. Executar consulta à SEFAZ
    var stopwatch = Stopwatch.StartNew();
    var sefazResult = await sefazStatusService.ConsultarStatusAsync(
        config.UF,
        ServiceTypeMapper.ToSefazServiceType(config.ServiceType),
        token);
    stopwatch.Stop();

    // 3. Mapear e persistir resultado
    var result = SefazResultMapper.ToMonitorResult(
        sefazResult,
        config.UF,
        serviceName,
        stopwatch.ElapsedMilliseconds);

    await monitorUseCase.ExecuteAsync(result);
}

public async Task<SefazStatusResult> ConsultarStatusAsync(...)
{
    // 1. Criar envelope SOAP
    var envelope = CriarSoapEnvelope(ambiente, codigoUf, isSoap12);

    // 2. Enviar requisição HTTP POST
    using var request = new HttpRequestMessage(HttpMethod.Post, url);
    request.Content = new StringContent(envelope, Encoding.UTF8, "application/soap+xml");

    // 3. Executar requisição com certificado
    using var response = await httpClient.SendAsync(request, ct);
    var responseXml = await response.Content.ReadAsStringAsync(ct);

    // 4. Parsear resposta XML
    return ParsearRespostaSoap(responseXml);
}

if (await redis.HasRecentUpdateAsync(config.UF, serviceName))
    return; // Pula consulta desnecessária

await Parallel.ForEachAsync(otherConfigs, new ParallelOptions 
{ 
    MaxDegreeOfParallelism = 5,  // Limite de concorrência
    CancellationToken = stoppingToken 
}, async (config, token) =>
{
    await CheckStatusWithRetryAsync(config, token);
});

// Consulta única para todos os estados
var sefazResult = await sefazStatusService.ConsultarStatusAsync(
    firstConfig.UF, // Qualquer UF serve
    ServiceType.DCe,
    token);

// Replica resultado para todos os estados
await Task.WhenAll(dceConfigs.Select(config => 
    monitorUseCase.ExecuteAsync(mappedResult)));

// Tenta SOAP 1.2 primeiro (padrão NF-e 4.0)
var resultado = await ExecutarRequestAsync(url, ambiente, codigoUf, httpClient, true, ct);

// Se falhar por incompatibilidade, tenta SOAP 1.1
if (resultado.CStat == "999" && resultado.XMotivo?.Contains("VersionMismatch"))
    resultado = await ExecutarRequestAsync(url, ambiente, codigoUf, httpClient, false, ct);

MonitorResult {
    UF: "SP",                    // Unidade Federativa
    Service: "NFeStatusServico", // Tipo de serviço
    Status: "Operacional",       // Status legível
    CStat: "107",                // Código de status SEFAZ
    XMotivo: "Serviço em Operação", // Motivo
    LatencyMs: 1234,             // Latência em milissegundos
    Success: true,               // Sucesso na consulta
    Timestamp: DateTime.UtcNow,  // Quando foi consultado
    ContingencyInfo: {...}       // Info de contingência (se aplicável)
}