# 📚 Exemplos de Uso da API de Predição de Glosas

## 🚀 Iniciando a aplicação

### Com Docker Compose (recomendado):
```bash
# Construir e iniciar
docker-compose up -d

# Ver logs
docker-compose logs -f

# Parar
docker-compose down
```

### Com Docker direto:
```bash
# Construir imagem
docker build -t predicao-glosas .

# Executar container
docker run -d -p 8010:8010 --name predicao-glosas predicao-glosas

# Ver logs
docker logs -f predicao-glosas
```

## 📡 Endpoints da API

### 1. Status da API
```bash
curl http://localhost:8010/
```

### 2. Health Check
```bash
curl http://localhost:8010/health
```

### 3. Listar Modelos Disponíveis
```bash
curl http://localhost:8010/modelos
```

### 4. Predição Individual
```bash
# Consulta simples
curl -X POST http://localhost:8010/predizer \
  -H "Content-Type: application/json" \
  -d '{
    "protocolo": 123456,
    "tipo_guia": 3,
    "id_convenio": 4,
    "cod": 10101012,
    "quantidade": 1
  }'

# Internação com múltiplos procedimentos
curl -X POST http://localhost:8010/predizer \
  -H "Content-Type: application/json" \
  -d '[
    {
      "id_procedimento": "PROC-001",
      "protocolo": 789012,
      "tipo_guia": 1,
      "id_convenio": 13,
      "cod": 31309054,
      "quantidade": 1,
      "tipo_atendimento": 2,
      "via_acesso": 1
    },
    {
      "id_procedimento": "PROC-002",
      "protocolo": 789012,
      "tipo_guia": 1,
      "id_convenio": 13,
      "cod": 31602150,
      "quantidade": 1,
      "tipo_atendimento": 2,
      "via_acesso": 3
    }
  ]'
```

### 5. Predição em Lote
```bash
curl -X POST http://localhost:8010/predizer/batch \
  -H "Content-Type: application/json" \
  -d '[
    {"protocolo": 111, "tipo_guia": 1, "cod": 31309054},
    {"protocolo": 222, "tipo_guia": 2, "cod": 40901220},
    {"protocolo": 333, "tipo_guia": 3, "cod": 10101012}
  ]'
```

## 💻 Exemplos em PHP

### Função para chamar a API:
```php
<?php
function predizerGlosa($dados) {
    $url = 'http://localhost:8010/predizer';
    
    $options = [
        'http' => [
            'header'  => "Content-Type: application/json\r\n",
            'method'  => 'POST',
            'content' => json_encode($dados)
        ]
    ];
    
    $context = stream_context_create($options);
    $result = file_get_contents($url, false, $context);
    
    return json_decode($result, true);
}

// Exemplo de uso
$guia = [
    'protocolo' => 123456,
    'tipo_guia' => 3,
    'cod' => 10101012,
    'quantidade' => 1
];

$resultado = predizerGlosa($guia);

if ($resultado['resultado']['predicao'] == 'glosa_provavel') {
    echo "⚠️ Risco de glosa: " . ($resultado['resultado']['maximo'] * 100) . "%";
} else {
    echo "✅ Baixo risco de glosa";
}
?>
```

### Usando cURL em PHP:
```php
<?php
function analisarGuia($protocolo_dados) {
    $ch = curl_init('http://localhost:8010/predizer');
    
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($protocolo_dados));
    
    $response = curl_exec($ch);
    $httpcode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpcode == 200) {
        return json_decode($response, true);
    } else {
        return ['erro' => 'Falha na requisição', 'http_code' => $httpcode];
    }
}

// Exemplo com múltiplos procedimentos
$internacao = [
    [
        'id_procedimento' => 'PHP-001',
        'protocolo' => 999,
        'tipo_guia' => 1,
        'cod' => 31309054,
        'quantidade' => 1
    ],
    [
        'id_procedimento' => 'PHP-002',
        'protocolo' => 999,
        'tipo_guia' => 1,
        'cod' => 31602150,
        'quantidade' => 2
    ]
];

$resultado = analisarGuia($internacao);
print_r($resultado);
?>
```

## 🐍 Exemplos em Python

```python
import requests

# Configuração
API_URL = "http://localhost:8010/predizer"

# Exemplo 1: Guia única
guia = {
    "protocolo": 123456,
    "tipo_guia": 3,
    "cod": 10101012,
    "quantidade": 1
}

response = requests.post(API_URL, json=guia)
resultado = response.json()

print(f"Risco: {resultado['resultado']['risco']}")
print(f"Probabilidade: {resultado['resultado']['maximo']*100:.1f}%")

# Exemplo 2: Múltiplos procedimentos
procedimentos = [
    {"protocolo": 111, "tipo_guia": 1, "cod": 31309054},
    {"protocolo": 111, "tipo_guia": 1, "cod": 31602150}
]

response = requests.post(API_URL, json=procedimentos)
print(response.json())
```

## 📊 Formato de Resposta

### Sucesso:
```json
{
  "protocolo": 123456,
  "tipo_guia": "Consulta",
  "analise_procedimentos": [
    {
      "id_procedimento": "PROC-001",
      "cod": "10101012",
      "risco": 0.15
    }
  ],
  "resultado": {
    "media": 0.15,
    "maximo": 0.15,
    "risco": "baixo",
    "predicao": "aprovado",
    "threshold": 0.77
  },
  "tempo_processamento_ms": 45.23
}
```

### Erro:
```json
{
  "erro": "Descrição do erro",
  "detalhes": "Informações adicionais"
}
```

## 🔧 Monitoramento

### Ver logs do container:
```bash
docker-compose logs -f predicao-glosas-api
```

### Verificar status:
```bash
docker ps
docker stats predicao-glosas
```

### Acessar container:
```bash
docker exec -it predicao-glosas /bin/bash
```