Análise do Setor de Commodities Brasil 2026: VALE3, SUZB3, KLBN11 e Mais

┌─────────────────────────────────────────────────────────────────┐
│                ECOSSISTEMA DE COMMODITIES NA B3                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│   MINERAÇÃO           PAPEL E CELULOSE     SIDERURGIA          │
│   ┌─────────────┐     ┌─────────────┐     ┌─────────────┐      │
│   │ VALE3       │     │ SUZB3       │     │ CSNA3       │      │
│   │ CMIN3       │     │ KLBN11      │     │ GGBR4       │      │
│   │             │     │ RANI3       │     │ USIM5       │      │
│   └─────────────┘     └─────────────┘     └─────────────┘      │
│                                                                 │
│   PETRÓLEO E GÁS      AGRONEGÓCIO         FRIGORÍFICOS         │
│   ┌─────────────┐     ┌─────────────┐     ┌─────────────┐      │
│   │ PETR4       │     │ SLCE3       │     │ JBSS3       │      │
│   │ PRIO3       │     │ AGRO3       │     │ BRFS3       │      │
│   │ RECV3       │     │ SMTO3       │     │ MRFG3       │      │
│   │ ENAT3       │     │ TTEN3       │     │ BEEF3       │      │
│   └─────────────┘     └─────────────┘     └─────────────┘      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

def simular_protecao_cambial(receita_usd, custo_brl, dolar_inicial, dolar_final):
    """
    Simula o efeito da desvalorização do real em empresas exportadoras
    """
    # Cenário inicial
    receita_brl_inicial = receita_usd * dolar_inicial
    lucro_inicial = receita_brl_inicial - custo_brl
    margem_inicial = (lucro_inicial / receita_brl_inicial) * 100
    
    # Cenário com dólar mais alto
    receita_brl_final = receita_usd * dolar_final
    lucro_final = receita_brl_final - custo_brl  # Custos em BRL ficam estáveis
    margem_final = (lucro_final / receita_brl_final) * 100
    
    variacao_lucro = ((lucro_final / lucro_inicial) - 1) * 100
    
    return {
        "dolar_inicial": dolar_inicial,
        "dolar_final": dolar_final,
        "variacao_dolar": round(((dolar_final/dolar_inicial) - 1) * 100, 1),
        "lucro_inicial": round(lucro_inicial, 0),
        "lucro_final": round(lucro_final, 0),
        "variacao_lucro": round(variacao_lucro, 1),
        "alavancagem_operacional": round(variacao_lucro / ((dolar_final/dolar_inicial - 1) * 100), 2)
    }

resultado = simular_protecao_cambial(
    receita_usd=1_000_000_000,
    custo_brl=3_000_000_000,
    dolar_inicial=5.00,
    dolar_final=6.00
)

print(f"Variação do dólar: +{resultado['variacao_dolar']}%")
print(f"Variação do lucro: +{resultado['variacao_lucro']}%")
print(f"Alavancagem: {resultado['alavancagem_operacional']}x")

EFEITO DO DÓLAR NO LUCRO DE EXPORTADORAS

Cenário: Dólar sobe de R$ 5,00 para R$ 6,00 (+20%)

┌────────────────────────────────────────────────────────┐
│                                                        │
│  RECEITA (USD → BRL)                                  │
│  ████████████████████████████████████  +20%           │
│                                                        │
│  CUSTOS (BRL)                                         │
│  ████████████████████████  0% (estável)               │
│                                                        │
│  LUCRO                                                │
│  ████████████████████████████████████████████  +50%+  │
│                                                        │
│  → Lucro cresce MAIS que o dólar (alavancagem)       │
│                                                        │
└────────────────────────────────────────────────────────┘

def analisar_drivers_minerio():
    """
    Analisa fatores que influenciam preço do minério de ferro
    """
    drivers = {
        "demanda_china": {
            "peso": 65,  # % do consumo global
            "indicadores": ["PMI industrial", "Produção de aço", "Construção civil"]
        },
        "oferta_global": {
            "principais_players": ["Vale (Brasil)", "Rio Tinto (Austrália)", "BHP (Austrália)"],
            "risco": "Concentração - top 3 = 60% da oferta"
        },
        "custos_producao": {
            "vale_c1_cost": 20.5,  # USD/ton (aproximado)
            "benchmark_preco": 100,  # USD/ton (referência)
            "margem_estimada": 79.5  # USD/ton
        },
        "qualidade": {
            "vale_fe_content": 65,  # % teor de ferro
            "mercado_media": 62,
            "premio_qualidade": "Sim - minério de alta qualidade"
        }
    }
    return drivers

drivers = analisar_drivers_minerio()
print(f"Peso da China: {drivers['demanda_china']['peso']}% do consumo global")
print(f"Custo C1 Vale: USD {drivers['custos_producao']['vale_c1_cost']}/ton")

CICLO DO PREÇO DA CELULOSE

Preço USD/ton
    │
1200├─────────────────────────────────●────────────
    │                              ╱  ╲
1000├─────────────────────────●───╱    ╲─────────
    │                      ╱                ╲
 800├───────────────●─────╯                  ╲────
    │            ╱                             ╲
 600├─────●─────╯                               ╲─
    │  ╱                                         
 400├─●──────────────────────────────────────────
    │
    └──2019──2020──2021──2022──2023──2024──2026──

FASES DO CICLO:
1. Baixa demanda → Preços caem → Produtores cortam CAPEX
2. Oferta reduz → Estoques baixam → Preços sobem
3. Alta margem → Produtores investem → Nova capacidade
4. Oferta sobe → Preços caem → Ciclo reinicia

Duração média do ciclo: 5-7 anos

def analisar_cadeia_siderurgica():
    """
    Analisa a cadeia produtiva e margens da siderurgia
    """
    cadeia = {
        "mineracao": {
            "empresa": "VALE3",
            "margem_ebitda_tipica": "45-55%",
            "posicao": "Fornecedor"
        },
        "siderurgia": {
            "empresas": ["CSNA3", "GGBR4", "USIM5"],
            "margem_ebitda_tipica": "15-25%",
            "posicao": "Transformação"
        },
        "distribuicao": {
            "empresas": ["GOAU4"],
            "margem_tipica": "3-8%",
            "posicao": "Intermediário"
        }
    }
    
    # Spread aço vs minério
    preco_aco = 4500  # BRL/ton (aproximado)
    preco_minerio = 600  # BRL/ton (aproximado, convertido)
    
    spread = preco_aco - (preco_minerio * 1.5)  # 1.5 ton minério = 1 ton aço
    
    return {
        "cadeia": cadeia,
        "spread_aco_minerio": spread,
        "comentario": "Spread comprimido = margens ruins para siderurgia"
    }

import requests

API_TOKEN = "seu_token_aqui"
BASE_URL = "https://brapi.dev/api"

def comparar_petroleo():
    """
    Compara empresas de petróleo na B3
    """
    tickers = ["PETR4", "PRIO3", "RECV3", "RRRP3", "ENAT3"]
    
    url = f"{BASE_URL}/quote/{','.join(tickers)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code != 200:
        return None
    
    dados = response.json()["results"]
    
    comparativo = []
    for empresa in dados:
        ev = empresa.get("enterpriseValue", 0) or 0
        ebitda = empresa.get("ebitda", 0) or 0
        
        comparativo.append({
            "ticker": empresa.get("symbol"),
            "preco": empresa.get("regularMarketPrice"),
            "pl": empresa.get("priceEarnings"),
            "ev_ebitda": round(ev/ebitda, 2) if ebitda > 0 else None,
            "dy": empresa.get("dividendYield"),
            "margem": empresa.get("netMargin")
        })
    
    return sorted(comparativo, key=lambda x: x["ev_ebitda"] or 999)

resultado = comparar_petroleo()

def analisar_cash_cost(custo_total, producao_tons, preco_venda):
    """
    Analisa custo caixa e margem operacional
    """
    cash_cost = custo_total / producao_tons
    margem_unitaria = preco_venda - cash_cost
    margem_pct = (margem_unitaria / preco_venda) * 100
    
    # Breakeven
    breakeven_price = cash_cost
    buffer_vs_breakeven = ((preco_venda / breakeven_price) - 1) * 100
    
    return {
        "cash_cost": round(cash_cost, 2),
        "preco_venda": preco_venda,
        "margem_unitaria": round(margem_unitaria, 2),
        "margem_pct": round(margem_pct, 1),
        "breakeven": round(breakeven_price, 2),
        "buffer_breakeven": round(buffer_vs_breakeven, 1)
    }

# Exemplo: Vale - Minério de ferro
analise = analisar_cash_cost(
    custo_total=4_100_000_000,  # USD 4.1 bilhões
    producao_tons=200_000_000,   # 200 milhões de toneladas
    preco_venda=100              # USD 100/ton
)

print(f"Cash Cost: USD {analise['cash_cost']}/ton")
print(f"Margem: {analise['margem_pct']}%")
print(f"Buffer vs Breakeven: {analise['buffer_breakeven']}%")

def avaliar_endividamento_commodity(divida_liquida, ebitda, setor):
    """
    Avalia endividamento considerando ciclicidade do setor
    """
    ratio = divida_liquida / ebitda if ebitda > 0 else float('inf')
    
    # Limites variam por setor
    limites = {
        "mineracao": {"ideal": 1.0, "aceitavel": 2.0, "risco": 3.0},
        "petroleo": {"ideal": 1.5, "aceitavel": 2.5, "risco": 3.5},
        "celulose": {"ideal": 2.0, "aceitavel": 3.0, "risco": 4.0},
        "siderurgia": {"ideal": 1.5, "aceitavel": 2.5, "risco": 3.5}
    }
    
    limite = limites.get(setor, limites["mineracao"])
    
    if ratio <= limite["ideal"]:
        avaliacao = "Excelente - Baixa alavancagem"
    elif ratio <= limite["aceitavel"]:
        avaliacao = "Aceitável - Alavancagem moderada"
    elif ratio <= limite["risco"]:
        avaliacao = "Atenção - Alavancagem elevada"
    else:
        avaliacao = "Risco - Muito alavancada"
    
    return {
        "div_liq_ebitda": round(ratio, 2),
        "limite_ideal": limite["ideal"],
        "limite_risco": limite["risco"],
        "avaliacao": avaliacao
    }

# Exemplos
print("VALE3:", avaliar_endividamento_commodity(66_000, 60_000, "mineracao"))
print("SUZB3:", avaliar_endividamento_commodity(69_000, 37_000, "celulose"))

def calcular_ebitda_tonelada(empresas_dados):
    """
    Calcula EBITDA por tonelada para comparação
    """
    resultados = []
    
    for empresa in empresas_dados:
        ebitda_ton = empresa["ebitda"] / empresa["producao_tons"]
        receita_ton = empresa["receita"] / empresa["producao_tons"]
        margem = (ebitda_ton / receita_ton) * 100
        
        resultados.append({
            "ticker": empresa["ticker"],
            "ebitda_ton": round(ebitda_ton, 2),
            "receita_ton": round(receita_ton, 2),
            "margem_ebitda": round(margem, 1)
        })
    
    return sorted(resultados, key=lambda x: x["ebitda_ton"], reverse=True)

def obter_dados_commodities():
    """
    Obtém dados fundamentalistas do setor de commodities
    """
    tickers = [
        "VALE3", "CMIN3",           # Mineração
        "SUZB3", "KLBN11", "RANI3", # Papel e Celulose
        "CSNA3", "GGBR4", "USIM5",  # Siderurgia
        "PETR4", "PRIO3",           # Petróleo
        "JBSS3", "BRFS3"            # Frigoríficos
    ]
    
    url = f"{BASE_URL}/quote/{','.join(tickers)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code == 200:
        return response.json()["results"]
    return None

def criar_ranking_commodities(dados):
    """
    Cria ranking de commodities por múltiplos critérios
    """
    ranking = []
    
    for empresa in dados:
        if not empresa:
            continue
        
        ev = empresa.get("enterpriseValue", 0) or 0
        ebitda = empresa.get("ebitda", 0) or 0
        
        info = {
            "ticker": empresa.get("symbol"),
            "setor": identificar_setor(empresa.get("symbol")),
            "preco": empresa.get("regularMarketPrice", 0),
            "pl": empresa.get("priceEarnings", 0),
            "ev_ebitda": round(ev/ebitda, 2) if ebitda > 0 else None,
            "dy": empresa.get("dividendYield", 0),
            "margem": empresa.get("netMargin", 0),
            "roe": empresa.get("returnOnEquity", 0)
        }
        ranking.append(info)
    
    return sorted(ranking, key=lambda x: x["ev_ebitda"] or 999)

def identificar_setor(ticker):
    """
    Identifica subsegmento de commodity
    """
    setores = {
        "VALE3": "Mineração", "CMIN3": "Mineração",
        "SUZB3": "Celulose", "KLBN11": "Celulose", "RANI3": "Celulose",
        "CSNA3": "Siderurgia", "GGBR4": "Siderurgia", "USIM5": "Siderurgia",
        "PETR4": "Petróleo", "PRIO3": "Petróleo",
        "JBSS3": "Frigoríficos", "BRFS3": "Frigoríficos"
    }
    return setores.get(ticker, "Outros")

# Executar
dados = obter_dados_commodities()
if dados:
    ranking = criar_ranking_commodities(dados)
    
    print("\n=== RANKING COMMODITIES (por EV/EBITDA) ===\n")
    for emp in ranking[:10]:
        print(f"{emp['ticker']:8} | {emp['setor']:12} | EV/EBITDA: {emp['ev_ebitda']} | DY: {emp['dy']}%")

def identificar_fase_ciclo(preco_atual, media_5_anos, estoques, demanda_crescendo):
    """
    Identifica fase do ciclo de commodity
    """
    vs_media = (preco_atual / media_5_anos - 1) * 100
    
    if vs_media < -20 and estoques == "alto":
        fase = "FUNDO - Possível oportunidade de compra"
        acao = "Acumular empresas de baixo custo"
    elif vs_media < 0 and demanda_crescendo:
        fase = "RECUPERAÇÃO - Início de alta"
        acao = "Aumentar exposição"
    elif vs_media > 0 and vs_media < 30:
        fase = "EXPANSÃO - Ciclo favorável"
        acao = "Manter posição, colher dividendos"
    elif vs_media > 30:
        fase = "PICO - Euforia, cuidado"
        acao = "Realizar lucros parciais"
    else:
        fase = "INDEFINIDO"
        acao = "Aguardar sinais mais claros"
    
    return {
        "preco_vs_media": round(vs_media, 1),
        "fase": fase,
        "acao_sugerida": acao
    }

# Exemplo: Minério de ferro
analise = identificar_fase_ciclo(
    preco_atual=100,
    media_5_anos=110,
    estoques="medio",
    demanda_crescendo=True
)
print(f"Fase: {analise['fase']}")
print(f"Ação: {analise['acao_sugerida']}")

def filtrar_baixo_custo(empresas, percentil_custo=25):
    """
    Filtra empresas com custo no quartil inferior
    """
    # Ordenar por margem EBITDA (proxy de baixo custo)
    ordenadas = sorted(
        [e for e in empresas if e.get("margem") and e.get("margem") > 0],
        key=lambda x: x["margem"],
        reverse=True
    )
    
    # Top 25% = baixo custo
    corte = int(len(ordenadas) * percentil_custo / 100)
    if corte == 0:
        corte = 1
    
    return ordenadas[:corte]

def identificar_dividendos_ciclicos(dados_empresa, historico_precos_commodity):
    """
    Identifica se dividendo é sustentável ou está em pico de ciclo
    """
    dy_atual = dados_empresa.get("dividendYield", 0) or 0
    payout = dados_empresa.get("payoutRatio", 0) or 0
    
    # Comparar preço commodity atual vs histórico
    preco_atual = historico_precos_commodity[-1]
    media_3_anos = sum(historico_precos_commodity[-36:]) / 36 if len(historico_precos_commodity) >= 36 else preco_atual
    
    vs_media = (preco_atual / media_3_anos - 1) * 100
    
    if vs_media > 30 and dy_atual > 10:
        aviso = "⚠️ DY alto pode ser insustentável - commodity em pico"
    elif vs_media < -20 and dy_atual < 3:
        aviso = "✅ DY baixo é normal - commodity em baixa"
    else:
        aviso = "Dividendo aparenta ser sustentável"
    
    return {
        "dy_atual": dy_atual,
        "commodity_vs_media": round(vs_media, 1),
        "aviso": aviso
    }

VOLATILIDADE HISTÓRICA (12 meses)

Minério de Ferro    ████████████████████████████████  40-60%
Petróleo           ██████████████████████████        30-45%
Celulose           ████████████████████              25-35%
Aço                ██████████████████████████        30-40%

Comparação:
Ibovespa           ██████████████                    20-25%
Renda Fixa         ████                              5-8%

def avaliar_exposicao_china(ticker):
    """
    Avalia dependência da demanda chinesa
    """
    exposicao = {
        "VALE3": {"china_pct": 65, "risco": "Alto"},
        "SUZB3": {"china_pct": 35, "risco": "Moderado"},
        "CSNA3": {"china_pct": 10, "risco": "Baixo"},
        "PETR4": {"china_pct": 5, "risco": "Baixo"},
        "JBSS3": {"china_pct": 25, "risco": "Moderado"}
    }
    
    dados = exposicao.get(ticker, {"china_pct": 0, "risco": "Desconhecido"})
    
    return {
        "ticker": ticker,
        "exposicao_china": f"{dados['china_pct']}%",
        "nivel_risco": dados["risco"],
        "impacto_desaceleracao": "Alto" if dados["china_pct"] > 40 else "Moderado" if dados["china_pct"] > 20 else "Baixo"
    }

def simular_cenarios_cambiais(empresa_dados, cenarios_dolar):
    """
    Simula impacto de diferentes cenários de câmbio
    """
    resultados = []
    
    receita_usd_pct = empresa_dados.get("receita_usd_pct", 80)
    custo_usd_pct = empresa_dados.get("custo_usd_pct", 30)
    lucro_base = empresa_dados.get("lucro_atual", 0)
    
    for cenario in cenarios_dolar:
        nome = cenario["nome"]
        variacao = cenario["variacao_pct"]
        
        # Receita aumenta com dólar, custo parcialmente também
        impacto_receita = (receita_usd_pct / 100) * variacao
        impacto_custo = (custo_usd_pct / 100) * variacao
        impacto_liquido = impacto_receita - impacto_custo
        
        novo_lucro = lucro_base * (1 + impacto_liquido / 100)
        
        resultados.append({
            "cenario": nome,
            "variacao_dolar": f"{variacao:+.0f}%",
            "impacto_lucro": f"{impacto_liquido:+.1f}%",
            "lucro_estimado": round(novo_lucro, 0)
        })
    
    return resultados

# Cenários
cenarios = [
    {"nome": "Dólar cai 10%", "variacao_pct": -10},
    {"nome": "Estável", "variacao_pct": 0},
    {"nome": "Dólar sobe 10%", "variacao_pct": 10},
    {"nome": "Dólar sobe 20%", "variacao_pct": 20}
]

resultado = simular_cenarios_cambiais(
    {"receita_usd_pct": 85, "custo_usd_pct": 25, "lucro_atual": 30_000_000_000},
    cenarios
)

def gerar_dashboard_commodities():
    """
    Gera dashboard consolidado do setor de commodities
    """
    tickers = ["VALE3", "SUZB3", "KLBN11", "CSNA3", "PETR4", "PRIO3", "JBSS3"]
    
    url = f"{BASE_URL}/quote/{','.join(tickers)}"
    params = {"fundamental": "true"}
    headers = {"Authorization": f"Bearer {API_TOKEN}"}
    
    response = requests.get(url, params=params, headers=headers)
    
    if response.status_code != 200:
        return None
    
    dados = response.json()["results"]
    
    # Métricas por subsegmento
    segmentos = {}
    for empresa in dados:
        setor = identificar_setor(empresa.get("symbol"))
        if setor not in segmentos:
            segmentos[setor] = []
        segmentos[setor].append({
            "ticker": empresa.get("symbol"),
            "variacao": empresa.get("regularMarketChangePercent", 0),
            "dy": empresa.get("dividendYield", 0)
        })
    
    # Consolidar
    dashboard = {
        "data": datetime.now().strftime("%Y-%m-%d %H:%M"),
        "total_empresas": len(dados),
        "segmentos": {}
    }
    
    for segmento, empresas in segmentos.items():
        dashboard["segmentos"][segmento] = {
            "quantidade": len(empresas),
            "variacao_media": round(sum(e["variacao"] or 0 for e in empresas) / len(empresas), 2),
            "dy_medio": round(sum(e["dy"] or 0 for e in empresas) / len(empresas), 2)
        }
    
    return dashboard