import numpy as np
import matplotlib.pyplot as plt
import gradio as gr

# Funções para o cálculo de IR no VGBL
def calcular_ir_regressivo(tempo_anos):
    """Tabela Regressiva de IR para VGBL."""
    if tempo_anos <= 2:
        return 0.35
    elif tempo_anos <= 4:
        return 0.30
    elif tempo_anos <= 6:
        return 0.25
    elif tempo_anos <= 8:
        return 0.20
    elif tempo_anos <= 10:
        return 0.15
    else:
        return 0.10

def calcular_ir_progressivo(valor_resgate):
    """
    Tabela Progressiva de IR para VGBL.
    A alíquota é determinada pelo valor total do resgate (não pelo rendimento).

    Base de cálculo (R$)	Alíquota de IR
    Até R$ 22.847,76	Isento
    De R$ 22.847,77 a R$ 33.919,80	7,5%
    De R$ 33.919,81 a R$ 45.012,60	15%
    De R$ 45.012,61 a R$ 55.976,16	22,5%
    Acima de R$ 55.976,16	27,5%
    """
    if valor_resgate <= 22847.76:
        return 0
    elif valor_resgate <= 33919.80:
        return 0.075
    elif valor_resgate <= 45012.60:
        return 0.15
    elif valor_resgate <= 55976.16:
        return 0.225
    else:
        return 0.275

def simular_vgbl(valor_inicial, anos, rentabilidade_anual, taxa_adm, taxa_carregamento, regime_tributario='regressivo'):
    """
    Simula o rendimento de um VGBL com base no regime tributário (regressivo ou progressivo).
    """
    meses = int(anos * 12)
    rentabilidade_mensal = (1 + rentabilidade_anual) ** (1/12) - 1
    taxa_adm_mensal = (1 + taxa_adm) ** (1/12) - 1

    # Aplicando a taxa de carregamento
    valor_inicial_apos_carregamento = valor_inicial * (1 - taxa_carregamento)
    valor_inicial_original = valor_inicial  # Guardar o valor inicial original para cálculos

    saldo = valor_inicial_apos_carregamento
    saldos_mensais = [saldo]  # Armazenar saldo de cada mês

    # Simulação do saldo ao longo do tempo
    for _ in range(meses):
        saldo = saldo * (1 + rentabilidade_mensal - taxa_adm_mensal)
        saldos_mensais.append(saldo)

    # Cálculo do IR
    rendimento = saldo - valor_inicial_apos_carregamento
    if regime_tributario == 'regressivo':
        aliquota = calcular_ir_regressivo(anos)
        imposto = rendimento * aliquota
    else:  # Progressivo
        # No regime progressivo, a alíquota é determinada pelo valor total do resgate
        aliquota = calcular_ir_progressivo(saldo)
        imposto = rendimento * aliquota

    # Lucro líquido é o saldo final menos o valor inicial original menos o imposto
    lucro_liquido = saldo - valor_inicial_original - imposto

    # Lucro bruto é o saldo final menos o valor inicial original (sem considerar imposto)
    lucro_bruto = saldo - valor_inicial_original

    # Calcular a porcentagem efetiva do imposto em relação ao lucro bruto
    imposto_percentual = (imposto / lucro_bruto) * 100 if lucro_bruto > 0 else 0

    # Calcular rendimento mensal
    rendimentos_mensais = []
    for i in range(1, len(saldos_mensais)):
        rendimento_mensal = saldos_mensais[i] - saldos_mensais[i-1]
        rendimentos_mensais.append(rendimento_mensal)

    # Rendimento médio mensal bruto
    rendimento_medio_mensal = sum(rendimentos_mensais) / len(rendimentos_mensais)

    # Rendimento médio mensal líquido (considerando IR)
    rendimento_liquido_medio_mensal = rendimento_medio_mensal * (1 - aliquota)

    # Rendimento líquido mensal em percentual
    rendimento_liquido_mensal_percentual = (rendimento_liquido_medio_mensal / valor_inicial_original) * 100

    return {
        'Saldo Bruto': saldo,
        'Valor Inicial': valor_inicial_original,
        'Valor Após Carregamento': valor_inicial_apos_carregamento,
        'Rendimento': rendimento,
        'IR': imposto,
        'IR Percentual': imposto_percentual,
        'Lucro Bruto': lucro_bruto,
        'Lucro Líquido': lucro_liquido,
        'Alíquota IR': aliquota,
        'Rendimento Líquido %': (lucro_liquido / valor_inicial_original) * 100,
        'Rendimento Líquido Médio Mensal': rendimento_liquido_medio_mensal,
        'Rendimento Líquido Mensal %': rendimento_liquido_mensal_percentual
    }

# Função para calcular o rendimento líquido de CDB e LCA
def calcular_rendimento_liquido(valor_inicial, taxa_cdi, percentual_cdi, prazo_meses, aporte_mensal=0, isento_ir=False):
    taxa_mensal = (taxa_cdi / 100) * (percentual_cdi / 100) / 12
    saldo = valor_inicial
    saldos_mensais = [saldo]  # Armazenar saldo de cada mês
    total_aportado = valor_inicial

    for _ in range(prazo_meses):
        rendimento_mensal = saldo * taxa_mensal
        saldo += rendimento_mensal
        saldo += aporte_mensal
        total_aportado += aporte_mensal
        saldos_mensais.append(saldo)

    lucro_bruto = saldo - total_aportado

    if not isento_ir:
        # Tabela regressiva de IR
        if prazo_meses <= 6:
            aliquota_ir = 0.225
        elif prazo_meses <= 12:
            aliquota_ir = 0.20
        elif prazo_meses <= 24:
            aliquota_ir = 0.175
        else:
            aliquota_ir = 0.15
        imposto = lucro_bruto * aliquota_ir
    else:
        imposto = 0
        aliquota_ir = 0

    # Calcular a porcentagem efetiva do imposto em relação ao lucro bruto
    imposto_percentual = (imposto / lucro_bruto) * 100 if lucro_bruto > 0 else 0

    lucro_liquido = lucro_bruto - imposto

    # Calcular rendimentos mensais brutos
    rendimentos_mensais = []
    for i in range(1, len(saldos_mensais)):
        rendimento_mensal = saldos_mensais[i] - saldos_mensais[i-1] - aporte_mensal
        rendimentos_mensais.append(rendimento_mensal)

    # Rendimento médio mensal bruto
    rendimento_medio_mensal = sum(rendimentos_mensais) / len(rendimentos_mensais)

    # Rendimento médio mensal líquido (considerando IR)
    rendimento_liquido_medio_mensal = rendimento_medio_mensal * (1 - aliquota_ir)

    # Rendimento líquido mensal em percentual
    rendimento_liquido_mensal_percentual = (rendimento_liquido_medio_mensal / valor_inicial) * 100

    return {
        "Saldo Total": saldo,
        "Imposto Pago": imposto,
        "IR Percentual": imposto_percentual,
        "Aliquota IR (%)": aliquota_ir * 100,
        "Lucro Bruto": lucro_bruto,
        "Lucro Líquido Final": lucro_liquido,
        "Rendimento Líquido %": (lucro_liquido / valor_inicial) * 100,
        "Rendimento Líquido Médio Mensal": rendimento_liquido_medio_mensal,
        "Rendimento Líquido Mensal %": rendimento_liquido_mensal_percentual
    }

# Função principal para o simulador
def simulador(valor_inicial, prazo_meses, aporte_mensal, taxa_cdi, percentual_cdi_cdb, percentual_cdi_lca, rentabilidade_anual, taxa_adm, taxa_carregamento):
    resultados = []
    anos = prazo_meses / 12

    # Simulação para CDB
    resultado_cdb = calcular_rendimento_liquido(valor_inicial, taxa_cdi, percentual_cdi_cdb, prazo_meses, aporte_mensal, isento_ir=False)
    resultado_cdb['Tipo'] = 'CDB'
    resultados.append(resultado_cdb)

    # Simulação para LCA (se o prazo for >= 10 meses)
    if prazo_meses >= 10:
        resultado_lca = calcular_rendimento_liquido(valor_inicial, taxa_cdi, percentual_cdi_lca, prazo_meses, aporte_mensal, isento_ir=True)
        resultado_lca['Tipo'] = 'LCA'
        resultados.append(resultado_lca)

    # Simulação para VGBL (se o prazo for >= 2 meses)
    if prazo_meses >= 2:
        for regime in ['regressivo', 'progressivo']:
            resultado = simular_vgbl(valor_inicial, anos, rentabilidade_anual / 100, taxa_adm / 100, taxa_carregamento / 100, regime)
            resultado['Tipo'] = f"VGBL ({regime})"
            resultados.append(resultado)

    # Determinando o investimento com maior rendimento líquido
    melhor_investimento = max(resultados, key=lambda x: x['Rendimento Líquido %'])

    # Criando o gráfico
    plt.figure(figsize=(10, 6))
    for resultado in resultados:
        cor = "orange" if resultado == melhor_investimento else "blue"
        plt.bar(resultado['Tipo'], resultado['Rendimento Líquido %'], color=cor)
    plt.title("Comparação de Rendimento Líquido (%)")
    plt.ylabel("Rendimento Líquido (%)")
    plt.xticks(rotation=45, ha="right")
    plt.tight_layout()

    # Salvando o gráfico
    plt.savefig("grafico.png")
    plt.close()

    # Resultados finais
    resultados_texto = "\n".join([
        f"{resultado['Tipo']}:\n"
        f"  Saldo Bruto: R$ {resultado.get('Saldo Bruto', resultado.get('Saldo Total')):,.2f}\n"
        f"  Imposto Pago: R$ {resultado.get('IR', resultado.get('Imposto Pago')):,.2f} ({resultado.get('IR Percentual', 0):.2f}%)\n"
        f"  Lucro Bruto: R$ {resultado.get('Lucro Bruto'):,.2f}\n"
        f"  Lucro Líquido: R$ {resultado.get('Lucro Líquido', resultado.get('Lucro Líquido Final')):,.2f}\n"
        f"  Rendimento Líquido Total: {resultado['Rendimento Líquido %']:.2f}%\n"
        f"  Rendimento Líquido Médio Mensal: R$ {resultado.get('Rendimento Líquido Médio Mensal'):,.2f}\n"
        f"  Rendimento Líquido Mensal %: {resultado.get('Rendimento Líquido Mensal %'):.4f}%\n"
        for resultado in resultados
    ])

    return resultados_texto, "grafico.png"

# Interface Gradio
with gr.Blocks() as interface:
    gr.HTML(
        "<h1 style='text-align: center; width: 100%;'>Simulador de Investimentos<br>CDB DI 97% vs LCA 93% vs VGBL</h1>"
    )
    gr.Markdown(
        "Compare o saldo total, impostos e lucro líquido de investimentos em CDB, LCA e VGBL com base nos parâmetros fornecidos.\n\n"
        "Observação sobre IOF (Imposto sobre Operações Financeiras): incide apenas se o resgate for feito nos primeiros 30 dias.\n\n"
        "**CDB DI 97%**\n"
        "- CDB pós-fixado."
        "- A Taxa CDI Anual é uma referência importante e pode ser obtida em sites como: [B3](https://www.b3.com.br/), [Infomoney](https://www.infomoney.com.br/), [Investing](https://br.investing.com/)\n"
        "- O imposto de renda é retido automaticamente pelo organismo financeiro antes de transferir o lucro líquido para sua conta corrente.\n"
        "- Sem carência (pelo contrário, o CDB prè-fixado exige que espere até o plano expirar para resgatá-lo (plano máximo de 120 dias). [Mais info aqui](https://megainvestimentos.com/cdb-banco-do-brasil-bb/))).\n\n"
        "**LCA**\n"
        "- O LCA é isento de imposto de renda.\n"
        "- 10 meses sem resgate.\n\n"
        "**VGBL**\n"
        "- A Rentabilidade Anual (%) representa o retorno esperado do fundo de investimento associado ao VGBL, que pode variar conforme o tipo de fundo escolhido (renda fixa, multimercado, ações, etc.).\n"
        "- Carência 60 dias.\n\n"
        "**Tabela de IR Regressivo (VGBL)**\n"
        "- A alíquota é determinada pelo tempo de aplicação\n"
        "- Até 2 anos: 35%\n"
        "- De 2 a 4 anos: 30%\n"
        "- De 4 a 6 anos: 25%\n"
        "- De 6 a 8 anos: 20%\n"
        "- De 8 a 10 anos: 15%\n"
        "- Acima de 10 anos: 10%\n\n"
        "**Tabela de IR Progressivo (VGBL)**\n"
        "- A alíquota é determinada pelo valor total do resgate (não pelo rendimento)\n"
        "- Até R$ 22.847,76: Isento\n"
        "- De R$ 22.847,77 a R$ 33.919,80: 7,5%\n"
        "- De R$ 33.919,81 a R$ 45.012,60: 15%\n"
        "- De R$ 45.012,61 a R$ 55.976,16: 22,5%\n"
        "- Acima de R$ 55.976,16: 27,5%\n\n"
        " "
    )

    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown("### **Geral**")
            valor_inicial = gr.Number(label="Valor Inicial (R$)", value=300000)
            prazo_meses = gr.Number(label="Prazo (meses)", value=3)
            aporte_mensal = gr.Number(label="Aporte Mensal (R$)", value=0)

            gr.Markdown("---")
            gr.Markdown("### **CDB**")
            taxa_cdi = gr.Number(label="Taxa CDI Anual (%)", value=14.5)
            percentual_cdi_cdb = gr.Number(label="Percentual do CDI (%)", value=97)

            gr.Markdown("---")
            gr.Markdown("### **LCA**")
            percentual_cdi_lca = gr.Number(label="Percentual do CDI (%)", value=93)

            gr.Markdown("---")
            gr.Markdown("### **VGBL**")
            rentabilidade_anual = gr.Number(label="Rentabilidade Anual (%)", value=10)
            taxa_adm = gr.Number(label="Taxa de Administração (%)", value=1)
            taxa_carregamento = gr.Number(label="Taxa de Carregamento (%)", value=0)

        with gr.Column(scale=1):
            gr.Markdown("### **Resultados da simulação**")
            resultados = gr.Textbox(label="Resultados")
            grafico = gr.Image(label="Gráfico de Rendimento Líquido")

    botao = gr.Button("Simular")
    botao.click(
        simulador,
        inputs=[
            valor_inicial, prazo_meses, aporte_mensal,
            taxa_cdi, percentual_cdi_cdb, percentual_cdi_lca,
            rentabilidade_anual, taxa_adm, taxa_carregamento
        ],
        outputs=[resultados, grafico]
    )

# Executando a interface
interface.launch()