# 📁 ESTRUTURA DO PROJETO REXMULTITRADE

## Árvore de Diretórios

```
d:\xampp\htdocs\projetos\rexmultitrade\
│
├── 📄 ARQUIVOS PRINCIPAIS (Robô)
│   ├── rexmultitrade.py                 ⭐ Robô principal (Python)
│   ├── configuracoes.json            ⚙️ Configuração de moedas
│   └── estado_robos.json             📊 Estado atual (JSON)
│
├── 🌐 INTERFACE WEB (PHP)
│   ├── rexmultitrade_dashboard.php   📈 Dashboard em tempo real
│   └── api.php                       🔗 API REST para SQLite
│
├── 🗂️ BANCO DE DADOS
│   ├── trades.db                     💾 Banco SQLite (auto-criado)
│   │   ├── trades (ID, symbol, side, quantity, price, tipo, timestamp)
│   │   └── daily_results (data, trades_count, ganho_total)
│   │
│   └── logs/
│       └── log_trades.log            📋 Log rotativo (20MB, 3 backups)
│
├── 📚 DOCUMENTAÇÃO
│   ├── README.md                     📖 Guia completo
│   ├── CUSTOMIZACAO.md              🔧 Como estender
│   └── ESTRUTURA.md                 📁 Este arquivo
│
├── 🧪 TESTES & SCRIPTS
│   ├── teste_instalacao.py           ✓ Validação pré-execução
│   ├── iniciar.bat                   ▶️ Menu interativo Windows
│   └── requirements.txt              📦 Dependências (NENHUMA!)
│
└── 🎨 ASSETS (Web)
    └── assets/
        ├── css/
        ├── js/
        └── img/
```

## 📊 TAMANHO E MÉTRICAS

| Arquivo | Linhas | Tamanho | Descrição |
|---------|--------|--------|-----------|
| rexmultitrade.py | 760+ | 28 KB | Robô completo com 4 classes |
| rexmultitrade_dashboard.php | 250+ | 12 KB | Interface web responsiva |
| api.php | 180+ | 8 KB | API REST SQLite |
| README.md | 500+ | 25 KB | Documentação completa |
| CUSTOMIZACAO.md | 300+ | 15 KB | Exemplos de extensão |
| teste_instalacao.py | 200+ | 9 KB | Script de validação |
| **TOTAL** | **2200+** | **~97 KB** | Projeto leve e eficiente |

## 🔄 FLUXO DE DADOS

```
┌─────────────────────────────────────────────────────────────┐
│                    REXMULTITRADE                            │
└─────────────────────────────────────────────────────────────┘

ENTRADA (Binance API)
        ↓
    [rexmultitrade.py]
        ↓
    ┌───────────────────────────────────────┐
    │ Para cada moeda (loop 2-3 seg):       │
    │                                       │
    │ 1. BinanceAPI.obter_candles()        │
    │ 2. AnalisadorMercado.calcular_rsi()  │
    │ 3. AnalisadorMercado.analise_30dias()│
    │ 4. EstrategiaTrading.dever_comprar() │
    │ 5. EstrategiaTrading.dever_vender()  │
    │ 6. BinanceAPI.place_market_order()   │
    │ 7. RoboTrader.registrar_trade()      │
    │                                       │
    │ Salvar: estado_robos.json            │
    │         trades.db (via api.php)      │
    │         log_trades.log               │
    └───────────────────────────────────────┘
        ↓
SAÍDA (Banco + Logs)
        ↓
    [Dashboard Web]
        ↓
    ┌───────────────────────────────────────┐
    │ PHP Lê:                               │
    │ • estado_robos.json                  │
    │ • log_trades.log (últimas 50 linhas) │
    │ • trades.db (últimos 7 dias)         │
    │                                       │
    │ Exibe via AJAX (atualiza 5s)         │
    └───────────────────────────────────────┘

USUÁRIO VÊ (em tempo real)
    ↓
    Status por moeda
    ├─ Capital atual
    ├─ Ganho %
    ├─ Trades executados
    └─ Preço entrada
    
    Últimos trades
    ├─ Data/hora
    ├─ Par
    ├─ Tipo (BUY/SELL)
    ├─ Quantidade
    └─ Preço
    
    Logs recentes
    └─ Eventos do robô
```

## 🎯 CICLO DE EXECUÇÃO (2-3 SEGUNDOS)

```
[INICIAR CICLO]
        │
        ├─→ Sincronizar timestamp com Binance
        │
        ├─→ Para MOEDA 1 (TRX/USDT):
        │   ├─ Obter 500 candles 3m
        │   ├─ Calcular RSI (5, 14, 21)
        │   ├─ Calcular ATR
        │   ├─ Verificar volume
        │   ├─ Análise 30 dias (cache 1h)
        │   │
        │   ├─ SE não em posição:
        │   │   ├─ Verificar COMPRA?
        │   │   │   ├─ RSI baixo? ✓
        │   │   │   ├─ Volume alto? ✓
        │   │   │   ├─ Melhor hora? ✓
        │   │   │   └─→ EXECUTAR BUY
        │   │
        │   └─ SE em posição:
        │       ├─ Atualizar trailing stop
        │       ├─ Verificar VENDA?
        │       │   ├─ RSI alto? ✓
        │       │   ├─ Melhor hora? ✓
        │       │   ├─ Ou trailing? ✓
        │       │   └─→ EXECUTAR SELL
        │       └─ Registrar em BD
        │
        ├─→ Para MOEDA 2 (XRP/USDT):
        │   └─ (Mesmo processo...)
        │
        ├─→ Para MOEDA 3 (DOGE/USDT):
        │   └─ (Mesmo processo...)
        │
        └─→ Salvar estado (JSON) + Aguardar 2-3 seg
                        │
                        ↓
                [PRÓXIMO CICLO]
```

## 🔌 CLASSES PYTHON

### BinanceAPI
```python
├── __init__(api_key, api_secret)
├── _fazer_requisicao(metodo, endpoint, params, assinado)
├── sincronizar_timestamp()          # Resolve -1021
├── obter_candles(symbol, interval)
├── obter_ticker(symbol)
├── obter_saldo(asset)
└── place_market_order(symbol, side, quantity)
```

### AnalisadorMercado
```python
├── __init__(binance_api, config)
├── calcular_rsi(closes, period)
├── calcular_atr(highs, lows, closes, period)
├── obter_candles_preparados(symbol)
├── calcular_triple_rsi(closes)
├── verificar_volume_alto(volumes)
├── obter_melhores_precos_30dias(symbol)
├── esta_no_melhor_horario_compra(analise)
└── esta_no_melhor_horario_venda(analise)
```

### EstrategiaTrading
```python
├── __init__(analisador, config)
├── dever_comprar(symbol, dados, padroes)
├── dever_vender(symbol, dados, padroes, preço_entrada, preço_atual)
└── calcular_trailing_stop(preco_atual, preco_max)
```

### RoboTrader
```python
├── __init__(config_file)
├── _carregar_config()
├── _carregar_estado()
├── _salvar_estado()
├── registrar_trade(symbol, side, qty, price)  # → api.php
├── processar_moeda(moeda_config)
├── executar_ciclo()
└── executar()                        # Loop infinito
```

## 📝 ENDPOINTS API PHP

```
GET/POST http://localhost/projetos/rexmultitrade/api.php

┌─────────────────────────────────────────────┐
│ acao=registrar_trade                        │
├─────────────────────────────────────────────┤
│ POST symbol, side, quantity, price, tipo    │
│ RETORNA: {sucesso: true, id: 123}          │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ acao=obter_trades                           │
├─────────────────────────────────────────────┤
│ GET ?symbol=TRXUSDT&dias=7                  │
│ RETORNA: {trades: [...]}                   │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ acao=obter_resumo                           │
├─────────────────────────────────────────────┤
│ GET ?symbol=TRXUSDT                         │
│ RETORNA: {total_trades, ganho_total, ...}  │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│ acao=obter_status                           │
├─────────────────────────────────────────────┤
│ GET (sem parâmetros)                        │
│ RETORNA: {estado, config_moedas, logs}     │
└─────────────────────────────────────────────┘
```

## 💾 ESTRUTURA SQLite

### Tabela: trades
```sql
CREATE TABLE trades (
    id INTEGER PRIMARY KEY,
    symbol TEXT,           -- TRXUSDT, XRPUSDT, etc
    side TEXT,             -- BUY, SELL
    quantity REAL,         -- 1250.5
    price REAL,           -- 0.08012
    tipo TEXT,            -- compra_padrao, venda_padrao
    timestamp INTEGER,    -- Unix timestamp
    created_at DATETIME   -- Auto
)
```

### Tabela: daily_results
```sql
CREATE TABLE daily_results (
    id INTEGER PRIMARY KEY,
    data_dia TEXT UNIQUE, -- YYYY-MM-DD
    trades_count INTEGER,
    ganho_total REAL,
    criado_em DATETIME,
    atualizado_em DATETIME
)
```

## 🚀 SEQUÊNCIA DE INICIALIZAÇÃO

```
1. Usuario executa: python rexmultitrade.py
            ↓
2. RoboTrader.__init__()
   ├─ Carregar configuracoes.json
   ├─ Carregar estado_robos.json
   ├─ Inicializar BinanceAPI
   ├─ Sincronizar timestamp
   ├─ Inicializar AnalisadorMercado
   └─ Inicializar EstrategiaTrading
            ↓
3. Log inicial (moedas, timeframe, ciclo)
            ↓
4. Loop infinito: executar_ciclo() a cada 2-3s
   ├─ Para cada moeda
   ├─ Processar compra/venda
   ├─ Registrar em BD
   ├─ Atualizar estado JSON
   └─ Log
            ↓
5. Dashboard acessa via API
   ├─ Dashboard.php → api.php?acao=obter_status
   ├─ api.php lê estado_robos.json
   ├─ api.php lê trades.db
   ├─ api.php lê log_trades.log
   └─ Retorna JSON
            ↓
6. Usuario vê em tempo real:
   - Status de cada moeda
   - Últimos trades
   - Últimos logs
   - Dashboard atualiza a cada 5s
```

## 📊 FLUXO DE DADOS JSON

### configuracoes.json
```json
{
  "binance_api_key": "...",
  "moedas": [
    {"par": "TRX/USDT", "symbol": "TRXUSDT", "capital": 100, "agressividade": 0.98}
  ],
  "indicadores": {"rsi_periods": [5,14,21], "rsi_minimo_compra": 35}
}
```

### estado_robos.json
```json
{
  "timestamp_sincronizacao": 1234567890,
  "robos": {
    "TRXUSDT": {
      "capital_atual": 102.50,
      "ganho_percentual": 2.50,
      "em_posicao": true,
      "preco_entrada": 0.08,
      "quantidade": 1280.625,
      "trades_realizados": 5
    }
  }
}
```

## ⚡ PERFORMANCE

- **Tempo de ciclo**: 2-3 segundos (configurável)
- **Consumo RAM**: ~50-100 MB
- **Consumo CPU**: ~1-2% em repouso
- **Requisições API**: 3-5 por ciclo por moeda
- **Rate limit Binance**: 1200 requests/min (seguro)
- **Logging**: 20 MB rotativo (eficiente)

## 🔐 SEGURANÇA

- ✓ API Key + Secret criptografadas (HTTPS)
- ✓ Timestamp sincronizado (erro -1021)
- ✓ Logging completo (auditoria)
- ✓ Validação de ordens antes de executar
- ✓ Banco de dados em SQLite local
- ✓ Sem exposição de dados sensíveis em logs

---

**Pronto para usar!** 🚀