import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots

# Leer el archivo CSV
df = pd.read_csv('/home/seba/projects/VPS_Streaming_CS/optionChain_2024-06-12.csv')

df['timestamp'] = pd.to_datetime(df['timestamp'], format='%m/%d/%Y %H:%M:%S')

# Definir los conjuntos de strikes
strikes_list = [
    [5470.0, 5475.0, 5370.0, 5365.0],
    [5485.0, 5490.0, 5345.0, 5340.0],
    # # [5340.0, 5380.0, 5300.0],
]

start_time = '06/12/2024 10:30:00'
start_time = pd.to_datetime(start_time)

# Filtrar los datos a partir del horario de comienzo
df = df[df['timestamp'] >= start_time]

# Comprobar si después del filtrado hay datos
if df.empty:
    print("No hay datos disponibles después del filtrado por start_time.")
else:
    print(f"{len(df)} registros después del filtrado por start_time.")

# Crear un DataFrame para almacenar los resultados de todas las configuraciones
result_df = pd.DataFrame()

for strikes in strikes_list:
    # Filtrar las filas por los strikes dados
    filtered_df = df[df['strike'].isin(strikes)]

    # Filtrar los datos por cada strike
    sell_call_df = filtered_df[filtered_df['strike'] == strikes[0]].copy()
    buy_call_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()
    sell_put_df = filtered_df[filtered_df['strike'] == strikes[2]].copy()
    buy_put_df = filtered_df[filtered_df['strike'] == strikes[3]].copy()

    # Calcular el valor medio entre bid_call y ask_call para cada DataFrame
    sell_call_df.loc[:, 'mean_sell_call'] = 100 * (sell_call_df['bid_call'] + sell_call_df['ask_call']) / 2
    sell_put_df.loc[:, 'mean_sell_put'] = 100 * (sell_put_df['bid_put'] + sell_put_df['ask_put']) / 2
    buy_call_df.loc[:, 'mean_buy_call'] = 100 * (buy_call_df['bid_call'] + buy_call_df['ask_call']) / 2
    buy_put_df.loc[:, 'mean_buy_put'] = 100 * (buy_put_df['bid_put'] + buy_put_df['ask_put']) / 2

    # Crear un DataFrame vacío para almacenar los valores de Iron Butterfly
    iron_butterfly_values = pd.DataFrame()

    # Combinar los DataFrames en uno solo usando el timestamp como índice
    iron_butterfly_values['timestamp'] = sell_call_df['timestamp']
    iron_butterfly_values['mean_sell_call'] = sell_call_df['mean_sell_call'].values
    iron_butterfly_values['mean_sell_put'] = sell_put_df['mean_sell_put'].values
    iron_butterfly_values['mean_buy_call'] = buy_call_df['mean_buy_call'].values
    iron_butterfly_values['mean_buy_put'] = buy_put_df['mean_buy_put'].values

    # Calcular el valor de Iron Butterfly
    iron_butterfly_values['iron_butterfly_value'] = (
        iron_butterfly_values['mean_sell_call'] +
        iron_butterfly_values['mean_sell_put'] -
        iron_butterfly_values['mean_buy_call'] -
        iron_butterfly_values['mean_buy_put']
    )

    # Obtener el crédito inicial (valor del primer timestamp)
    credito_inicial = iron_butterfly_values['iron_butterfly_value'].iloc[0]

    # Calcular las diferencias con respecto al crédito inicial
    iron_butterfly_values['diferencia'] = credito_inicial - iron_butterfly_values['iron_butterfly_value']

    # Agregar una columna para identificar el conjunto de strikes
    iron_butterfly_values['strikes'] = f'{strikes[0]}-{strikes[1]}-{strikes[2]}'

    # Concatenar los resultados en el DataFrame de resultados
    result_df = pd.concat([result_df, iron_butterfly_values], ignore_index=True)

# Verificar que result_df no esté vacío y que contenga la columna 'timestamp'
if not result_df.empty and 'timestamp' in result_df.columns:
    # Crear el gráfico de líneas con dos ejes Y
    fig = make_subplots(specs=[[{"secondary_y": True}]])

    # Agregar las líneas de diferencias del valor de Iron Butterfly
    for strikes in result_df['strikes'].unique():
        df_strikes = result_df[result_df['strikes'] == strikes]
        fig.add_trace(
            go.Scatter(x=df_strikes['timestamp'], y=df_strikes['diferencia'], mode='lines', name=f'Diferencia {strikes}'),
            secondary_y=False
        )

    # Agregar la línea para 'underlying_price' en color negro continuo y ancho de 3
    fig.add_trace(
        go.Scatter(
            x=df['timestamp'],
            y=df['underlying_price'],
            mode='lines',
            name='Underlying Price',
            line=dict(color='black', width=1)
        ),
        secondary_y=True
    )

    # Actualizar los títulos de los ejes
    fig.update_xaxes(title_text='Timestamp')
    fig.update_yaxes(title_text='Diferencia del Valor de Iron Butterfly', secondary_y=False)
    fig.update_yaxes(title_text='Underlying Price', secondary_y=True)

    # Actualizar el título del gráfico
    fig.update_layout(title_text='Diferencias del Valor de Iron Butterfly y Underlying Price')

    # Mostrar el gráfico
    fig.show()
else:
    print("No hay datos disponibles para mostrar el gráfico.")