import requests
from datetime import datetime, timedelta

def obter_selic_atual():
    """Obtém taxa SELIC atual via brapi.dev"""
    
    try:
        url = "https://brapi.dev/api/prime-rate?token=SEU_TOKEN"
        response = requests.get(url)
        data = response.json()
        
        if data and 'prime-rate' in data:
            selic_dados = data['prime-rate']
            
            return {
                'taxa_atual': selic_dados[-1]['value'],
                'data_atualizacao': selic_dados[-1]['date'],
                'historico_6m': selic_dados[-6:],  # Últimos 6 meses
                'tendencia': calcular_tendencia_selic(selic_dados[-12:])
            }
    except Exception as e:
        print(f"Erro ao obter SELIC: {e}")
        return None

def calcular_tendencia_selic(historico):
    """Calcula tendência da SELIC"""
    if len(historico) < 2:
        return "Estável"
    
    valor_atual = historico[-1]['value']
    valor_anterior = historico[-2]['value']
    
    if valor_atual > valor_anterior + 0.25:
        return "Alta"
    elif valor_atual < valor_anterior - 0.25:
        return "Baixa"
    else:
        return "Estável"

# Exemplo de uso
selic_info = obter_selic_atual()

if selic_info:
    print("💰 TAXA SELIC")
    print("=" * 30)
    print(f"Taxa Atual: {selic_info['taxa_atual']:.2f}% a.a.")
    print(f"Última Atualização: {selic_info['data_atualizacao']}")
    print(f"Tendência: {selic_info['tendencia']}")
    
    print(f"\n📊 Histórico 6 meses:")
    for periodo in selic_info['historico_6m']:
        print(f"  {periodo['date']}: {periodo['value']:.2f}%")

def obter_ipca_dados():
    """Obtém dados do IPCA via brapi.dev"""
    
    try:
        url = "https://brapi.dev/api/inflation?token=SEU_TOKEN"
        response = requests.get(url)
        data = response.json()
        
        if data and 'inflation' in data:
            ipca_dados = data['inflation']
            
            # Calcular inflação acumulada 12 meses
            ultimos_12m = ipca_dados[-12:]
            inflacao_12m = calcular_inflacao_acumulada(ultimos_12m)
            
            return {
                'ipca_mensal': ipca_dados[-1]['value'],
                'data_referencia': ipca_dados[-1]['date'],
                'ipca_12m': inflacao_12m,
                'historico_12m': ultimos_12m,
                'meta_governo': 3.25,  # Meta central 2024
                'banda_superior': 4.75,  # Teto da meta
                'banda_inferior': 1.75   # Piso da meta
            }
    except Exception as e:
        print(f"Erro ao obter IPCA: {e}")
        return None

def calcular_inflacao_acumulada(historico_mensal):
    """Calcula inflação acumulada em 12 meses"""
    acumulado = 1.0
    
    for periodo in historico_mensal:
        acumulado *= (1 + periodo['value'] / 100)
    
    return (acumulado - 1) * 100

def analisar_cenario_inflacionario(ipca_dados):
    """Analisa cenário inflacionário"""
    
    ipca_12m = ipca_dados['ipca_12m']
    meta = ipca_dados['meta_governo']
    teto = ipca_dados['banda_superior']
    piso = ipca_dados['banda_inferior']
    
    if ipca_12m > teto:
        cenario = {
            'status': 'ACIMA DA META',
            'cor': 'vermelho',
            'descricao': 'Inflação acima do teto, pressão para alta da SELIC',
            'impacto_investimentos': 'Favor renda fixa, cuidado com ações'
        }
    elif ipca_12m < piso:
        cenario = {
            'status': 'ABAIXO DA META',
            'cor': 'azul',
            'descricao': 'Inflação baixa, espaço para corte de juros',
            'impacto_investimentos': 'Favor ações e ativos de risco'
        }
    elif piso <= ipca_12m <= teto:
        cenario = {
            'status': 'DENTRO DA META',
            'cor': 'verde',
            'descricao': 'Inflação controlada, SELIC estável',
            'impacto_investimentos': 'Cenário favorável para diversificação'
        }
    else:
        distancia_meta = abs(ipca_12m - meta)
        if distancia_meta < 0.5:
            cenario = {
                'status': 'PRÓXIMO DA META',
                'cor': 'amarelo',
                'descricao': 'Inflação próxima ao centro da meta',
                'impacto_investimentos': 'Cenário estável'
            }
        else:
            cenario = {
                'status': 'DISTANTE DA META',
                'cor': 'laranja',
                'descricao': 'Inflação se afastando da meta',
                'impacto_investimentos': 'Atenção às mudanças de política monetária'
            }
    
    return cenario

# Exemplo de análise IPCA
ipca_info = obter_ipca_dados()

if ipca_info:
    print("📈 IPCA - INFLAÇÃO")
    print("=" * 30)
    print(f"IPCA Mensal: {ipca_info['ipca_mensal']:.2f}%")
    print(f"IPCA 12 meses: {ipca_info['ipca_12m']:.2f}%")
    print(f"Meta do Governo: {ipca_info['meta_governo']:.2f}%")
    
    cenario = analisar_cenario_inflacionario(ipca_info)
    print(f"\nCenário: {cenario['status']}")
    print(f"Análise: {cenario['descricao']}")
    print(f"Impacto: {cenario['impacto_investimentos']}")

def comparar_indices_inflacao():
    """Compara IPCA vs IGP-M"""
    
    # Dados históricos comparativos (exemplo)
    comparacao = {
        'periodo': '2023',
        'ipca': 4.62,
        'igpm': 5.45,
        'diferenca': 0.83,
        'caracteristicas': {
            'ipca': {
                'foco': 'Famílias 1-40 salários mínimos',
                'peso_alimentacao': 23.12,
                'peso_transporte': 18.77,
                'uso_principal': 'Meta de inflação do governo'
            },
            'igpm': {
                'foco': 'Preços no atacado, construção civil',
                'peso_atacado': 60,
                'peso_varejo': 30,
                'uso_principal': 'Contratos de aluguel'
            }
        }
    }
    
    return comparacao

def calcular_impacto_carteira_inflacao(carteira, ipca_atual, igpm_atual):
    """Calcula impacto da inflação na carteira"""
    
    impactos = []
    
    for ativo in carteira:
        tipo = ativo['tipo']
        valor = ativo['valor']
        
        if tipo == 'CDB_PRE':
            # CDB pré-fixado perde com inflação alta
            rentabilidade_real = ativo['taxa'] - ipca_atual
            impacto = {
                'ativo': ativo['nome'],
                'tipo': 'Renda Fixa Pré',
                'rentabilidade_real': rentabilidade_real,
                'status': 'Positiva' if rentabilidade_real > 0 else 'Negativa',
                'recomendacao': 'Trocar por pós-fixado' if rentabilidade_real < 2 else 'Manter'
            }
        
        elif tipo == 'TESOURO_IPCA':
            # Tesouro IPCA+ protegido da inflação
            impacto = {
                'ativo': ativo['nome'],
                'tipo': 'Renda Fixa Inflação',
                'rentabilidade_real': ativo['taxa_real'],
                'status': 'Protegida',
                'recomendacao': 'Excelente proteção'
            }
        
        elif tipo == 'ACAO':
            # Ações podem se beneficiar de inflação moderada
            impacto = {
                'ativo': ativo['nome'],
                'tipo': 'Renda Variável',
                'rentabilidade_real': 'Variável',
                'status': 'Moderada' if ipca_atual < 6 else 'Atenção',
                'recomendacao': 'Focar empresas com pricing power'
            }
        
        elif tipo == 'FII':
            # FIIs podem se beneficiar com aluguéis indexados ao IGP-M
            impacto = {
                'ativo': ativo['nome'],
                'tipo': 'Fundo Imobiliário',
                'rentabilidade_real': f'Benefício IGP-M: {igpm_atual:.1f}%',
                'status': 'Positiva',
                'recomendacao': 'Bom hedge inflacionário'
            }
        
        impactos.append(impacto)
    
    return impactos

# Exemplo de carteira
carteira_exemplo = [
    {'nome': 'CDB Banco X', 'tipo': 'CDB_PRE', 'valor': 50000, 'taxa': 12.5},
    {'nome': 'Tesouro IPCA+ 2029', 'tipo': 'TESOURO_IPCA', 'valor': 30000, 'taxa_real': 5.8},
    {'nome': 'PETR4', 'tipo': 'ACAO', 'valor': 20000},
    {'nome': 'HGLG11', 'tipo': 'FII', 'valor': 15000}
]

# Análise de impacto
impactos_inflacao = calcular_impacto_carteira_inflacao(carteira_exemplo, 4.5, 5.2)

print("\n💰 IMPACTO INFLAÇÃO NA CARTEIRA")
print("=" * 50)

for impacto in impactos_inflacao:
    print(f"\n{impacto['ativo']} ({impacto['tipo']}):")
    print(f"  Status: {impacto['status']}")
    print(f"  Rentabilidade Real: {impacto['rentabilidade_real']}")
    print(f"  Recomendação: {impacto['recomendacao']}")

def analisar_cdi_vs_selic():
    """Analisa relação CDI vs SELIC"""
    
    # Dados comparativos (exemplo)
    dados_comparativos = {
        'selic_atual': 11.75,
        'cdi_atual': 11.65,
        'diferenca': 0.10,
        'historico': [
            {'periodo': '2024-01', 'selic': 11.75, 'cdi': 11.65},
            {'periodo': '2023-12', 'selic': 11.75, 'cdi': 11.65},
            {'periodo': '2023-11', 'selic': 11.75, 'cdi': 11.65}
        ]
    }
    
    # Calcular spread médio
    spreads = [abs(h['selic'] - h['cdi']) for h in dados_comparativos['historico']]
    spread_medio = sum(spreads) / len(spreads)
    
    return {
        'dados': dados_comparativos,
        'spread_medio': spread_medio,
        'relacao': 'CDI tradicionalmente 0.1-0.2% abaixo da SELIC'
    }

def calcular_rentabilidade_cdi(valor_inicial, percentual_cdi, periodo_dias):
    """Calcula rentabilidade baseada no CDI"""
    
    cdi_anual = 11.65  # Exemplo: CDI atual
    cdi_aplicado = cdi_anual * (percentual_cdi / 100)  # Ex: 100% do CDI
    
    # Fórmula de juros compostos com CDI
    taxa_periodo = (1 + cdi_aplicado / 100) ** (periodo_dias / 365) - 1
    valor_final = valor_inicial * (1 + taxa_periodo)
    
    return {
        'valor_inicial': valor_inicial,
        'valor_final': valor_final,
        'rendimento': valor_final - valor_inicial,
        'rentabilidade_percentual': taxa_periodo * 100,
        'cdi_aplicado': cdi_aplicado,
        'periodo_dias': periodo_dias
    }

# Exemplo de cálculo CDI
rendimento_cdi = calcular_rentabilidade_cdi(100000, 100, 365)  # R$ 100k, 100% CDI, 1 ano

print("\n💳 ANÁLISE CDI")
print("=" * 30)
print(f"Investimento: R$ {rendimento_cdi['valor_inicial']:,.2f}")
print(f"CDI Aplicado: {rendimento_cdi['cdi_aplicado']:.2f}% a.a.")
print(f"Período: {rendimento_cdi['periodo_dias']} dias")
print(f"Valor Final: R$ {rendimento_cdi['valor_final']:,.2f}")
print(f"Rendimento: R$ {rendimento_cdi['rendimento']:,.2f}")
print(f"Rentabilidade: {rendimento_cdi['rentabilidade_percentual']:.2f}%")

class DashboardMacroeconomico:
    def __init__(self, token):
        self.token = token
        self.indicadores = {}
    
    def atualizar_todos_indicadores(self):
        """Atualiza todos os indicadores econômicos"""
        
        print("Atualizando indicadores...")
        
        # SELIC
        self.indicadores['selic'] = self.obter_selic()
        
        # IPCA
        self.indicadores['ipca'] = self.obter_ipca()
        
        # CDI (estimado baseado na SELIC)
        if self.indicadores['selic']:
            self.indicadores['cdi'] = {
                'taxa': self.indicadores['selic']['taxa'] - 0.1,
                'data': self.indicadores['selic']['data']
            }
        
        # Cenário consolidado
        self.indicadores['cenario'] = self.analisar_cenario_macro()
        
        return self.indicadores
    
    def obter_selic(self):
        """Obtém dados da SELIC"""
        try:
            url = f"https://brapi.dev/api/prime-rate?token={self.token}"
            response = requests.get(url)
            data = response.json()
            
            if data and 'prime-rate' in data:
                ultimo = data['prime-rate'][-1]
                return {
                    'taxa': ultimo['value'],
                    'data': ultimo['date']
                }
        except:
            return None
    
    def obter_ipca(self):
        """Obtém dados do IPCA"""
        try:
            url = f"https://brapi.dev/api/inflation?token={self.token}"
            response = requests.get(url)
            data = response.json()
            
            if data and 'inflation' in data:
                ultimos_12m = data['inflation'][-12:]
                ipca_acumulado = calcular_inflacao_acumulada(ultimos_12m)
                
                return {
                    'mensal': data['inflation'][-1]['value'],
                    'acumulado_12m': ipca_acumulado,
                    'data': data['inflation'][-1]['date']
                }
        except:
            return None
    
    def analisar_cenario_macro(self):
        """Analisa cenário macroeconômico consolidado"""
        
        if not self.indicadores.get('selic') or not self.indicadores.get('ipca'):
            return {'status': 'DADOS INSUFICIENTES'}
        
        selic = self.indicadores['selic']['taxa']
        ipca_12m = self.indicadores['ipca']['acumulado_12m']
        
        taxa_real = selic - ipca_12m
        
        # Análise de cenário
        if taxa_real > 4:
            cenario = {
                'status': 'JUROS ALTOS',
                'taxa_real': taxa_real,
                'descricao': 'Taxa real alta, favorável à renda fixa',
                'recomendacao': 'Aumentar posição em renda fixa',
                'impacto_acoes': 'Negativo',
                'impacto_fiis': 'Negativo'
            }
        elif taxa_real > 2:
            cenario = {
                'status': 'JUROS MODERADOS',
                'taxa_real': taxa_real,
                'descricao': 'Taxa real adequada, cenário equilibrado',
                'recomendacao': 'Manter diversificação',
                'impacto_acoes': 'Neutro',
                'impacto_fiis': 'Neutro'
            }
        else:
            cenario = {
                'status': 'JUROS BAIXOS',
                'taxa_real': taxa_real,
                'descricao': 'Taxa real baixa, busca por renda variável',
                'recomendacao': 'Aumentar posição em ações e FIIs',
                'impacto_acoes': 'Positivo',
                'impacto_fiis': 'Positivo'
            }
        
        return cenario
    
    def gerar_relatorio(self):
        """Gera relatório consolidado"""
        
        relatorio = {
            'data_geracao': datetime.now().strftime('%d/%m/%Y %H:%M'),
            'indicadores': self.indicadores,
            'alertas': self.identificar_alertas(),
            'recomendacoes': self.gerar_recomendacoes()
        }
        
        return relatorio
    
    def identificar_alertas(self):
        """Identifica alertas importantes"""
        
        alertas = []
        
        if self.indicadores.get('ipca'):
            ipca_12m = self.indicadores['ipca']['acumulado_12m']
            
            if ipca_12m > 4.75:  # Teto da meta
                alertas.append({
                    'tipo': 'INFLACAO_ALTA',
                    'mensagem': f'IPCA {ipca_12m:.1f}% acima do teto da meta (4.75%)',
                    'severidade': 'ALTA'
                })
            elif ipca_12m < 1.75:  # Piso da meta
                alertas.append({
                    'tipo': 'INFLACAO_BAIXA',
                    'mensagem': f'IPCA {ipca_12m:.1f}% abaixo do piso da meta (1.75%)',
                    'severidade': 'MEDIA'
                })
        
        if self.indicadores.get('selic'):
            selic = self.indicadores['selic']['taxa']
            
            if selic > 13:
                alertas.append({
                    'tipo': 'SELIC_MUITO_ALTA',
                    'mensagem': f'SELIC {selic:.1f}% em nível muito elevado',
                    'severidade': 'ALTA'
                })
            elif selic < 3:
                alertas.append({
                    'tipo': 'SELIC_MUITO_BAIXA',
                    'mensagem': f'SELIC {selic:.1f}% em nível muito baixo',
                    'severidade': 'MEDIA'
                })
        
        return alertas
    
    def gerar_recomendacoes(self):
        """Gera recomendações de alocação"""
        
        if not self.indicadores.get('cenario'):
            return []
        
        cenario = self.indicadores['cenario']['status']
        
        if cenario == 'JUROS ALTOS':
            return [
                'Aumentar alocação em renda fixa (60-70%)',
                'Reduzir exposição a ações de crescimento',
                'Evitar FIIs com yields baixos',
                'Considerar Tesouro SELIC para liquidez'
            ]
        elif cenario == 'JUROS BAIXOS':
            return [
                'Aumentar alocação em ações (50-60%)',
                'Buscar FIIs com yields atrativos',
                'Reduzir renda fixa para o mínimo estratégico',
                'Considerar ações de crescimento'
            ]
        else:
            return [
                'Manter alocação equilibrada (40% RF, 40% RV, 20% FIIs)',
                'Diversificar entre setores defensivos e cíclicos',
                'Acompanhar evolução dos indicadores',
                'Rebalancear conforme mudanças macro'
            ]

# Exemplo de uso do dashboard
dashboard = DashboardMacroeconomico('SEU_TOKEN')
indicadores = dashboard.atualizar_todos_indicadores()
relatorio = dashboard.gerar_relatorio()

print("🌍 DASHBOARD MACROECONÔMICO")
print("=" * 50)
print(f"Data: {relatorio['data_geracao']}")

if indicadores.get('selic'):
    print(f"\n💰 SELIC: {indicadores['selic']['taxa']:.2f}%")

if indicadores.get('ipca'):
    print(f"📊 IPCA (12m): {indicadores['ipca']['acumulado_12m']:.2f}%")

if indicadores.get('cdi'):
    print(f"💳 CDI: {indicadores['cdi']['taxa']:.2f}%")

if indicadores.get('cenario'):
    cenario = indicadores['cenario']
    print(f"\n🎯 CENÁRIO: {cenario['status']}")
    print(f"Taxa Real: {cenario['taxa_real']:.2f}%")
    print(f"Descrição: {cenario['descricao']}")

print(f"\n⚠️ ALERTAS:")
for alerta in relatorio['alertas']:
    print(f"  • {alerta['mensagem']} (Severidade: {alerta['severidade']})")

print(f"\n💡 RECOMENDAÇÕES:")
for rec in relatorio['recomendacoes']:
    print(f"  • {rec}")

def estrategia_por_cenario(cenario_macro, valor_carteira=100000):
    """Define estratégia de alocação baseada no cenário"""
    
    estrategias = {
        'JUROS_ALTOS_INFLACAO_CONTROLADA': {
            'nome': 'Defensiva - Renda Fixa',
            'alocacao': {
                'tesouro_selic': 30,
                'cdb_di': 25,
                'tesouro_ipca': 15,
                'acoes_defensivas': 20,
                'fiis': 10
            },
            'justificativa': 'Juros altos favorecem renda fixa',
            'expectativa_retorno': 'SELIC - 1%'
        },
        
        'JUROS_BAIXOS_INFLACAO_CONTROLADA': {
            'nome': 'Agressiva - Renda Variável',
            'alocacao': {
                'acoes_crescimento': 35,
                'acoes_value': 25,
                'fiis': 20,
                'tesouro_ipca': 10,
                'reserva_liquidez': 10
            },
            'justificativa': 'Busca por yield em cenário de juros baixos',
            'expectativa_retorno': 'IPCA + 6-8%'
        },
        
        'JUROS_ALTOS_INFLACAO_ALTA': {
            'nome': 'Proteção Inflacionária',
            'alocacao': {
                'tesouro_ipca': 40,
                'acoes_commodities': 25,
                'fiis': 15,
                'tesouro_selic': 15,
                'ouro_dolar': 5
            },
            'justificativa': 'Proteção contra inflação alta',
            'expectativa_retorno': 'IPCA + 3-5%'
        },
        
        'CENARIO_INCERTO': {
            'nome': 'Balanceada - Diversificação',
            'alocacao': {
                'tesouro_ipca': 25,
                'acoes_diversificadas': 30,
                'fiis': 20,
                'cdb_di': 15,
                'reserva': 10
            },
            'justificativa': 'Diversificação em cenário incerto',
            'expectativa_retorno': 'CDI + 2-4%'
        }
    }
    
    return estrategias.get(cenario_macro, estrategias['CENARIO_INCERTO'])

def simular_carteira_cenarios(valor_inicial, cenario_atual):
    """Simula performance da carteira em diferentes cenários"""
    
    estrategia = estrategia_por_cenario(cenario_atual, valor_inicial)
    
    # Simulação de retornos (12 meses)
    retornos_esperados = {
        'tesouro_selic': 11.75,
        'cdb_di': 11.65,
        'tesouro_ipca': 15.5,  # IPCA + taxa real
        'acoes_defensivas': 12.0,
        'acoes_crescimento': 15.0,
        'acoes_value': 13.0,
        'acoes_commodities': 10.0,
        'acoes_diversificadas': 13.5,
        'fiis': 11.0,
        'reserva_liquidez': 10.0,
        'reserva': 10.0,
        'ouro_dolar': 8.0
    }
    
    simulacao = {
        'estrategia': estrategia['nome'],
        'valor_inicial': valor_inicial,
        'alocacao_detalhada': {},
        'valor_final_esperado': 0,
        'retorno_total_esperado': 0
    }
    
    valor_total_final = 0
    
    for ativo, percentual in estrategia['alocacao'].items():
        valor_ativo = valor_inicial * (percentual / 100)
        retorno_ativo = retornos_esperados.get(ativo, 10) / 100
        valor_final_ativo = valor_ativo * (1 + retorno_ativo)
        
        simulacao['alocacao_detalhada'][ativo] = {
            'percentual': percentual,
            'valor_inicial': valor_ativo,
            'retorno_esperado': retorno_ativo * 100,
            'valor_final': valor_final_ativo,
            'ganho': valor_final_ativo - valor_ativo
        }
        
        valor_total_final += valor_final_ativo
    
    simulacao['valor_final_esperado'] = valor_total_final
    simulacao['retorno_total_esperado'] = ((valor_total_final / valor_inicial) - 1) * 100
    
    return simulacao

# Exemplo de simulação
cenario_exemplo = 'JUROS_ALTOS_INFLACAO_CONTROLADA'
simulacao_resultado = simular_carteira_cenarios(100000, cenario_exemplo)

print(f"\n💼 SIMULAÇÃO DE CARTEIRA")
print("=" * 50)
print(f"Cenário: {cenario_exemplo}")
print(f"Estratégia: {simulacao_resultado['estrategia']}")
print(f"Valor Inicial: R$ {simulacao_resultado['valor_inicial']:,.2f}")
print(f"Valor Final Esperado: R$ {simulacao_resultado['valor_final_esperado']:,.2f}")
print(f"Retorno Esperado: {simulacao_resultado['retorno_total_esperado']:+.2f}%")

print(f"\n📊 ALOCAÇÃO DETALHADA:")
for ativo, dados in simulacao_resultado['alocacao_detalhada'].items():
    print(f"\n{ativo.replace('_', ' ').title()}: {dados['percentual']}%")
    print(f"  Valor: R$ {dados['valor_inicial']:,.2f}")
    print(f"  Retorno: {dados['retorno_esperado']:.2f}%")
    print(f"  Ganho: R$ {dados['ganho']:+,.2f}")

def configurar_alertas_macro(parametros_alerta):
    """Configura alertas para indicadores macroeconômicos"""
    
    alertas_config = {
        'selic': {
            'limite_superior': parametros_alerta.get('selic_max', 15),
            'limite_inferior': parametros_alerta.get('selic_min', 2),
            'variacao_maxima': parametros_alerta.get('selic_variacao', 0.75)  # 0.75 p.p.
        },
        'ipca': {
            'limite_superior': parametros_alerta.get('ipca_max', 4.75),  # Teto da meta
            'limite_inferior': parametros_alerta.get('ipca_min', 1.75),  # Piso da meta
            'variacao_maxima': parametros_alerta.get('ipca_variacao', 1.0)
        },
        'taxa_real': {
            'limite_inferior': parametros_alerta.get('taxa_real_min', 2),
            'limite_superior': parametros_alerta.get('taxa_real_max', 6)
        }
    }
    
    return alertas_config

def verificar_alertas_indicadores(indicadores_atuais, alertas_config):
    """Verifica se algum alerta deve ser disparado"""
    
    alertas_disparados = []
    
    # Verificar SELIC
    if indicadores_atuais.get('selic'):
        selic = indicadores_atuais['selic']['taxa']
        config_selic = alertas_config['selic']
        
        if selic > config_selic['limite_superior']:
            alertas_disparados.append({
                'tipo': 'SELIC_ALTA',
                'mensagem': f'SELIC {selic:.2f}% acima do limite ({config_selic["limite_superior"]}%)',
                'acao_sugerida': 'Aumentar renda fixa'
            })
        elif selic < config_selic['limite_inferior']:
            alertas_disparados.append({
                'tipo': 'SELIC_BAIXA',
                'mensagem': f'SELIC {selic:.2f}% abaixo do limite ({config_selic["limite_inferior"]}%)',
                'acao_sugerida': 'Aumentar renda variável'
            })
    
    # Verificar IPCA
    if indicadores_atuais.get('ipca'):
        ipca = indicadores_atuais['ipca']['acumulado_12m']
        config_ipca = alertas_config['ipca']
        
        if ipca > config_ipca['limite_superior']:
            alertas_disparados.append({
                'tipo': 'INFLACAO_ALTA',
                'mensagem': f'IPCA {ipca:.2f}% acima da meta ({config_ipca["limite_superior"]}%)',
                'acao_sugerida': 'Aumentar proteção inflacionária'
            })
        elif ipca < config_ipca['limite_inferior']:
            alertas_disparados.append({
                'tipo': 'INFLACAO_BAIXA',
                'mensagem': f'IPCA {ipca:.2f}% abaixo da meta ({config_ipca["limite_inferior"]}%)',
                'acao_sugerida': 'Reduzir proteção inflacionária'
            })
    
    return alertas_disparados

def enviar_alerta_telegram_macro(alertas, bot_token, chat_id):
    """Envia alertas macroeconômicos via Telegram"""
    
    if not alertas:
        return
    
    mensagem = "🌍 <b>ALERTAS MACROECONÔMICOS</b>\n\n"
    
    for alerta in alertas:
        emoji = "🔴" if "ALTA" in alerta['tipo'] else "🔵" if "BAIXA" in alerta['tipo'] else "⚠️"
        mensagem += f"{emoji} <b>{alerta['tipo'].replace('_', ' ')}</b>\n"
        mensagem += f"   {alerta['mensagem']}\n"
        mensagem += f"   💡 <i>{alerta['acao_sugerida']}</i>\n\n"
    
    # Código para enviar via Telegram seria implementado aqui
    print(f"📱 Enviando alerta: {mensagem}")

# Exemplo de configuração de alertas
config_alertas = configurar_alertas_macro({
    'selic_max': 14,
    'selic_min': 3,
    'ipca_max': 4.5,
    'ipca_min': 2.0
})

# Verificar alertas com dados atuais
alertas_atuais = verificar_alertas_indicadores(indicadores, config_alertas)

if alertas_atuais:
    print("\n🚨 ALERTAS DISPARADOS:")
    for alerta in alertas_atuais:
        print(f"  • {alerta['mensagem']}")
        print(f"    Ação: {alerta['acao_sugerida']}")
else:
    print("\n✅ Nenhum alerta disparado - indicadores dentro dos parâmetros")