apps/simulacion_vc.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 21 11:53:13 2021

@author: benjaminull
"""

import numpy as np
import streamlit as st
import plotly.express as px
import pandas as pd
import scipy.stats as stats
import plotly.express as px
import scipy.stats as stats
import plotly.graph_objects as go
from sqlalchemy import create_engine
import pybase64 as base64
import io
import matplotlib.pyplot as plt
from io import StringIO
import pandas as pd

@st.cache(allow_output_mutation=True)
def read_excel(path):
    df = pd.read_excel(path)
    return df

@st.cache(allow_output_mutation=True)
def read_excel2(path):
    df = pd.read_excel(path)
    return df

def explorar_data():
    df = read_excel('base_personas.xlsx')
    df2 = read_excel2('base_personas.xlsx')
    data = df.copy()
    data2 = df2.copy()
    l=[]

    variable = st.selectbox(" ",list(data.columns))
    for i in list(data2.columns):
        if i not in ["FE", "EDAD", variable]:
            try:
                data2[i] =  data2[i]* data2["FE"]
            except:
                pass
    col1, col2 = st.beta_columns(2)
    minim = col1.number_input("Edad minima", min_value=0, max_value=105)
    maxim = col2.number_input("Edad maxima", min_value=0, max_value=105, value=105)
    data = data[data["EDAD"] < maxim]
    data = data[data["EDAD"] > minim]
    data2 = data2[data2["EDAD"] < maxim]
    data2 = data2[data2["EDAD"] > minim]
    pond = st.checkbox("Ponderar por FE")
    import plotly.graph_objects as go
    if pond:
        data_f3 = data2.groupby([ variable, "EDAD"]).sum()
        data_f3 = data_f3.loc[:,data_f3.columns[0]].unstack(level=1).replace(np.nan, 0)
        st.write(data_f3)
    
    
        fig = go.Figure()
        for i in list(data_f3.index):
            fig.add_trace(go.Scatter(
                x=list(data_f3.columns), y=list(data_f3.loc[i,:]),
                mode='lines',
                line=dict(width=0.5),
                stackgroup='one',
                groupnorm='percent' # sets the normalization for the sum of the stackgroup
            ))
    
        fig.update_layout(
            showlegend=True,
            xaxis_type='category',
            yaxis=dict(
                type='linear',
                range=[1, 100],
                ticksuffix='%'))
        
        st.plotly_chart(fig, use_container_width=True)

    else:
        data_f = data.groupby([ variable, "EDAD"]).count()
        data_f2 = data_f.loc[:,data_f.columns[0]].unstack(level=1).replace(np.nan, 0)
        st.write(data_f2)
        fig = go.Figure()
        for i in list(data_f2.index):
            fig.add_trace(go.Scatter(
                x=list(data_f2.columns), y=list(data_f2.loc[i,:]),
                mode='lines',
                line=dict(width=0.5),
                stackgroup='one',
                groupnorm='percent' # sets the normalization for the sum of the stackgroup
            ))
    
        fig.update_layout(
            showlegend=True,
            xaxis_type='category',
            yaxis=dict(
                type='linear',
                range=[1, 100],
                ticksuffix='%'))
        
        st.plotly_chart(fig, use_container_width=True)
    

    # pr = data_f2.profile_report()

    # st_profile_report(data_f2)

def transform_df(scraping_df):
    # Extract numbers from string
    # Change datatype
    # Add 'Comuna' and 'Región'
    scraping_df[["Comuna"]] = scraping_df[[
        "direccion"]].applymap(lambda x: get_comuna(x))
    # Scrap UF value for date
    #scraping_df[["Valor UF"]] = get_UF()
    return scraping_df


def get_table_excel_link(df, name):
    towrite = io.BytesIO()
    downloaded_file = df.to_excel(towrite, encoding='utf-8', index=False,
                                  header=True)
    towrite.seek(0)  # reset pointer
    file_name = 'Data' + name + '.xlsx'
    style = 'style="color:black;text-decoration: none; font-size:18px;"'
    name_mark = "Descargar " + name + ".xlsx"
    b64 = base64.b64encode(towrite.read()).decode()  # some strings
    linko = f'<center><a href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}" ' + \
        style+'download="'+file_name+'"><button>'+name_mark+'</button></a></center>'
    return linko


def get_comuna(direction):
    values = direction.split(',')
    return values[-2]


def formatnum(numero):
    '''
    Esta función permite dar formato a los montos de saldo y valor cuota en 
    las cartolas.
    '''
    return '{:,.0f}'.format(numero).replace(",", "@").replace(".", ",").replace("@", ".")


def sim_norm():
    with st.form(key='my_form'):
        col1, col2 = st.beta_columns(2)
        sim = col1.number_input("Nº Simulaciones", min_value=1, value=100)
        vc = col2.number_input("Cuota inicial", min_value=100)
        col1, col2, col3 = st.beta_columns(3)
        mu = col1.number_input("µ Fondo Arriesgado", value=0.1)
        sigma = col1.number_input("σ Fondo Arriesgado", value=0.1)
        mu2 = col2.number_input("µ Fondo Intermedio ", value=0.05)
        sigma2 = col2.number_input("σ Fondo Intermedio", value=0.05)
        mu3 = col3.number_input("µ Fondo Conservador", value=-0.01)
        sigma3 = col3.number_input("σ Fondo Conservador", value=0.03)
        # t= col1.number_input("Periodo", value=288)
        # t2 = col2.number_input("Periodo ", value=120)
        # t3 = col3.number_input("Periodo  ", value=72)
        values = st.slider(
            'Seleccione los años de cambio de fondo', 0, 40, (33, 38))
        with st.beta_expander("Ajustar parámetros de distribucion de permanencia del cliente (gamma)"):
            col1, col2 = st.beta_columns(2)
            alpha = col1.number_input("alpha", value=1.5)
            beta = col2.number_input("lambda", value=71.1)
        submit_button = st.form_submit_button(label='Actualizar')
    if submit_button:
        t = values[0]*12
        t2 = values[1]*12-t
        t3 = 480-t2-t
        mu = mu / 12
        mu2 = mu2 / 12
        mu3 = mu3 / 12
        sigma = sigma / (12**(1/2))
        sigma2 = sigma2 / (12**(1/2))
        sigma3 = sigma3 / (12**(1/2))
        var_al = np.random.normal(mu, sigma, size=(t, sim))
        var_al2 = np.random.normal(mu2, sigma2, size=(t2, sim))
        var_al3 = np.random.normal(mu3, sigma3, size=(t3, sim))
        simulacion = np.zeros((t + t2 + t3, sim))
        simulacion[0, :] = vc
        dist_gamma = stats.gamma.rvs(alpha, scale=beta, size=sim).astype(int)+1
        for i in range(1, t):
            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al[i-1, :])
        for i in range(t, t+t2):
            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al2[t-i-1, :])
        for i in range(t+t2, t+t2+t3):
            simulacion[i, :] = simulacion[i - 1, :] * \
                (1 + var_al3[t2+t-i-1, :])
        retornos = np.zeros(sim)
        for j in range(sim):
            ingreso = 480-dist_gamma[j]
            simulacion[0:ingreso, j] = None
            simulacion[ingreso:480, j] = simulacion[ingreso:480, j] * \
                vc/simulacion[ingreso, j]
            retorno = (simulacion[-1, j]/simulacion[ingreso, j]
                       )**(1/(dist_gamma[j]/12))-1
            retornos[j] = retorno
        df = pd.DataFrame(simulacion)
        df["meses"] = list(df.index)
        fig = px.line(df, x="meses", y=df.columns,
                      title='Simulaciones')
        fig.layout.update(xaxis_rangeslider_visible=True)
        fig.add_vline(x=t, line_width=3, line_dash="dash", line_color="grey")
        fig.add_vline(x=t+t2, line_width=3,
                      line_dash="dash", line_color="grey")
        fig.add_vrect(x0=0, x1=t, annotation_text="Arries",
                      annotation_position="top",
                      fillcolor="red", opacity=0.15, line_width=0)
        fig.add_vrect(x0=t, x1=t+t2,
                      annotation_text="Inter", annotation_position="top",
                      fillcolor="midnightblue", opacity=0.15, line_width=0)
        fig.add_vrect(x0=t + t2, x1=t + t2 + t3,
                      annotation_text="Cons", annotation_position="top",
                      fillcolor="seagreen", opacity=0.15, line_width=0)
        fig.update_layout(height=600, width=950)
        st.plotly_chart(fig, use_container_width=True)
        st.subheader("Distribución de duracion de clientes")
        df_in = pd.DataFrame(dist_gamma//12, columns=["ingreso"])
        fig = px.histogram(df_in, x="ingreso", nbins=40)
        fig.add_vline(x=(dist_gamma//12).mean(), line_width=3,
                      line_dash="dash", line_color="midnightblue")
        col1, col2 = st.beta_columns((3, 1))
        col1.plotly_chart(fig, use_container_width=True)
        col2.title("  ")
        col2.header("µ = "+str((dist_gamma//12).mean())[0:4] + " años")
        col2.subheader("σ = "+str((dist_gamma//12).std())[0:4] + " años")
        st.subheader("Distribución de retorno anual")
        col1, col2 = st.beta_columns((3, 1))
        df_ret = pd.DataFrame(retornos, columns=["retornos"])
        col2.title("  ")
        col2.header("µ = "+str((retornos.mean()*100))[0:4] + "%")
        col2.subheader("σ = "+str((retornos.std())*100)[0:4] + "%")
        fig2 = px.histogram(df_ret, x="retornos", nbins=50)
        retorno_fc = (1.053)*(1.0312)-1
        if retornos.mean() > 0.0312:
            posicion1 = "top right"
            posicion2 = "top left"
        else:
            posicion2 = "top right"
            posicion1 = "top left"
        fig2.add_vline(x=retornos.mean(), line_width=3, line_dash="dash",
                       line_color="midnightblue", annotation_font_color="midnightblue",
                       annotation_position=posicion1,
                       annotation_text=str(round(retornos.mean()*100, 1))+"%")
        fig2.add_vline(x=0.0312, line_width=3, line_dash="dash",
                       annotation_font_color="red",
                       annotation_position=posicion2,
                       line_color="red", annotation_text="3,12%")
        fig2.add_vline(x=retorno_fc, line_width=3, line_dash="dash",
                       annotation_font_color="green",
                       annotation_position=posicion2,
                       line_color="green", annotation_text=str(round(retorno_fc, 2)*100)+"%")
        fig2.add_vline(x=0.00, line_width=3, line_dash="dash",
                       line_color="yellow")
        col1.plotly_chart(fig2, use_container_width=True)
        col1, col2 = st.beta_columns((1, 8))
        col2.write(str(round(sum(df_ret["retornos"] > 0.00)/len(df_ret)*100, 0)) +
                   "%: Probabilidad de que un clientes tenga retorno mayor a 0%")
        col2.write(str(round(sum(df_ret["retornos"] > 0.0312)/len(df_ret)*100, 0)) +
                   "%: Probabilidad de que un clientes tenga un retorno mayor a 3,12% (Inflación)")
        col2.write(str(round(sum(df_ret["retornos"] > retorno_fc)/len(df_ret)*100, 0)) +
                   "%: Probabilidad de que un clientes tenga retorno mayor a "+str(round(retorno_fc, 2)*100)+"% (Fondo C)")


def sim_2():
    with st.form(key='my_form'):
        col1, col2 = st.beta_columns(2)
        sim = col1.number_input("Nº Simulaciones", min_value=1, value=100)
        vc = col2.number_input("Cuota inicial", min_value=100)
        col1, col2, col3 = st.beta_columns(3)
        mu = col1.number_input("µ Fondo Arriesgado", value=0.1)
        sigma = col1.number_input("σ Fondo Arriesgado", value=0.1)
        mu2 = col2.number_input("µ Fondo Intermedio ", value=0.05)
        sigma2 = col2.number_input("σ Fondo Intermedio", value=0.05)
        mu3 = col3.number_input("µ Fondo Conservador", value=-0.01)
        sigma3 = col3.number_input("σ Fondo Conservador", value=0.03)
        values = st.slider('Seleccione los años de cambio de fondo', 0, 40,
                           (33, 38))
        with st.beta_expander("Ajustar parámetros de distribucion de permanencia del cliente (gamma)"):
            col1, col2 = st.beta_columns(2)
            alpha = col1.number_input("alpha", value=1.5)
            beta = col2.number_input("lambda", value=71.1)
        submit_button = st.form_submit_button(label='Actualizar')
    if submit_button:
        t = values[0]*12
        t2 = values[1]*12-t
        t3 = 480-t2-t
        mu = mu / 12
        mu2 = mu2 / 12
        mu3 = mu3 / 12
        sigma = sigma / (12 ** (1/2))
        sigma2 = sigma2 / (12 ** (1/2))
        sigma3 = sigma3 / (12 ** (1/2))
        var_al = np.random.normal(mu, sigma, size=(t, sim))
        var_al2 = np.random.normal(mu2, sigma2, size=(t2, sim))
        var_al3 = np.random.normal(mu3, sigma3, size=(t3, sim))
        simulacion = np.zeros((t + t2 + t3, sim))
        simulacion[0, :] = vc
        dist_gamma = stats.gamma.rvs(alpha, scale=beta, size=sim).astype(int)+1
        for i in range(1, t):
            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al[i-1, :])
        for i in range(t, t+t2):
            simulacion[i, :] = simulacion[i - 1, :] * (1 + var_al2[t-i-1, :])
        for i in range(t+t2, t+t2+t3):
            simulacion[i, :] = simulacion[i - 1, :] * \
                (1 + var_al3[t2+t-i-1, :])
        retornos = np.zeros(sim)
        for j in range(sim):
            ingreso = 480-dist_gamma[j]
            simulacion[0:ingreso, j] = None
            simulacion[ingreso:480, j] = simulacion[ingreso:480, j] * \
                vc/simulacion[ingreso, j]
            retorno = (simulacion[-1, j]/simulacion[ingreso, j]
                       )**(1/(dist_gamma[j]/12))-1
            retornos[j] = retorno
        df = pd.DataFrame(simulacion)
        df["meses"] = list(df.index)
        fig = px.line(df, x="meses", y=df.columns,
                      title='Simulaciones')
        fig.layout.update(xaxis_rangeslider_visible=True)
        fig.add_vline(x=t, line_width=3, line_dash="dash", line_color="grey")
        fig.add_vline(x=t+t2, line_width=3, line_dash="dash",
                      line_color="grey")
        fig.add_vrect(x0=0, x1=t, annotation_text="Arries",
                      annotation_position="top",
                      fillcolor="red", opacity=0.15, line_width=0)
        fig.add_vrect(x0=t, x1=t+t2,
                      annotation_text="Inter", annotation_position="top",
                      fillcolor="midnightblue", opacity=0.15, line_width=0)
        fig.add_vrect(x0=t + t2, x1=t + t2 + t3,
                      annotation_text="Cons", annotation_position="top",
                      fillcolor="seagreen", opacity=0.15, line_width=0)
        fig.update_layout(height=600, width=950)
        st.plotly_chart(fig, use_container_width=True)
        sigma_sim1 = np.random.normal(sigma, 0.009, size=480)
        sigma_sim2 = np.random.normal(sigma2, 0.004, size=480)
        sigma_sim3 = np.random.normal(sigma3, 0.001, size=480)
        sigma_comb = np.zeros(480)
        sigma_comb[0:t] = sigma_sim1[0:t]
        sigma_comb[t:t+t2] = sigma_sim2[t:t+t2]
        sigma_comb[t+t2:480] = sigma_sim3[t+t2:480]
        sigma_comb2 = np.zeros(480)
        retorno_comb = np.zeros(480)
        for i in range(t):
            sigma_comb2[i] = sigma_sim1[i] * (1-i/t) + sigma_sim2[i] * i/t
            retorno_comb[i] = mu * (1-i/t) + mu2 * i/t
        for j in range(480-t):
            sigma_comb2[t + j] = sigma_sim2[t + j] * \
                (1-j/(480-t)) + sigma_sim3[t + j] * j/(480-t)
            retorno_comb[i] = mu2 * (1-j/(480-t)) + mu3 * j/(480-t)
        dfsig = pd.DataFrame(sigma_sim1, columns=["sig"])
        dfsig["mes"] = list(dfsig.index)
        dfsig["sigma inter"] = sigma_sim2
        dfsig["sigma cons"] = sigma_sim3
        dfsig["sigma por periodos"] = sigma_comb
        dfsig["sigma combinacion lineal"] = sigma_comb2
        dfsig["sigma combinacion lineal"] = dfsig["sigma combinacion lineal"].abs()
        var_al_comb = np.zeros(480)
        patr_al_comb = np.zeros(480)
        patr_al_comb[0] = vc
        for i in range(1, 480):
            var_al_comb[i] = np.random.normal(
                retorno_comb[i],
                dfsig["sigma combinacion lineal"].iloc[i],
                size=1)
            patr_al_comb[i] = patr_al_comb[i-1]*(1 + var_al_comb[i-1])
        ingreso = 480-dist_gamma[0]

        data_comb = pd.DataFrame(patr_al_comb, columns=["Precio"])
        data_comb["mes"] = list(data_comb.index)
        data_comb = data_comb[data_comb["mes"] >= ingreso]
        data_comb["Precio"] = data_comb["Precio"]/data_comb.iloc[0]["Precio"]
        fig2 = px.line(dfsig, x='mes', y=dfsig.columns,
                       title='Simulaciones')
        st.plotly_chart(fig2)
        fig3 = px.line(data_comb, x='mes', y=data_comb.columns,
                       title='Simulaciones')
        st.plotly_chart(fig3)


def sim_inmob():
    url = """postgresql://tbgxsndupdarfp:5578576bc884e31a4f7e117a66a9dad8b13917e6a5262d85ff20f1f69cb4bf49@ec2-52-205-45-219.compute-1.amazonaws.com:5432/db5ktai215krcv"""
    engine = create_engine(url, echo=False)
    data = pd.read_sql_query("SELECT * FROM Scraping_inmob", con=engine)
    data = transform_df(data)
    col1, col2 = st.beta_columns((0.65, 1))
    placeholder = st.empty()
    placeholder2 = st.empty()
    placeholder3 = st.empty()
    placeholder4 = st.empty()
    dist_gamma = stats.gamma.rvs(1, scale=250000, size=2965)
    dist_norm = np.random.normal(734874, 1250, size=2965)
    data_hist = data[data["mercado"] == "venta"]
    data_hist = data_hist[data_hist["valor_peso"]
                          < 400000000]["valor_peso"] * 0.2
    fig2 = go.Figure()
    fig3 = go.Figure()
    fig4 = go.Figure()
    fig2.add_trace(go.Histogram(x=dist_norm, name='Dist Ingreso'))
    # fig2.add_vline(x=data_hist.mean(), line_width=3, line_dash="dash", line_color="darkred")
    # fig2.add_vline(x=dist_gamma.mean(), line_width=3, line_dash="dash", line_color="darkblue")
    fig3.add_trace(go.Histogram(x=data_hist, name='Data real'))
    a = sorted(data_hist)
    b = sorted(dist_norm)
    dist_periodo = [(x)/y for x, y in zip(a, b)]
    dist_periodo = [i for i in dist_periodo if i < 480]
    fig4.add_trace(go.Histogram(x=dist_periodo, name='Dist periodo'))
    # Overlay both histograms
    # fig2.update_layout(barmode='overlay')
    # Reduce opacity to see both histograms
    fig2.update_traces(opacity=0.75)
    #fig2 = px.histogram((data_hist), x='valor_peso', color_discrete_sequence=['indianred'])
    placeholder2.plotly_chart(fig2, use_container_width=True)
    placeholder.subheader("µ Capacidad de ahorro: $" +
                          formatnum(dist_norm.mean()))
    placeholder4.plotly_chart(fig3, use_container_width=True)
    placeholder3.subheader("µ Pie vivienda: $" + formatnum(data_hist.mean()))
    st.plotly_chart(fig4, use_container_width=True)
    st.subheader("µ Period: " + formatnum(np.array(dist_periodo).mean()))
    df = pd.DataFrame([a, b, dist_periodo])
    df2 = df.T
    st.markdown(get_table_excel_link(df2[df2[2] < 480], "Distribucion"),
                unsafe_allow_html=True)
    data_hist = data[data["mercado"] == "venta"]
    data_hist = data_hist[data_hist["valor_peso"] > 40000000]
    data_hist = data_hist[data_hist["valor_peso"]
                          < 1000000000]["valor_peso"] * 0.2
    fig2 = px.histogram((data_hist), x='valor_peso')


def sim_ingreso_clientes():
    with st.form(key='my_form'):
        col1, col2 = st.beta_columns(2)
        clientes1 = col1.number_input("Clientes nuevos año 1", value=1250)
        clientes2 = col2.number_input("Clientes nuevos año 2", value=6750)
        clientes3 = col1.number_input("Clientes nuevos año 3", value=17000)
        clientes4 = col2.number_input("Clientes nuevos año 4", value=17000)
        clientes5 = col1.number_input("Clientes nuevos año 5", value=8000)
        col1, col2 = st.beta_columns(2)
        cap_ahorro = col1.number_input("Capacidad de ahorro", 735000)
        de_cap = col2.number_input("Desviacion estandar C.A.", 1250)
        submit_button = st.form_submit_button(label='Actualizar')
    if submit_button:
        clientesm1 = clientes1/12
        clientesm2 = clientes2/12
        clientesm3 = clientes3/12
        clientesm4 = clientes4/12
        clientesm5 = clientes5/12
        porc_mult = 0.46
        porc_cp = 0.19
        porc_lp = 0.35
        inmob = np.zeros(60)
        a = np.zeros(60)
        b = np.zeros(60)
        c = np.zeros(60)
        cp = np.zeros(60)
        lp = np.zeros(60)
        inmob[0] = int(clientesm1 * porc_mult)
        cp[0] = int(clientesm1 * porc_cp)
        lp[0] = int(clientesm1 * porc_lp)
        for i in range(1, 60):
            if i < 12:
                inmob[i] =int( clientesm1 * porc_mult + inmob[i-1])
                cp[i] = int(clientesm1 * porc_cp + cp[i-1]) 
                lp[i] = int(clientesm1 * porc_lp + lp[i-1])
                a[i] = cp[i]
                b[i] = lp[i]
                c[i] = inmob[i]
            elif i < 24:
                inmob[i] = int(clientesm2 * porc_mult + inmob[i-1]) 
                cp[i] = int(clientesm2 * porc_cp + cp[i-1])  + clientesm1 * porc_cp*0.8
                lp[i] = int(clientesm2 * porc_lp + lp[i-1])
                a[i] = cp[i]
                b[i] = lp[i] + c[i-12]
                c[i] = inmob[i] - c[i-12]
            elif i < 36:
                inmob[i] = int(clientesm3 * porc_mult + inmob[i-1])
                cp[i] = int(clientesm3 * porc_cp + cp[i-1]) + clientesm2 * porc_cp*0.8
                lp[i] = int(clientesm3 * porc_lp + lp[i-1])
                a[i] = cp[i]
                b[i] = lp[i]  + c[i-24] + c[i-12]
                c[i] = inmob[i]  - c[i-24] - c[i-12]
            elif i < 48:
                inmob[i] = int(clientesm4 * porc_mult + inmob[i-1])
                cp[i] = int(clientesm4 * porc_cp + cp[i-1])  - clientesm3 * porc_cp*0.8
                lp[i] = int(clientesm4 * porc_lp + lp[i-1])
                a[i] = cp[i] + c[i-36]
                b[i] = lp[i]   + c[i-24] + c[i-12]
                c[i] = inmob[i] - c[i-24] - c[i-12] - c[i-36]
            elif i < 60:
                inmob[i] = int(clientesm5 * porc_mult + inmob[i-1])
                cp[i] = int(clientesm5 * porc_cp + cp[i-1]) + clientesm4 * porc_cp*0.8
                lp[i] = int(clientesm5 * porc_lp + lp[i-1])
                a[i] = cp[i] + c[i-36]
                b[i] = lp[i]  + c[i-24] + c[i-12]
                c[i] = inmob[i] - c[i-24] - c[i-12] - c[i-36] - c[i-48]
        
        inmob_res = np.zeros(60)
        cp_res = np.zeros(60)
        lp_res = np.zeros(60)
        a_res = np.zeros(60)
        b_res = np.zeros(60)
        c_res = np.zeros(60)
        for i in range(1, 60):
            if i<12:
                pass
            elif i < 24:
                cp_res[i] = - clientes1  * porc_cp*0.2
                b_res[i] = clientes1 * porc_mult
                c_res[i] = -clientes1 * porc_mult
            elif i < 36:
                cp_res[i] = - clientes2  * porc_cp * 0.2
                b_res[i] = clientes2 * porc_mult
                c_res[i] = -clientes2 * porc_mult
            elif i < 48:
                cp_res[i] = - clientes3  * porc_cp * 0.2
                a_res[i] = clientes1 * porc_mult * 3
                b_res[i] = clientes3 * porc_mult - clientes1 * 3 * porc_mult
                c_res[i] = -clientes3 * porc_mult
            elif i < 60:
                cp_res[i] = - clientes4 * porc_mult * 0.2
                a_res[i] =  clientes2 * 3 *porc_mult
                b_res[i] = clientes3 * porc_mult  - clientes2 * 3 *porc_mult
                c_res[i] = -clientes3 * porc_mult
        st.write(cp-cp_res)
        inmob[0] = int(clientesm1 * porc_mult)
        cp[0] = int(clientesm1 * porc_cp)
        lp[0] = int(clientesm1 * porc_lp)
        anual = np.zeros((5,4))
        anual_aum = np.zeros((5,4))
        for i in range(5):
            anual[i, 0] = int(sum(a[i*12:(i+1)*12]))
            anual[i, 1] = int(sum(b[i*12:(i+1)*12]))
            anual[i, 2] = int((sum(c[i*12:(i+1)*12])))
        anual[:,3] = anual[:,0] +  anual[:,1] +  anual[:,2]
        for i in range(5):
            anual_aum[i, 0] = sum(((a - a_res)*cap_ahorro)[0:(i+1)*12])
            anual_aum[i, 1] = sum(((b - b_res)*cap_ahorro)[0:(i+1)*12])
            anual_aum[i, 2] = sum(((c - c_res)*cap_ahorro)[0:(i+1)*12])
        anual_aum[:,3] = anual_aum[:,0] +  anual_aum[:,1] +  anual_aum[:,2]
        data = pd.DataFrame([cp, lp, inmob, (cp - cp_res)*cap_ahorro, lp*cap_ahorro,
                             (inmob - inmob_res)*cap_ahorro])
        
        anual[:,3] = anual[:,0] +  anual[:,1] +  anual[:,2]
        cambios = np.zeros(5)
        cambios[0] = 0
        cambios[1] = int(clientes1 * porc_mult)
        cambios[2] = int(clientes2* porc_mult)
        cambios[3] = int((clientes3 + clientes1)* porc_mult)
        cambios[4] = int((clientes2 + clientes4) * porc_mult)
        retiros = np.zeros(5)
        retiros[0] = 0
        retiros[1] = int(clientes1 * porc_cp)
        retiros[2] = int(clientes2 * porc_cp)
        retiros[3] = int(clientes3 * porc_cp)
        retiros[4] = int(clientes4 * porc_cp +clientes1 * porc_cp*porc_mult)
        clientes_a = np.zeros(5)
        clientes_b = np.zeros(5)
        clientes_c = np.zeros(5)
        clientes_a[0] = int(clientes1 * porc_cp)
        clientes_b[0] = int(clientes1 * porc_lp)
        clientes_c[0] = int(clientes1 * porc_mult)
        
        clientes_a[1] = int(clientes2 * porc_cp + clientes1 * porc_cp * 0.8)
        clientes_b[1] = int(clientes1 * porc_lp + clientes2 * porc_lp +  clientes1 * porc_mult)
        clientes_c[1] = int(clientes2 * porc_mult)
        
        clientes_a[2] = int(clientes3 * porc_cp + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8)
        clientes_b[2] = int(clientes_b[1] + clientes2 * porc_mult + clientes3 * porc_lp )
        clientes_c[2] = int(clientes3 * porc_mult)
                
        clientes_a[3] = int(clientes4 * porc_cp +  clientes1 * porc_mult + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8 + clientes3 * porc_cp * 0.8)
        clientes_b[3] = int(clientes_b[2] - clientes1 * porc_mult + clientes3 * porc_mult + clientes4 * porc_lp)
        clientes_c[3] = int(clientes4 * porc_mult)
        
        clientes_a[4] = int(clientes5 * porc_cp +  clientes1 * porc_mult +  clientes2 * porc_mult + clientes4 *0.8* porc_cp + clientes2 * porc_cp * 0.8 + clientes1 * porc_cp * 0.8 + clientes3 * porc_cp * 0.8)
        clientes_b[4] = int(clientes_b[3] - clientes2 * porc_mult + clientes4 * porc_mult + clientes5 * porc_lp )
        clientes_c[4] = int(clientes5 * porc_mult)
        
        
        
        data2 = pd.DataFrame(anual, columns = ["Depositos a", "Depositos b", "Depositos c", "Dep Total"])
        data3 = pd.DataFrame(anual_aum, columns = ["a AUM", "b AUM", "c Aum", "Aum Total"])
        data4 = pd.DataFrame([a,b,c])
        st.write(data4)
        data = data.T
        data4 = data4.T
        data4.columns = ["Fondo A", "Fondo B", "Fondo C"]
        data3["Cambios"] = cambios
        data3["Retiros"] = retiros
        data3["Clientes a"] = clientes_a
        data3["Clientes b"] = clientes_b
        data3["Clientes c"] = clientes_c
        data3["Dep totales"] = data2["Dep Total"]
        fig = px.line(data4, x=data4.index, y=data4._)
        st.plotly_chart(fig, use_container_width=True)
        st.write(data3.T)
        st.markdown(get_table_excel_link(data3.T, "Estimación demanda"),
                    unsafe_allow_html=True)

    
import matplotlib.pyplot as plt
import numpy as np
import streamlit as st
import time
import statistics
def simulacion_final():
    import altair as alt
    from altair import datum
    with st.form("Form"):
        cols = st.columns(3)
        capital_inicial = cols[0].number_input("Capital inicial", value=1000000, format="%d")
        cap_ahorro = cols[1].number_input("Capacidad de ahorro", value=750000, format='%d')
        objetivo = cols[2].number_input("Objetivo", value=40000000, format="%u")
        
        button_2 = st.form_submit_button("Comenzar simulacion")
    my_bar = st.sidebar.progress(0)
    progress = 0
    periodo = int(objetivo/cap_ahorro)+1
    periodo_cambio = int(periodo*3/5)
    periodo_cambio = int(periodo*3/5)
    periodo_cambio2 = int(periodo*4/5)
    l_1=[capital_inicial]
    l_2=[0]
    l_3 = []
    l_4 = []
    l_5 = []
    l_6 = []
    volatilidad = []
    drawdown = False
    corte_antes = False
    cambio = 0
    lista2=l_1+l_2+l_3
    chart_row = st.empty()
    if button_2:


        for j in range(1,periodo+4):
            lista =np.array(l_1+l_3+l_5)
            if lista[-1] > objetivo:
                corte_antes = True
                corte = j
                periodo = j
                break
            else:
                if j <= 12:
                    volatilidad.append(0)
                # elif j < 12 and j >3:
                    
                #     volatilidad.append(statistics.stdev((lista[1:j]/lista[0:j-1])))
                else:
                    retornos = ((lista[j-11:j]-cap_ahorro)/lista[j-12:j-1])
                    volatilidad.append(statistics.stdev(retornos))
                    if statistics.stdev(retornos) > 0.13 and j==periodo_cambio:
                        drawdown=True
                        cambio =+ 6
    
                if j < periodo_cambio:
                    sig = abs(np.random.normal(0.04,0.1))
                    a = np.random.normal(0.018,sig)
                    
                elif j < periodo_cambio2 and not drawdown:
                    sig = abs(np.random.normal(0.03,0.04))
                    a = np.random.normal(0.01,sig)
                    
                    
                elif j < periodo_cambio2 and drawdown:
                    sig = abs(np.random.normal(0.04,0.1))
                    a = np.random.normal(0.018,sig)
                    
                    drawdown=False
                else:
                    sig = abs(np.random.normal(0.005,0.01))
                    a = np.random.normal(0,sig)
                    
                    
                if j < (periodo_cambio + cambio):
                    l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
                    l_2.append(j)
    
                if j >= (periodo_cambio + cambio) and j <periodo_cambio2:
                    if (periodo_cambio + cambio) == j:
                        l_3.append(l_1[j-1])
                        l_4.append(j-1)
                    l_3.append(l_3[j- periodo_cambio- cambio]*(1+a) + cap_ahorro )
                    l_4.append(j)
    
                if j >= periodo_cambio2:
                    if periodo_cambio2 == j:
                        l_5.append(l_3[j - periodo_cambio - cambio])
                        l_6.append(j-1)
                    l_5.append(l_5[j- periodo_cambio2]*(1+a) + cap_ahorro )
                    l_6.append(j)
                    
        vol =pd.DataFrame(volatilidad)
        cols = st.columns(3)
        col1, col2 = st.columns(2)
        #st.line_chart(vol)
        mas_tmpo = False
        if lista[-1] < objetivo:
            delta = objetivo-l_5[-1]
            t_extra = int(delta/cap_ahorro)+1
            periodo_ant=periodo
            mas_tmpo=True
            periodo = periodo + t_extra
            for i in range(t_extra):
                l_5.append(l_5[-1]+ cap_ahorro)
                l_6.append(l_6[-1]+ 1)
        lista =np.array(l_1+l_3+l_5)
        col1.subheader("Analista")
        col2.subheader("Cliente")

        
        for i in range(periodo+2):
            time.sleep(0.01)
            if mas_tmpo==True and i == periodo_ant:
                st.write(t_extra)
                col2.error("Mes " + str(i) +": Te faltan " + str(t_extra) + " meses para la meta")
                time.sleep(3)
            if corte_antes==True and i == corte:
                col2.success("Mes " + str(i) +": Felcidiades llegaste antes a la meta")
                time.sleep(3)
            if cambio == 6 and i==(periodo_cambio):
                col1.error("Mes " + str(i) +": Estas en drawdown se recomienda esperar 6 meses más")
                col2.warning("Mes " + str(i) +": Debes esperar 6 mes mas para cambiarte")
                time.sleep(3)
            df = pd.DataFrame()
            df2 = pd.DataFrame()
            df3 = pd.DataFrame()
            df["Mes"]=l_2[0:i+1]
            df["Valor"]=l_1[0:i+1]
            
            if i >= (periodo_cambio+cambio):
                
                df2["Mes"]=l_4[0:i-periodo_cambio - cambio+1]
                df2["Valor"] =l_3[0:i-periodo_cambio - cambio+1]
                if i >= periodo_cambio2:
                    df3["Mes"]=l_6[0:i-periodo_cambio2+2]
                    df3["Valor"] =l_5[0:i-periodo_cambio2+2]
            df["Fondo"] = ["Fondo Arriesgado"]*len(df)
            df2["Fondo"] = ["Fondo Intermedio"]*len(df2)
            df3["Fondo"] = ["Fondo Conservador"]*len(df3)
            
            df_f = pd.concat([df,df2, df3])
            
            df_f["Ahorro"] = df_f["Mes"]*cap_ahorro + capital_inicial
            if i == (periodo_cambio+cambio):
                col2.success("Mes " + str(i) +": Debes cambiarte al Fondo Intermedio")
                time.sleep(3)
            if i == periodo_cambio2:
                col2.success("Mes " + str(i) +": Debes cambiarte al Fondo Conservador")
                time.sleep(3)
            fig = alt.Chart(df_f).mark_area(opacity=0.6).encode(
                    x=alt.X('Mes',
                            scale=alt.Scale(domain=(0, periodo - 1))
                            ),
                    y=alt.X('Valor',
                            scale=alt.Scale(domain=(0, max(lista)*1.1))
                            ),
                  color=alt.Color("Fondo", scale=alt.Scale(scheme='pastel1'))
              )
            bar = fig.mark_bar().encode(y='Ahorro')
          
          
            chart_row.altair_chart(bar + fig, use_container_width=True)
        
        my_bar.empty()
        # from st_card import st_card
        # with cols[0]:
        #     st_card('Capital proyectado', value=df_f.iloc[-1]["Valor"], show_progress=True)
        # with cols[1]:
        #     st_card('Ganancia proyectada', value = df_f.iloc[-1]["Valor"] - df_f.iloc[-1]["Ahorro"],
        #             delta=round((df_f.iloc[-1]["Valor"]/df_f.iloc[-1]["Ahorro"]-1)*100,0) ,
        #             use_percentage_delta=True, delta_description='de retorno')
        # with cols[2]:
        #     st_card('Meses', value=int(df_f.iloc[-1]["Mes"]), delta=periodo_cambio, delta_description='En el Fondo Arriesgado')
        # st.write(df_f)
import streamlit.components.v1 as components
def candidatos():
    html_str ="""
    <!DOCTYPE html>
    <html lang="es">
    <head>
    <title>D3.js - Mapas</title>
    <meta charset="utf-8"/>
    <!-- d3 😍-->
    <script src="https://d3js.org/d3.v7.min.js"></script>
    <!--nuestro estilo -->
    <link type="text/css" rel="stylesheet" href="style.css"/>
    </head>
    <body>
    <h1>
    Mapa por región de votos a Gabriel Boric
    </h1>
    <p>
    <u>Fuente: https://www.futuro.cl/2021/11/elecciones-presidenciales-chile-2021-resultados-region-por-region-en-vivo/</u>
    </p>
    <div>
    <div id="viz1", style = "width:50%">
    <svg id="geoOrthographic1"></svg>
    </div>
    <script>
    //Nos sirve para poder cargar los archivos y luego ejecutar createMap
    Promise
    .all([
    d3.json('chile.geojson'),
    d3.json('chile.geojson')
    ])
    .then(resolve => {
    createMap1(resolve[1]);
    createMap2(resolve[0]);
    });
    //creamos el mapa2
    function createMap1(countries) {
    const viz1 = d3.select("#viz1");
    const ancho = viz1.style("width").substring(0, viz1.style("width").length - 2) - 10;
    console.log("Ancho: " + ancho);
    //como proyectamos lo que vamos a dibujar
    //https://github.com/d3/d3-geo/blob/master/README.md#d3-geo
    //https://github.com/d3/d3-geo-projection#geoConicEqualArea
    const projection = d3.geoMercator()
    //que tan cercano
    .scale(550)
    // .translate([ancho / 2, 250])
    //desde el centro, lo podemos mover
    .center([-55.6, -40]);
    //definimos nuestro geoPath, lo que queremos dibujar
    const geoPath = d3.geoPath().projection(projection);
    //solo datos
    const poblacion = [
    {comuna: "Puente Alto", cantidad: 31.07},
    {comuna: "Río Ibáñez", cantidad: 25},
    {comuna: "Tocopilla", cantidad: 20.67},
    {comuna: "Juan Fernández", cantidad: 28.12},
    {comuna: "Caldera", cantidad: 19.24},
    {comuna: "Castro", cantidad: 20.43},
    {comuna: "Cañete", cantidad: 19.09},
    {comuna: "La Unión", cantidad: 23.05},
    {comuna: "Iquique", cantidad: 18.27},
    {comuna: "San Esteban", cantidad: 28.12},
    {comuna: "Putre", cantidad: 17.79},
    {comuna: "Río Hurtado", cantidad: 25.92},
    {comuna: "Torres del Paine", cantidad: 30.64},
    {comuna: "Carahue", cantidad: 16.58},
    {comuna: "Pelluhue", cantidad: 19.58},
    {comuna: "Malloa", cantidad: 24.14},
    ];
    //geoArea nos da el area dado un GeoJson
    //extent nos devuelve el minimo y maximo valor
    const realFeatureSize = d3.extent(poblacion, function (d) {
    return +d.cantidad
    });
    console.log("Mínimo y Máximo: ");
    console.log(realFeatureSize);
    //hacemos un escala para los colores
    //veamos cual es el rango
    //https://github.com/d3/d3-scale#scaleQuantize
    const newFeatureColor = d3.scaleQuantize()
    .domain(realFeatureSize)
    .range(['#fee0d2','#fc9272','#de2d26']);
    //Nada nuevo, aqui hacemos el dibujo
    d3.select("#geoOrthographic1").selectAll("path")
    .data(countries.features).enter()
    .append("path")
    .attr("d", geoPath)
    .attr("id", d => d.id)
    .attr("class", "countries")
    .style("fill", d => {
    //comentar la linea de abajo para ver que hace el resto
    //return "grey"
    console.log(d.properties.NOM_COM);
    let poblacionEncontrada;
    poblacion.forEach(function (e) {
    console.log(d.properties.NOM_COM);
    console.log(e.comuna);
    if (e.comuna === d.properties.NOM_COM) {
    poblacionEncontrada = e.cantidad;
    }
    });
    return newFeatureColor(poblacionEncontrada)
    })
    .style("stroke", d => d3.rgb(newFeatureColor(d3.geoArea(d))).darker());
    // //generamos la "grilla"
    // const graticule = d3.geoGraticule();
    //
    // //dibujamos la grilla
    // d3.select("#geoOrthographic1").insert("path", "path.countries")
    // .datum(graticule)
    // .attr("class", "graticule line")
    // .attr("d", geoPath);
    const zoom = d3.zoom()
    .scaleExtent([1, 8])
    .on('zoom', function (event) {
    d3.select("#geoOrthographic1").selectAll('path')
    .attr('transform', event.transform);
    });
    d3.select("#geoOrthographic1").call(zoom);
    }
    //creamos el mapa
    //Nos sirve para poder cargar los archivos y luego ejecutar createMap
    //creamos el mapa2
    function createMap2(countries) {
    const viz1 = d3.select("#viz2");
    const ancho = viz1.style("width").substring(0, viz1.style("width").length - 2) - 10;
    console.log("Ancho: " + ancho);
    //como proyectamos lo que vamos a dibujar
    //https://github.com/d3/d3-geo/blob/master/README.md#d3-geo
    //https://github.com/d3/d3-geo-projection#geoConicEqualArea
    const projection = d3.geoMercator()
    //que tan cercano
    .scale(550)
    // .translate([ancho / 2, 250])
    //desde el centro, lo podemos mover
    .center([-55.6, -40]);
    //definimos nuestro geoPath, lo que queremos dibujar
    const geoPath = d3.geoPath().projection(projection);
    //solo datos
    const poblacion = [
    {comuna: "Puente Alto", cantidad: 31.07},
    {comuna: "Río Ibáñez", cantidad: 25},
    {comuna: "Tocopilla", cantidad: 20.67},
    {comuna: "Juan Fernández", cantidad: 28.12},
    {comuna: "Caldera", cantidad: 19.24},
    {comuna: "Castro", cantidad: 20.43},
    {comuna: "Cañete", cantidad: 19.09},
    {comuna: "La Unión", cantidad: 23.05},
    {comuna: "Iquique", cantidad: 18.27},
    {comuna: "San Esteban", cantidad: 28.12},
    {comuna: "Putre", cantidad: 17.79},
    {comuna: "Río Hurtado", cantidad: 25.92},
    {comuna: "Torres del Paine", cantidad: 30.64},
    {comuna: "Carahue", cantidad: 16.58},
    {comuna: "Pelluhue", cantidad: 19.58},
    {comuna: "Malloa", cantidad: 24.14},
    ];
    //geoArea nos da el area dado un GeoJson
    //extent nos devuelve el minimo y maximo valor
    const realFeatureSize = d3.extent(poblacion, function (d) {
    return +d.cantidad
    });
    console.log("Mínimo y Máximo: ");
    console.log(realFeatureSize);
    //hacemos un escala para los colores
    //veamos cual es el rango
    //https://github.com/d3/d3-scale#scaleQuantize
    const newFeatureColor = d3.scaleQuantize()
    .domain(realFeatureSize)
    .range(['#fee0d2','#fc9272','#de2d26']);
    //Nada nuevo, aqui hacemos el dibujo
    d3.select("#geoOrthographic2").selectAll("path")
    .data(countries.features).enter()
    .append("path")
    .attr("d", geoPath)
    .attr("id", d => d.id)
    .attr("class", "countries")
    .style("fill", d => {
    //comentar la linea de abajo para ver que hace el resto
    //return "grey"
    console.log(d.properties.NOM_COM);
    let poblacionEncontrada;
    poblacion.forEach(function (e) {
    console.log(d.properties.NOM_COM);
    console.log(e.comuna);
    if (e.comuna === d.properties.NOM_COM) {
    poblacionEncontrada = e.cantidad;
    }
    });
    return newFeatureColor(poblacionEncontrada)
    })
    .style("stroke", d => d3.rgb(newFeatureColor(d3.geoArea(d))).darker());
    // //generamos la "grilla"
    // const graticule = d3.geoGraticule();
    //
    // //dibujamos la grilla
    // d3.select("#geoOrthographic1").insert("path", "path.countries")
    // .datum(graticule)
    // .attr("class", "graticule line")
    // .attr("d", geoPath);
    const zoom = d3.zoom()
    .scaleExtent([1, 8])
    .on('zoom', function (event) {
    d3.select("#geoOrthographic2").selectAll('path')
    .attr('transform', event.transform);
    });
    d3.select("#geoOrthographic2").call(zoom);
    }
    //creamos el mapa1
    </script>
    </div>
    </body>
    </html>
    """
    components.html(html_str, height=1000)
# def simulacion_final():
#     import altair as alt
#     from altair import datum
#     with st.form("Form"):
#         cols = st.beta_columns(3)
#         capital_inicial = cols[0].number_input("Objetivo", value=1000000, format="%d")
#         cap_ahorro = cols[1].number_input("Capacidad de ahorro", value=750000, format='%d')
#         objetivo = cols[2].number_input("Objetivo", value=40000000, format="%u")
        
#         button_2 = st.form_submit_button("Comenzar simulacion")
#     l_1=[capital_inicial]
#     l_2=[0]
#     l_3=[np.nan]
#     l_4=[np.nan]
#     text=[]



#     chart_row = st.empty()
#     if button_2:
#         my_bar = st.sidebar.progress(0)
#         progress = 0
#         periodo = int(objetivo/cap_ahorro)+1
#         periodo_cambio = int(periodo*3/5)
#         periodo_cambio2 = int(periodo*4/5)

#         for j in range(1,periodo):

#             a = np.random.normal(0.03,0.10)
#             if j <periodo_cambio:
#                 l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
#                 l_3.append(np.nan)
#                 l_4.append(np.nan)
#                 text.append("")
#             elif j ==periodo_cambio:
#                 l_1.append(l_1[j-1]*(1+a) + cap_ahorro )
#                 l_3.append(l_1[j-1]*(1+a) + cap_ahorro )
#                 l_4.append(np.nan)
#                 text.append("")
#             elif j > periodo_cambio and j < periodo_cambio2 :
#                 a = a/3
#                 l_1.append(np.nan)
#                 l_3.append(l_3[j-1]*(1+a) + cap_ahorro)
#                 l_4.append(np.nan)
#                 text.append("")
#             elif j == periodo_cambio2:
#                 a = a/3
#                 l_1.append(np.nan)
#                 l_3.append(l_3[j-1]*(1+a) + cap_ahorro)
#                 l_4.append(l_3[j-1]*(1+a) + cap_ahorro)
#                 text.append("")
#             else:
#                 a = a/5
#                 l_1.append(np.nan)
#                 l_3.append(np.nan)
#                 l_4.append(l_4[j-1]*(1+a) + cap_ahorro)
#                 text.append("")
#             l_2.append(j)
#         drawd =[]
#         for k in range(2,len(l_1)):
            
#             if (l_1[k] - l_1[k-1])/(l_1[k]) < -0.01:
#                 periodo_cambio1_2 = periodo_cambio + 1
#                 drawd.append(k)
#             else:
#                 periodo_cambio1_2=periodo_cambio
        
#         for i in range(periodo):
#             progress = (i/periodo)
#             my_bar = my_bar.progress(progress)
#             time.sleep(0.001)
#             df = pd.DataFrame()
#             df["Mes"]=l_2[0:i+1]+l_2[0:i+1] +  l_2[0:i+1]
#             df["Valor"]=l_1[0:i+1]+l_3[0:i+1] + l_4[0:i+1]
#             if i <= periodo_cambio:
#                 df["Fondo"]=["Fondo Arriesgado"]*len(df)
#                 if i in drawd:
#                         st.warning("Drawdown")
#                         time.sleep(2)
#             elif i > periodo_cambio and  i <= periodo_cambio2:
#                 df["Fondo"]=["Fondo Arriesgado"]*(periodo_cambio+1) + ["Fondo Intermedio"]*(i-periodo_cambio) + ["Fondo Arriesgado"]*(periodo_cambio + 1) + ["Fondo Intermedio"]*(i-periodo_cambio) + ["Fondo Arriesgado"]*(periodo_cambio+1)  + ["Fondo Intermedio"]*(i-periodo_cambio)
#             else:
#                 a = ["Fondo Arriesgado"] * periodo_cambio
#                 b = ["Fondo Intermedio"] * (periodo_cambio2 - periodo_cambio-1)
#                 c = ["Fondo Conservador"] * (i-periodo_cambio2)
#                 d = ["Fondo Arriesgado"] * (periodo_cambio+2)
#                 e = ["Fondo Intermedio"] * (periodo_cambio2 - (periodo_cambio+2))
#                 f = ["Fondo Conservador"]*(i-periodo_cambio2+2)
#                 df["Fondo"]= a +  b + c + d + e + f + d + e + f
#             df = df.dropna()
            
                
                
                
#             if i == periodo_cambio:
#                 placeholder=st.empty()
#                 placeholder.info("Debes cambiarte al fondo intermedio")
#                 time.sleep(3)
#                 placeholder.empty()
#             if i == periodo_cambio2:
#                 placeholder=st.empty()
#                 placeholder.info("Debes cambiarte al fondo conservador")
#                 time.sleep(3)
#                 placeholder.empty()
#             # df=df.dropna()
            
#             fig = alt.Chart(df).mark_area(opacity=0.6).encode(
#                     x=alt.X('Mes',
#                             scale=alt.Scale(domain=(0, periodo - 1))
#                             ),
#                     y=alt.X('Valor',
#                             scale=alt.Scale(domain=(0, max(l_1+l_3+l_4)*1.1))
#                             ),
#                   color=alt.Color("Fondo", scale=alt.Scale(scheme='category20'))
#               )
#             if i > periodo_cambio and i <= periodo_cambio2:
#                 df["Cambio"]="Cambiate al fondo intermedio"
#                 text = (
#                     alt.Chart(df[df["Mes"]==periodo_cambio])
#                     .mark_text(dy=-25, color="black")
#                     .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
#                 )
            
#                 chart_row.altair_chart(fig + text, use_container_width=True)
#             if i > periodo_cambio2:
#                 df["Cambio"]="Cambiate al fondo conservador"
#                 text = (
#                     alt.Chart(df[df["Mes"]==periodo_cambio2])
#                     .mark_text(dy=-25, color="black")
#                     .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
#                 )
#                 chart_row.altair_chart(fig, use_container_width=True)
#             else:
#                 chart_row.altair_chart(fig, use_container_width=True)
#         cols = st.columns(3)
#         ganancia=value=l_3[-1] - cap_ahorro * l_2[-1]
#         my_bar.empty()
#         # with cols[0]:
#         #     st_card('Capital proyectado', value=l_3[-1], show_progress=True)
#         # with cols[1]:
#         #     st_card('Ganancia proyectada', value=ganancia, delta=round(ganancia/(cap_ahorro * l_2[-1])*100,0) ,
#         #             use_percentage_delta=True, delta_description='de retorno')
#         # with cols[2]:
#         #     st_card('Meses', value=l_2[-1], delta=periodo_cambio, delta_description='En el Fondo Arriesgado')
#         st.write(df)
def prototipo_simulacion():
    # import streamlit as st
    # import time
    # import numpy as np
    # progress_bar = st.sidebar.progress(0)
    # status_text = st.sidebar.empty()
    # last_rows = np.random.randn(1, 1)
    # chart = st.line_chart(last_rows)
    # for i in range(1, 101):
    #     new_rows = last_rows[-1, :] + np.random.randn(50, 1).cumsum(axis=0)
    #     status_text.text("%i%% Complete" % i)
    #     chart.add_rows(new_rows)
    #     progress_bar.progress(i)
    #     last_rows = new_rows
    #     time.sleep(0.001)
        
    # progress_bar.empty()
    # # Streamlit widgets automatically run the script from top to bottom. Since
    # # this button is not connected to any other logic, it just causes a plain
    # # rerun.
    # st.button("Re-run")
    # import numpy as np
    # import matplotlib.pyplot as plt
    # import matplotlib.animation as animation
    # import streamlit as st
    # import streamlit.components.v1 as components
    
    # def update_line(num, data, line):
    #     line.set_data(data[..., :num])
    #     return line,
    
    # fig = plt.figure()
    
    # # Fixing random state for reproducibility
    # np.random.seed(19680801)
    
    # data = np.random.rand(2, 25)
    # l, = plt.plot([], [], 'r-')
    # plt.xlim(0, 1)
    # plt.ylim(0, 1)
    # plt.xlabel('x')
    # plt.title('test')
    # line_ani = animation.FuncAnimation(fig, update_line, 25, fargs=(data, l), interval=50, blit=True)
    
    # st.title("Embed Matplotlib animation in Streamlit")
    # st.markdown("https://matplotlib.org/gallery/animation/basic_example.html")
    # components.html(line_ani.to_jshtml(), height=1000)
    # import matplotlib.pyplot as plt
    # import numpy as np
    # import streamlit as st
    # import time
    
    # fig, ax = plt.subplots()
    
    # max_x = 5
    # max_rand = 10
    
    # x = np.arange(0, max_x)
    # ax.set_ylim(0, max_rand)
    # line, = ax.plot(x, np.random.randint(0, max_rand, max_x))
    # the_plot = st.pyplot(plt)
    
    # def init():  # give a clean slate to start
    #     line.set_ydata([np.nan] * len(x))
    
    # def animate(i):  # update the y values (every 1000ms)
    #     line.set_ydata(np.random.randint(0, max_rand, max_x))
    #     the_plot.pyplot(plt)
    
    # init()
    # for i in range(100):
    #     animate(i)
    #     time.sleep(0.1)
    import plotly.express as px
    from datetime import date
    from datetime import timedelta
    import numpy as np
    df = px.data.gapminder()
    cap_ahorro = 750000
    Data = pd.DataFrame()
    today =date.today()
    l=[]
    l2=[]
    l3=[]
    l4=[]
    for i in range(53):
        
        for j in range(53):
            l.append(i)
            l2.append(j)
            if j<=i:
                l3.append(cap_ahorro*j)
            else:
                l3.append(0)
            if j<40:
                l4.append("Arriesgado")
            elif j<47:
                l4.append("Intermedio")
            else:
                l4.append("Conservador")
    l5 = []     
    l6 = []
    Data["Mes"] = l
    Data["Ahorro"] = l2      
    Data["Total"] = l3   
    Data["Fondo"] = l4
    fig = px.bar(Data, x="Ahorro", y="Total", color="Fondo",
      animation_frame="Mes")
    fig.update_yaxes(range=[0, 50000000])
    fig.update_xaxes(range=[0, 53])
    st.plotly_chart(fig)
    button = st.button("Activar")
    if button:
        chart_data = pd.DataFrame()
        chart = st.area_chart(chart_data)
        for i in range(100):
            if i<70:
                chart.add_rows(pd.DataFrame([[i*cap_ahorro,0, 0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
            elif i==70:
                chart.add_rows(pd.DataFrame([[i*cap_ahorro,i*cap_ahorro,0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
                st.success("Debes cambiarte al fondo intermedio")
            elif i<85:
                chart.add_rows(pd.DataFrame([[0,i*cap_ahorro,0]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
            elif i==85:
                chart.add_rows(pd.DataFrame([[0,i*cap_ahorro,i*cap_ahorro]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
                st.success("Debes cambiarte al fondo arriesgado")
            else:
                chart.add_rows(pd.DataFrame([[0,0, i*cap_ahorro]], columns=['Fondo 1', 'Fondo 2', 'Fondo 3']))
            time.sleep(0.1)

    cap_ahorro = 750000
    from plotly.subplots import make_subplots
    import plotly.graph_objects as go
    import numpy as np
    import plotly.graph_objects as go
    Frames=[]
    Frames2 =[]
    
    l_1=[]
    l_2=[]
    l_3=[]
    text=[]
    fig = make_subplots(rows=1, cols=1, subplot_titles = ('Subplot (1,1)'))
    for i in range(53):
        if i <40:
            l_1.append(cap_ahorro*i)
            l_3.append(np.nan)
            text.append("")
        elif i ==40:
            l_1.append(cap_ahorro*i)
            l_3.append(cap_ahorro*i)
            text.append("")
        else:
            l_1.append(np.nan)
            l_3.append(cap_ahorro*i)
            text.append("")
        l_2.append(i)

        Frames.append(go.Scatter(x=l_2, y=l_1,
                                 mode="lines+text",
                                 text=text,
                                 textposition="bottom center",
                                 textsrc="bottom center",
            textfont=dict(
                family="sans serif",
                size=10,
                color="Black"
            ), fill='tozeroy'))
        Frames2.append(go.Scatter(x=l_2, y=l_3, fill='tozeroy'))
        go.Annotations
    Frames_finales=[Frames, Frames2]
    fig.add_trace(go.Scatter(
          x= [0],
          y= [0],
          mode = 'lines',
          hoverinfo='name',
          legendgroup= 'Fondo Arriesgado',
          line_color= 'rgb(255, 79, 38)',
          name= 'Fondo Arriesgado',
          showlegend= True), row=1, col=1)  
    fig.add_trace(go.Scatter(
          x= [0],
          y= [0],
          mode = 'lines',
          hoverinfo='name',
          legendgroup= 'Fondo Conservador',
          line_color= 'rgb(79, 38, 255)',
          name= 'Fondo Conservador',
          showlegend= True), row=1, col=1)
    frames =[dict(name = k,
                  data = [Frames[k],Frames2[k]],
                  traces=[0,1]) for k in range(53)
                      ]   
    updatemenus=[dict(
                type="buttons",
                buttons=[dict(label="Play",
                              method="animate",
                              args=[None])])]
    fig.update_yaxes(range=[0, 50000000])
    fig.update_xaxes(range=[0, 53])
    annotations1 = [dict(
            x=40,
            y=40*cap_ahorro,
            text=text,
            xanchor='auto',
            yanchor='bottom',
            showarrow=False,
        )]

    fig.update(frames=frames),
    fig.update_layout(updatemenus=updatemenus)
    
    st.plotly_chart(fig)
    import altair as alt
    from altair import datum
    l_1=[]
    l_2=[]
    l_3=[]
    for i in range(51):
        if i <41:
            l_1.append(cap_ahorro*i)
            l_3.append(np.nan)
            text.append("")
        elif i ==41:
            l_1.append(cap_ahorro*i)
            l_3.append(cap_ahorro*i)
            text.append("")
        else:
            l_1.append(np.nan)
            l_3.append(cap_ahorro*i)
            text.append("")
        l_2.append(i)
    chart_row = st.empty()
    button_2 = st.button("Comenzar simulació")
    if button_2:
        for i in range(51):
            time.sleep(0.1)
            df = pd.DataFrame()
            
            df["Mes"]=l_2[0:i+1]+l_2[0:i+1]
            print(df["Mes"])
            df["Valor"]=l_1[0:i+1]+l_3[0:i+1]
            if i <= 41:
                df["Fondo"]=["Fondo Arriesgado"]*len(df)
            else:
                df["Fondo"]=["Fondo Arriesgado"]*41 + ["Fondo Conservador"]*(i-41) + ["Fondo Arriesgado"]*43 + ["Fondo Conservador"]*(i-41)
            if i == 41:
                st.success("Debes cambiarte al fondo conservador")
                time.sleep(1)
            df=df.dropna()
            fig = alt.Chart(df).mark_area(opacity=0.6).encode(
                    x=alt.X('Mes',
                            scale=alt.Scale(domain=(0, 50))
                            ),
                    y=alt.X('Valor',
                            scale=alt.Scale(domain=(0, max(l_1+l_3)*1.1))
                            ),
                  color=alt.Color("Fondo", scale=alt.Scale(scheme='category20'))
              )
            if i > 41:
                df["Cambio"]="Cambiate al fondo conservador"
                text = (
                    alt.Chart(df[df["Mes"]==41])
                    .mark_text(dy=-25, color="black")
                    .encode(x=alt.X("Mes"), y=alt.Y("Valor"), text="Cambio")
                )

                chart_row.altair_chart(fig + text, use_container_width=True)
            else:
                chart_row.altair_chart(fig, use_container_width=True)