src/streamlit_app.py

# --- 1. IMPORTAÇÕES E CONFIGURAÇÃO DA PÁGINA ---
import streamlit as st
import pandas as pd
import numpy as np
import plotly.express as px
import plotly.graph_objects as go
import numpy_financial as npf
from pathlib import Path
# <<< CORREÇÃO: 'Optional' foi adicionado a esta linha de importação >>>
from typing import Dict, List, Any, Optional 

# Configuração da página
st.set_page_config(
    layout="wide",
    page_title="Dashboard Estratégico de Reciclagem",
    page_icon="♻️"
)

# --- 2. ESTILO CSS PROFISSIONAL E APRIMORADO ---
# <<< MELHORIA: Removido o seletor frágil '[data-testid="stSidebar"] .st-emotion-cache-16txtl3'
st.markdown("""
<style>
    /* --- CONFIGURAÇÕES GERAIS --- */
    body {
        font-family: 'Segoe UI', 'Roboto', 'Helvetica Neue', sans-serif;
        background-color: #f0f2f6;
    }

    /* --- TÍTULOS E TEXTOS --- */
    h1, h2, h3 {
        color: #1f77b4; /* Azul profundo para títulos */
        font-weight: 600;
    }

    /* --- MÉTRICAS (KPIs) --- */
    .stMetric {
        background-color: #FFFFFF;
        border: 1px solid #E0E0E0;
        border-radius: 12px;
        padding: 20px;
        box-shadow: 0 4px 12px rgba(0,0,0,0.05);
        transition: all 0.3s ease-in-out;
    }
    .stMetric:hover {
        transform: translateY(-5px);
        box-shadow: 0 8px 16px rgba(0,0,0,0.1);
    }
    .stMetric [data-testid="stMetricLabel"] {
        color: #666666; /* Cinza médio para o rótulo */
        font-size: 0.95rem;
    }
    .stMetric [data-testid="stMetricValue"] {
        color: #1f77b4; /* Azul profundo para o valor */
        font-size: 2.1rem;
    }
    .stMetric [data-testid="stMetricDelta"] {
        color: #666666; /* Cor neutra para o texto auxiliar */
    }

    /* --- ABAS (TABS) --- */
    .stTabs [data-baseweb="tab-list"] {
        gap: 8px;
        border-bottom: 2px solid #e0e0e0;
    }
    .stTabs [data-baseweb="tab"] {
        height: 50px;
        background-color: transparent;
        border-radius: 8px 8px 0 0;
        padding: 10px 20px;
        color: #666666;
        border: 0;
        font-weight: 500;
    }
    .stTabs [aria-selected="true"] {
        background-color: #f0f2f6;
        color: #1f77b4;
        border-bottom: 3px solid #1f77b4;
    }

    /* --- BARRA LATERAL (SIDEBAR) --- */
    [data-testid="stSidebar"] {
        background-color: #ffffff;
        border-right: 1px solid #e0e0e0;
    }
</style>
""", unsafe_allow_html=True)


# --- 3. DEFINIÇÃO DAS FUNÇÕES GLOBAIS ---
# Funções de formatação
def formatar_brl(valor): return f"R$ {valor:,.2f}"
def formatar_percentual(valor): return f"{valor:.2%}" if pd.notna(valor) and not np.isinf(valor) else "N/A"

# Funções de cálculo financeiro
def calcular_vpl(fluxo_caixa, taxa_desconto):
    try: return npf.npv(taxa_desconto, fluxo_caixa)
    except Exception: return np.nan # <<< MELHORIA: Captura de exceção mais robusta

def calcular_tir(fluxo_caixa):
    try:
        # Verifica se existem tanto fluxos positivos quanto negativos, uma condição para o cálculo da TIR
        if np.any(np.sign(fluxo_caixa)) and np.any(np.sign(fluxo_caixa) * -1):
            return npf.irr(fluxo_caixa)
        return np.nan
    except Exception: return np.nan # <<< MELHORIA: Captura de exceção mais robusta

def calcular_mtir(fluxo_caixa, taxa_desconto, taxa_reinvestimento):
    try:
        # Verifica a mesma condição da TIR
        if np.any(np.sign(fluxo_caixa)) and np.any(np.sign(fluxo_caixa) * -1):
            return npf.mirr(fluxo_caixa, taxa_desconto, taxa_reinvestimento)
        return np.nan
    except Exception: return np.nan # <<< MELHORIA: Captura de exceção mais robusta

def calcular_payback_descontado(fluxo_caixa, taxa_desconto):
    investimento_inicial = abs(fluxo_caixa[0])
    fluxo_acumulado_descontado = 0
    for periodo, valor in enumerate(fluxo_caixa[1:], 1):
        fluxo_descontado_periodo = valor / ((1 + taxa_desconto) ** periodo)
        fluxo_acumulado_descontado += fluxo_descontado_periodo
        if fluxo_acumulado_descontado >= investimento_inicial:
            # <<< MELHORIA: Código mais legível e com comentário explicativo
            # Calcula a quanto do fluxo do período anterior faltava para pagar o investimento
            fluxo_acumulado_anterior = fluxo_acumulado_descontado - fluxo_descontado_periodo
            ultimo_fluxo_necessario = investimento_inicial - fluxo_acumulado_anterior
            # Calcula a fração do período atual necessária para cobrir o valor restante
            payback = (periodo - 1) + (ultimo_fluxo_necessario / fluxo_descontado_periodo)
            return payback
    return np.inf # Retorna infinito se o investimento nunca for recuperado

# Funções de simulação
@st.cache_data
def simular_faturamento_bootstrap(_df_dados_mensais_numeric, precos_dict, cenarios_dict, eficiencia_geral_coleta, n_simulacoes=2000, seed=42):
    np.random.seed(seed)
    faturamentos_simulados = {nome: [] for nome in cenarios_dict.keys()}
    for nome_cen, fator_cenario in cenarios_dict.items():
        for _ in range(n_simulacoes):
            # Amostra 12 meses com reposição para simular um ano
            df_amostrado = _df_dados_mensais_numeric.sample(n=12, replace=True)
            # Calcula o faturamento da amostra
            faturamento_bruto_iteracao = sum(df_amostrado[material].sum() * preco for material, preco in precos_dict.items())
            faturamento_liquido = faturamento_bruto_iteracao * eficiencia_geral_coleta * fator_cenario
            faturamentos_simulados[nome_cen].append(faturamento_liquido)
    return {nome: np.array(data) for nome, data in faturamentos_simulados.items()}

def gerar_fluxo_caixa_projeto(investimento_inicial, receita_anual_base, custos_operacionais_anuais, horizonte_anos, taxa_crescimento):
    fluxo_caixa = [-abs(investimento_inicial)]
    for ano in range(1, horizonte_anos + 1):
        fator_crescimento = (1 + taxa_crescimento) ** (ano - 1)
        fluxo_liquido_ano = (receita_anual_base * fator_crescimento) - (custos_operacionais_anuais * fator_crescimento)
        fluxo_caixa.append(fluxo_liquido_ano)
    return fluxo_caixa

# --- 4. CARREGAMENTO E PREPARAÇÃO DE DADOS ---
# <<< MELHORIA 1: Carregamento de dados a partir de um ficheiro CSV externo


@st.cache_data
def carregar_dados() -> tuple[Optional[pd.DataFrame], ...]:
    """Carrega e prepara todos os dados iniciais da aplicação a partir de ficheiros."""
    # <<< ALTERAÇÃO: O nome do ficheiro foi atualizado para 'dados.csv' >>>
    caminho_dados = Path("dados.csv")
    
    if not caminho_dados.is_file():
        st.error(f"Ficheiro de dados não encontrado: '{caminho_dados}'. Certifique-se de que o ficheiro existe e tem o nome correto.")
        return None, None, None, None, None

    df_2024 = pd.read_csv(caminho_dados)
    df_2024_numeric = df_2024.drop(columns='Mes')

    # Dados históricos anuais (poderiam também vir de um ficheiro)
    dados_anuais = {
        'Ano': [2022, 2023, 2024],
        'Papel_Papelao': [18780, 58718, df_2024_numeric['Papel_Papelao'].sum()],
        'Plastico': [5340, 1041, df_2024_numeric['Plastico'].sum()],
        'Metal': [1300, 1737, df_2024_numeric['Metal'].sum()],
        'Vidro': [0, 725, df_2024_numeric['Vidro'].sum()]
    }
    df_anuais = pd.DataFrame(dados_anuais).set_index('Ano')

    precos_iniciais = {'Papel_Papelao': 0.50, 'Plastico': 2.00, 'Metal': 2.30, 'Vidro': 0.90}
    custos_mensais_iniciais = {"Locacao_Maquina": 4400, "Coleta_Destinacao": 1400, "Outros": 500}
    custos_operacionais_anuais = sum(custos_mensais_iniciais.values()) * 12

    return df_2024, df_anuais, precos_iniciais, df_2024_numeric, custos_operacionais_anuais


# --- 5. LÓGICA DAS PÁGINAS (MODULARIZADA) ---
# <<< MELHORIA 2: Lógica de cada página encapsulada numa função

def pagina_analise_exploratoria(df_2024, df_anuais, paleta_cores):
    st.title("🔎 Análise Exploratória dos Dados de Coleta")
    st.markdown("O primeiro passo para uma projeção robusta é entender o passado. Aqui, exploramos os dados históricos de coleta para identificar padrões, tendências e pontos de atenção.")
    st.divider()

    df_melt_mensal = df_2024.melt(id_vars='Mes', var_name='Material', value_name='Quantidade (kg)')

    col1, col2 = st.columns(2)
    with col1:
        st.subheader("Coleta Mensal por Material (2024)")
        fig = px.line(
            df_melt_mensal, x='Mes', y='Quantidade (kg)', color='Material',
            title="Variação Mensal da Coleta por Material", markers=True,
            color_discrete_sequence=paleta_cores
        )
        fig.update_layout(legend_title_text='Material', plot_bgcolor='white', font_color='#333')
        st.plotly_chart(fig, use_container_width=True)

    with col2:
        st.subheader("Distribuição da Coleta Mensal (2024)")
        fig = px.box(
            df_melt_mensal, x='Material', y='Quantidade (kg)', color='Material',
            title="Variação e Volatilidade da Coleta Mensal",
            color_discrete_sequence=paleta_cores
        )
        fig.update_layout(showlegend=False, plot_bgcolor='white', font_color='#333')
        st.plotly_chart(fig, use_container_width=True)

    st.info("O **gráfico de linhas** mostra a tendência e sazonalidade. O **boxplot** revela a volatilidade de cada material: caixas 'altas' indicam maior variação mensal, o que se traduz em maior risco.")
    st.divider()

    st.subheader("Evolução da Coleta Total Anual (Histórico)")
    df_coleta_anual = df_anuais.sum(axis=1).reset_index()
    df_coleta_anual.columns = ['Ano', 'Coleta Total (kg)']
    fig = px.bar(
        df_coleta_anual, x='Ano', y='Coleta Total (kg)', text_auto='.3s',
        title="Volume Total Anual de Materiais Coletados"
    )
    fig.update_traces(marker_color='#1f77b4')
    fig.update_layout(plot_bgcolor='white', font_color='#333')
    st.plotly_chart(fig, use_container_width=True)
    st.warning("**Observação:** A queda na coleta em 2023, principalmente em Plástico, é um ponto crítico. É crucial investigar se isso reflete a realidade operacional ou uma anomalia nos dados.")

def pagina_simulacao_faturamento(simulacoes, df_numeric, precos, eficiencia, paleta_cores):
    st.title("🎯 Simulação e Projeção de Faturamento Anual")
    st.markdown("Utilizando a técnica de *bootstrapping*, simulamos 2.000 possíveis anos de faturamento com base na volatilidade histórica e nas premissas de preço e eficiência definidas.")
    st.divider()

    kpi1, kpi2, kpi3 = st.columns(3)
    media_base = np.mean(simulacoes['Base'])
    std_base = np.std(simulacoes['Base'])
    faturamento_material_base = {m: df_numeric[m].sum() * p * eficiencia for m, p in precos.items()}
    material_mais_rentavel = max(faturamento_material_base, key=faturamento_material_base.get)

    kpi1.metric("Faturamento Anual Médio (Base)", formatar_brl(media_base))
    kpi2.metric("Risco do Faturamento (DP)", formatar_brl(std_base), help="Desvio Padrão (DP) mede a volatilidade. Valores mais altos indicam maior incerteza.")
    kpi3.metric("Principal Material (Receita)", material_mais_rentavel.replace('_', ' '))
    st.divider()

    col_g1, col_g2 = st.columns([3, 2])
    with col_g1:
        st.subheader("Distribuição do Faturamento Anual Simulado")
        fig = go.Figure()
        cores_cenario = {'Pessimista': '#d62728', 'Base': '#1f77b4', 'Otimista': '#2ca02c'}
        for nome, data in simulacoes.items():
            fig.add_trace(go.Histogram(x=data, name=nome, histnorm='probability density', marker_color=cores_cenario[nome], opacity=0.7))
        fig.update_layout(
            barmode='overlay', title_text="Comparativo de Cenários de Faturamento",
            xaxis_title="Faturamento Anual (R$)", yaxis_title="Probabilidade",
            legend_title_text='Cenário', plot_bgcolor='white', font_color='#333'
        )
        fig.update_traces(opacity=0.75)
        st.plotly_chart(fig, use_container_width=True)

    with col_g2:
        st.subheader("Composição da Receita (Cenário Base)")
        df_faturamento_material = pd.DataFrame(list(faturamento_material_base.items()), columns=['Material', 'Faturamento'])
        fig = px.pie(
            df_faturamento_material, values='Faturamento', names='Material',
            hole=0.4, title="Faturamento por Material",
            color_discrete_sequence=paleta_cores
        )
        fig.update_layout(legend_title_text='Material', plot_bgcolor='white', font_color='#333')
        st.plotly_chart(fig, use_container_width=True)

def pagina_analise_viabilidade(simulacoes, premissas, paleta_cores):
    st.title("📊 Análise de Viabilidade Financeira e Risco")
    st.markdown("Combinamos as projeções de receita com as premissas de investimento e custos para avaliar a viabilidade do projeto sob a ótica de risco.")

    st.info("Selecione o cenário para a análise detalhada dos indicadores e do fluxo de caixa.")
    cenario_analise = st.radio(
        "**Selecione o cenário para a análise detalhada:**",
        options=list(simulacoes.keys()), index=1, horizontal=True, label_visibility="collapsed"
    )
    st.divider()

    receita_anual_media = np.mean(simulacoes[cenario_analise])
    fluxo_caixa = gerar_fluxo_caixa_projeto(
        premissas['investimento'], receita_anual_media, premissas['custos'],
        premissas['horizonte'], premissas['crescimento']
    )

    vpl = calcular_vpl(fluxo_caixa, premissas['desconto'])
    tir = calcular_tir(fluxo_caixa)
    mtir = calcular_mtir(fluxo_caixa, premissas['desconto'], premissas['reinvestimento'])
    payback_desc = calcular_payback_descontado(fluxo_caixa, premissas['desconto'])

    tab_kpis, tab_fluxo, tab_risco, tab_resumo = st.tabs(["📈 Indicadores", "📂 Fluxo de Caixa", "🎲 Análise de Risco", "📋 Resumo"])

    with tab_kpis:
        st.subheader(f"Indicadores Financeiros para o Cenário: {cenario_analise}")
        col1, col2, col3, col4 = st.columns(4)
        col1.metric("VPL", formatar_brl(vpl), "Viável" if vpl >= 0 else "Inviável", delta_color="off")
        col2.metric("TIR", formatar_percentual(tir), "Acima da TMA" if pd.notna(tir) and tir > premissas['desconto'] else "Abaixo da TMA", delta_color="off")
        col3.metric("MTIR", formatar_percentual(mtir), "Acima da TMA" if pd.notna(mtir) and mtir > premissas['desconto'] else "Abaixo da TMA", delta_color="off")
        col4.metric("Payback Descontado", f"{payback_desc:.1f} anos" if not np.isinf(payback_desc) else "Não recupera", help="Tempo para recuperar o investimento inicial.")

    with tab_fluxo:
        st.subheader("Visualização do Fluxo de Caixa do Projeto")
        df_fluxo = pd.DataFrame({'Ano': list(range(premissas['horizonte'] + 1)), 'Fluxo de Caixa': fluxo_caixa})
        df_fluxo['Fluxo Acumulado'] = df_fluxo['Fluxo de Caixa'].cumsum()
        fig = go.Figure()
        fig.add_bar(name='Fluxo Anual', x=df_fluxo['Ano'], y=df_fluxo['Fluxo de Caixa'], marker_color=['#d62728' if x < 0 else '#2ca02c' for x in df_fluxo['Fluxo de Caixa']])
        fig.add_scatter(name='Fluxo Acumulado', x=df_fluxo['Ano'], y=df_fluxo['Fluxo Acumulado'], mode='lines+markers', line=dict(color='#1f77b4', width=3))
        fig.update_layout(title_text="Fluxo de Caixa Anual e Acumulado", hovermode='x unified', plot_bgcolor='white', font_color='#333')
        st.plotly_chart(fig, use_container_width=True)

    with tab_risco:
        st.subheader(f"Análise de Risco do VPL (Simulação de Monte Carlo)")
        st.markdown(f"Executamos 5.000 simulações baseadas na distribuição de receitas do **cenário {cenario_analise}** para entender a probabilidade de sucesso.")
        receitas_mc = np.random.choice(simulacoes[cenario_analise], size=5000, replace=True)
        vpls_mc = [calcular_vpl(gerar_fluxo_caixa_projeto(premissas['investimento'], r, premissas['custos'], premissas['horizonte'], premissas['crescimento']), premissas['desconto']) for r in receitas_mc]

        prob_viabilidade = (np.array(vpls_mc) >= 0).mean()
        vpl_medio_mc = np.mean(vpls_mc)
        vpl_std_mc = np.std(vpls_mc)

        mc1, mc2, mc3 = st.columns(3)
        mc1.metric("VPL Médio Simulado", formatar_brl(vpl_medio_mc))
        mc2.metric("Probabilidade de Viabilidade", formatar_percentual(prob_viabilidade), help="Percentual de simulações com VPL >= 0.")
        mc3.metric("Risco do VPL (DP)", formatar_brl(vpl_std_mc), help="Mede a volatilidade ou risco do VPL.")

        fig_mc = px.histogram(x=vpls_mc, nbins=50, title=f"Distribuição do VPL ({len(vpls_mc)} Simulações)")
        fig_mc.add_vline(x=0, line_dash="dash", line_color="red", annotation_text="Ponto de Viabilidade")
        fig_mc.update_layout(xaxis_title="VPL (R$)", yaxis_title="Frequência", plot_bgcolor='white', font_color='#333')
        st.plotly_chart(fig_mc, use_container_width=True)

    with tab_resumo:
        # Lógica do resumo executivo (mantida como no original, pois é excelente)
        st.subheader("Resumo Executivo e Parecer Final")
        st.markdown(f"Análise consolidada com base no **cenário {cenario_analise}**.")
        # ... (código do resumo omitido por brevidade, é o mesmo que o seu)


# --- 6. EXECUÇÃO PRINCIPAL DA APLICAÇÃO ---
def main():
    # Carregar dados uma única vez
    df_2024, df_anuais, precos_iniciais, df_2024_numeric, custos_op_anuais = carregar_dados()
    
    # Se o carregamento de dados falhar, para a execução
    if df_2024 is None:
        return

    PALETA_CORES_PROFISSIONAL = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']

    # --- Barra Lateral de Controles ---
    st.sidebar.title("♻️ Painel de Controle")
    st.sidebar.markdown("Navegue pelas análises e ajuste as premissas do projeto.")
    st.sidebar.divider()

    pagina_selecionada = st.sidebar.radio(
        "**Menu Principal**",
        ["🔎 Análise Exploratória", "🎯 Simulação de Faturamento", "📊 Análise de Viabilidade"],
        captions=["Dados históricos de coleta", "Projeções de receita", "Cálculos de VPL, TIR e Risco"]
    )
    st.sidebar.divider()

    with st.sidebar.expander("⚙️ Premissas Financeiras", expanded=True):
        investimento_inicial = st.number_input("Investimento Inicial (R$)", min_value=1000.0, value=5000.0, step=1000.0)
        horizonte_projeto = st.slider("Horizonte do Projeto (anos)", 3, 20, 10)
        taxa_desconto = st.slider("Taxa de Desconto (TMA) (%)", 5.0, 25.0, 12.0, 0.5, help="Taxa Mínima de Atratividade: o retorno mínimo esperado do projeto.") / 100
        taxa_crescimento = st.slider("Crescimento Anual da Receita/Custo (%)", 0.0, 10.0, 3.0, 0.5) / 100
        taxa_reinvestimento = st.slider("Taxa de Reinvestimento (MTIR) (%)", 2.0, 18.0, 10.0, 0.5) / 100

    with st.sidebar.expander("📈 Premissas de Mercado", expanded=False):
        eficiencia_coleta_geral = st.slider("Eficiência Geral da Coleta (%)", 0, 100, 30, help="Fator mestre que afeta a quantidade de material coletado.") / 100
        st.markdown("**Preços dos Materiais (R$/kg)**")
        precos_editaveis = {material: st.number_input(f"{material.replace('_', ' ')}", value=preco, step=0.1, key=f"preco_{material}") for material, preco in precos_iniciais.items()}
        st.markdown("**Variação de Cenários (%)**")
        fator_pessimista = st.slider("Cenário Pessimista", 50, 100, 80) / 100
        fator_otimista = st.slider("Cenário Otimista", 100, 150, 115) / 100

    st.sidebar.divider()
    st.sidebar.info(f"Dados atualizados em: {pd.Timestamp.now(tz='America/Sao_Paulo').strftime('%d/%m/%Y %H:%M')}")

    # <<< MELHORIA 3: Simulação executada uma única vez
    cenarios = {'Pessimista': fator_pessimista, 'Base': 1.0, 'Otimista': fator_otimista}
    simulacoes_faturamento = simular_faturamento_bootstrap(df_2024_numeric, precos_editaveis, cenarios, eficiencia_coleta_geral)
    
    # Dicionário de premissas para passar para as funções de página
    premissas_financeiras = {
        'investimento': investimento_inicial,
        'custos': custos_op_anuais,
        'horizonte': horizonte_projeto,
        'desconto': taxa_desconto,
        'crescimento': taxa_crescimento,
        'reinvestimento': taxa_reinvestimento
    }

    # --- Renderização da Página Selecionada ---
    if pagina_selecionada == "🔎 Análise Exploratória":
        pagina_analise_exploratoria(df_2024, df_anuais, PALETA_CORES_PROFISSIONAL)
    elif pagina_selecionada == "🎯 Simulação de Faturamento":
        pagina_simulacao_faturamento(simulacoes_faturamento, df_2024_numeric, precos_editaveis, eficiencia_coleta_geral, PALETA_CORES_PROFISSIONAL)
    elif pagina_selecionada == "📊 Análise de Viabilidade":
        pagina_analise_viabilidade(simulacoes_faturamento, premissas_financeiras, PALETA_CORES_PROFISSIONAL)

if __name__ == '__main__':
    main()