from flask import Flask, render_template, request, jsonify
import pandas as pd
import datetime

import os
import time
import pprint

import re
app = Flask(__name__)

PATH_UBUNTU = "/var/www/html/flask_project/chains/"

# Ruta para obtener los datos


@app.route('/data', methods=['POST'])
def data():
    data = request.get_json()
    primeraVez = data.get('primeraVez', False)

    print(data)
    butterfly_strike1 = data.get('butterfly_strike1') + ".0"
    butterfly_strike1 = float(butterfly_strike1)
    butterfly_strike1 = round(butterfly_strike1, 1)
    butterfly_strike2 = data.get('butterfly_strike2') + ".0"
    butterfly_strike2 = float(butterfly_strike2)
    butterfly_strike2 = round(butterfly_strike2, 1)
    butterfly_strike3 = data.get('butterfly_strike3') + ".0"
    butterfly_strike3 = float(butterfly_strike3)
    butterfly_strike3 = round(butterfly_strike3, 1)
    butterfly_option_type = data.get('butterfly_option_type')

    ironCondor_strike1 = data.get('ironCondor_strike1') + ".0"
    ironCondor_strike1 = float(ironCondor_strike1)
    ironCondor_strike1 = round(ironCondor_strike1, 1)
    ironCondor_strike2 = data.get('ironCondor_strike2') + ".0"
    ironCondor_strike2 = float(ironCondor_strike2)
    ironCondor_strike2 = round(ironCondor_strike2, 1)
    ironCondor_strike3 = data.get('ironCondor_strike3') + ".0"
    ironCondor_strike3 = float(ironCondor_strike3)
    ironCondor_strike3 = round(ironCondor_strike3, 1)
    ironCondor_strike4 = data.get('ironCondor_strike4') + ".0"
    ironCondor_strike4 = float(ironCondor_strike4)
    ironCondor_strike4 = round(ironCondor_strike4, 1)

    sonar_strike1 = data.get('sonar_strike1') + ".0"
    sonar_strike1 = float(sonar_strike1)
    sonar_strike1 = round(sonar_strike1, 1)
    sonar_strike2 = data.get('sonar_strike2') + ".0"
    sonar_strike2 = float(sonar_strike2)
    sonar_strike2 = round(sonar_strike2, 1)
    sonar_strike3 = data.get('sonar_strike3') + ".0"
    sonar_strike3 = float(sonar_strike3)
    sonar_strike3 = round(sonar_strike3, 1)
    sonar_strike4 = data.get('sonar_strike4') + ".0"
    sonar_strike4 = float(sonar_strike4)
    sonar_strike4 = round(sonar_strike4, 1)

    vertical_strike1 = data.get('vertical_strike1') + ".0"
    vertical_strike1 = float(vertical_strike1)
    vertical_strike1 = round(vertical_strike1, 1)
    vertical_strike2 = data.get('vertical_strike2') + ".0"
    vertical_strike2 = float(vertical_strike2)
    vertical_strike2 = round(vertical_strike2, 1)
    vertical_option_type = data.get('vertical_option_type')

    # makeka
    makeka_option_type = data.get('vertical_option_type')
    if (makeka_option_type == 'CALL'):
        makeka_option_type = 'PUT'
        makeka_strike1 = data.get('vertical_strike1') + ".0"
        makeka_strike1 = float(makeka_strike1)
        makeka_strike1 = round(makeka_strike1, 1) - 10

        makeka_strike2 = data.get('vertical_strike1') + ".0"
        makeka_strike2 = float(makeka_strike2)
        makeka_strike2 = round(makeka_strike2, 1) - 5

        makeka_strike3 = data.get('vertical_strike2') + ".0"
        makeka_strike3 = float(makeka_strike3)
        makeka_strike3 = round(makeka_strike3, 1)

    else:
        makeka_option_type = 'CALL'
        makeka_strike1 = data.get('vertical_strike1') + ".0"
        makeka_strike1 = float(makeka_strike1)
        makeka_strike1 = round(makeka_strike1, 1) + 10

        makeka_strike2 = data.get('vertical_strike1') + ".0"
        makeka_strike2 = float(makeka_strike2)
        makeka_strike2 = round(makeka_strike2, 1) + 5

        makeka_strike3 = data.get('vertical_strike2') + ".0"
        makeka_strike3 = float(makeka_strike3)
        makeka_strike3 = round(makeka_strike3, 1)

    date_time = data.get('date_time')
    symbol = data.get('symbol')

    butterfly_initialValue = float(data.get('butterfly_initialValue', 0))
    iron_condor_initialValue = float(data.get('iron_condor_initialValue', 0))
    sonar_initialValue = float(data.get('sonar_initialValue', 0))
    vertical_initialValue = float(data.get('vertical_initialValue', 0))
    makeka_initialValue = float(data.get('makeka_initialValue', 0))

    # Parsear la cadena a un objeto datetime
    date_obj = datetime.datetime.strptime(date_time, '%m-%d-%Y %H:%M:%S')
    formatted_date = date_obj.strftime('%Y-%m-%d')

    filename = PATH_UBUNTU + "optionChain_" + symbol + "_" + str(formatted_date) + ".csv"

    if symbol == 'SPX':
        # filename = PATH_UBUNTU + "optionChain_" + str(formatted_date) + ".csv"
        filename = PATH_UBUNTU + "optionChain_$" + symbol + "_" + str(formatted_date) + ".csv"

    if symbol == 'RUT' or symbol == 'XSP':
        filename = PATH_UBUNTU + "optionChain_$" + symbol + "_" + str(formatted_date) + ".csv"

    if not os.path.exists(filename):
        return jsonify({"error": "Archivo no encontrado"}), 404

    # Filtrar datos a partir de un horario de comienzo especificado
    df = pd.read_csv(filename, parse_dates=['timestamp'])
    start_time = date_time
    start_time = pd.to_datetime(start_time)
    df = df[df['timestamp'] >= start_time]

    butterfly_strikes = [
        [butterfly_strike1, butterfly_strike2, butterfly_strike3, butterfly_option_type, 'BUTTERFLY'],
    ]

    iron_condor_strikes = [
        [ironCondor_strike1, ironCondor_strike2, ironCondor_strike3, ironCondor_strike4, 'IRON CONDOR'],
    ]

    sonar_strikes = [
        [sonar_strike1, sonar_strike2, sonar_strike3, sonar_strike4, 'SONAR'],
    ]

    vertical_strikes = [
        [vertical_strike1, vertical_strike2, vertical_option_type, 'VERTICAL']
    ]

    makeka_strikes = [
        [makeka_strike1, makeka_strike2, makeka_strike3, makeka_option_type, 'LONG BUTTERFLY'],
    ]

    butterfly_data = []
    ironCondor_data = []
    sonar_data = []
    vertical_data = []
    makeka_data = []

    try:
        for strikes in butterfly_strikes:
            butterfly_data.append(calcular_butterfly(strikes, strikes[4], df, butterfly_initialValue, primeraVez))
    except Exception as e:
        print(f"Error en la estrategia Butterfly: {e}")

    try:
        for strikes in iron_condor_strikes:
            ironCondor_data.append(calcular_iron_condor(strikes, strikes[4], df, iron_condor_initialValue, primeraVez))
    except Exception as e:
        print(f"Error en la estrategia Iron Condor: {e}")

    try:
        for strikes in sonar_strikes:
            sonar_data.append(calcular_sonar(strikes, strikes[4], df, sonar_initialValue, primeraVez))
    except Exception as e:
        print(f"Error en la estrategia Sonar: {e}")

    try:
        for strikes in vertical_strikes:
            vertical_data.append(calcular_vertical(strikes, strikes[3], df, vertical_initialValue, primeraVez))
    except Exception as e:
        print(f"Error en la estrategia Vertical: {e}")

    try:
        for strikes in makeka_strikes:
            makeka_data.append(calcular_makeka(strikes, strikes[4], df, makeka_initialValue, primeraVez))
    except Exception as e:
        print(f"Error en la estrategia Makeka: {e}")

    print(makeka_initialValue)

    # Convertir los DataFrames a diccionarios (sólo si existen datos)
    butterfly_data = pd.concat(butterfly_data).to_dict(orient='records') if butterfly_data else []
    ironCondor_data = pd.concat(ironCondor_data).to_dict(orient='records') if ironCondor_data else []
    sonar_data = pd.concat(sonar_data).to_dict(orient='records') if sonar_data else []
    vertical_data = pd.concat(vertical_data).to_dict(orient='records') if vertical_data else []
    makeka_data = pd.concat(makeka_data).to_dict(orient='records') if makeka_data else []

    # Obtener datos del precio subyacente
    underlying_price_data = df[['timestamp', 'underlying_price']].drop_duplicates()

    # Convertir el timestamp a formato hh:mm:ss
    underlying_price_data['timestamp'] = underlying_price_data['timestamp'].dt.strftime('%H:%M:%S')
    underlying_price_data = underlying_price_data.to_dict(orient='records')

    # Formatear el timestamp como hh:mm:ss en butterfly_data y vertical_data
    for item in butterfly_data:
        item['timestamp'] = item['timestamp'].strftime("%H:%M:%S")

    for item in ironCondor_data:
        item['timestamp'] = item['timestamp'].strftime("%H:%M:%S")

    for item in sonar_data:
        item['timestamp'] = item['timestamp'].strftime("%H:%M:%S")

    for item in vertical_data:
        item['timestamp'] = item['timestamp'].strftime("%H:%M:%S")

    for item in makeka_data:
        item['timestamp'] = item['timestamp'].strftime("%H:%M:%S")

    return jsonify({
        'butterfly': butterfly_data,
        'iron_condor': ironCondor_data,
        'sonar': sonar_data,
        'vertical': vertical_data,
        'makeka': makeka_data,
        'underlying_price': underlying_price_data
    })


# Función para calcular valores de Iron Butterfly
def calcular_butterfly(strikes, label, df, butterfly_initialValue, primeraVez):
    # strikes= [5495.0, 5470.0, 5445.0, 'CALL', 'BUTTERFLY']
    option_type = strikes[3]
    filtered_df = df[df['strike'].isin(strikes[:3])]

    if option_type == 'CALL':
        buy_df1 = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        sell_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()
        buy_df2 = filtered_df[filtered_df['strike'] == strikes[2]].copy()

        buy_df1.loc[:, 'mean_buy1'] = 100 * (buy_df1['bid_call'] + buy_df1['ask_call']) / 2
        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_call'] + sell_df['ask_call']) / 2
        buy_df2.loc[:, 'mean_buy2'] = 100 * (buy_df2['bid_call'] + buy_df2['ask_call']) / 2

    elif option_type == 'PUT':

        buy_df1 = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        sell_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()
        buy_df2 = filtered_df[filtered_df['strike'] == strikes[2]].copy()

        buy_df1.loc[:, 'mean_buy1'] = 100 * (buy_df1['bid_put'] + buy_df1['ask_put']) / 2
        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_put'] + sell_df['ask_put']) / 2
        buy_df2.loc[:, 'mean_buy2'] = 100 * (buy_df2['bid_put'] + buy_df2['ask_put']) / 2

    butterfly_values = pd.DataFrame()

    butterfly_values['timestamp'] = sell_df['timestamp']
    butterfly_values['mean_sell'] = sell_df['mean_sell'].values
    butterfly_values['mean_buy1'] = buy_df1['mean_buy1'].values
    butterfly_values['mean_buy2'] = buy_df2['mean_buy2'].values

    butterfly_values['butterfly_value'] = (
        butterfly_values['mean_sell'] * 2 -
        butterfly_values['mean_buy1'] -
        butterfly_values['mean_buy2']
    )

    if primeraVez == True:
        credito_inicial = butterfly_values['butterfly_value'].iloc[0]
    else:
        credito_inicial = butterfly_initialValue
        butterfly_values['butterfly_value'].iloc[0] = credito_inicial  # Sobrescribir el primer valor

    butterfly_values['diferencia'] = credito_inicial - butterfly_values['butterfly_value']
    butterfly_values['label'] = f'{label} [{strikes[0]}, {strikes[1]}, {strikes[2]}] {strikes[3]}'

    return butterfly_values

# Función para calcular valores de Iron Condors


def calcular_iron_condor(strikes, label, df, iron_condor_initialValue, primeraVez):
    filtered_df = df[df['strike'].isin(strikes[:4])]

    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()

    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

    iron_condor_values = pd.DataFrame()

    iron_condor_values['timestamp'] = sell_call_df['timestamp']
    iron_condor_values['mean_sell_call'] = sell_call_df['mean_sell_call'].values
    iron_condor_values['mean_sell_put'] = sell_put_df['mean_sell_put'].values
    iron_condor_values['mean_buy_call'] = buy_call_df['mean_buy_call'].values
    iron_condor_values['mean_buy_put'] = buy_put_df['mean_buy_put'].values

    iron_condor_values['iron_condor_value'] = (
        iron_condor_values['mean_sell_call'] +
        iron_condor_values['mean_sell_put'] -
        iron_condor_values['mean_buy_call'] -
        iron_condor_values['mean_buy_put']
    )

    if primeraVez == True:
        credito_inicial = iron_condor_values['iron_condor_value'].iloc[0]
    else:
        credito_inicial = iron_condor_initialValue
        iron_condor_values['iron_condor_value'].iloc[0] = credito_inicial  # Sobrescribir el primer valor

    iron_condor_values['diferencia'] = credito_inicial - iron_condor_values['iron_condor_value']
    iron_condor_values['label'] = f'{label} [{strikes[0]}, {strikes[1]}] [{strikes[2]}, {strikes[3]}]'

    return iron_condor_values


# Función para calcular valores de Sonars
def calcular_sonar(strikes, label, df, sonar_initialValue, primeraVez):
    filtered_df = df[df['strike'].isin(strikes[:4])]

    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()

    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

    sonar_values = pd.DataFrame()

    sonar_values['timestamp'] = sell_call_df['timestamp']
    sonar_values['mean_sell_call'] = sell_call_df['mean_sell_call'].values
    sonar_values['mean_sell_put'] = sell_put_df['mean_sell_put'].values
    sonar_values['mean_buy_call'] = buy_call_df['mean_buy_call'].values
    sonar_values['mean_buy_put'] = buy_put_df['mean_buy_put'].values

    sonar_values['sonar_value'] = (
        sonar_values['mean_sell_call'] +
        sonar_values['mean_sell_put'] -
        sonar_values['mean_buy_call'] -
        sonar_values['mean_buy_put']
    )

    if primeraVez == True:
        credito_inicial = sonar_values['sonar_value'].iloc[0]
    else:
        credito_inicial = sonar_initialValue
        sonar_values['sonar_value'].iloc[0] = credito_inicial  # Sobrescribir el primer valor

    sonar_values['diferencia'] = credito_inicial - sonar_values['sonar_value']
    sonar_values['label'] = f'{label} [{strikes[0]}, {strikes[1]}] [{strikes[2]}, {strikes[3]}]'
    return sonar_values

# Función para calcular valores de Verticales


def calcular_vertical(strikes, label, df, vertical_initialValue, primeraVez):
    option_type = strikes[2]
    filtered_df = df[df['strike'].isin(strikes[:2])]

    if option_type == 'CALL':
        sell_df = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        buy_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()

        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_call'] + sell_df['ask_call']) / 2
        buy_df.loc[:, 'mean_buy'] = 100 * (buy_df['bid_call'] + buy_df['ask_call']) / 2

    elif option_type == 'PUT':
        sell_df = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        buy_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()

        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_put'] + sell_df['ask_put']) / 2
        buy_df.loc[:, 'mean_buy'] = 100 * (buy_df['bid_put'] + buy_df['ask_put']) / 2

    vertical_values = pd.DataFrame()

    vertical_values['timestamp'] = sell_df['timestamp']
    vertical_values['mean_sell'] = sell_df['mean_sell'].values
    vertical_values['mean_buy'] = buy_df['mean_buy'].values

    vertical_values['vertical_value'] = vertical_values['mean_sell'] - vertical_values['mean_buy']

    if primeraVez == True:
        credito_inicial = vertical_values['vertical_value'].iloc[0]
    else:
        credito_inicial = vertical_initialValue
        vertical_values['vertical_value'].iloc[0] = credito_inicial  # Sobrescribir el primer valor

    vertical_values['diferencia'] = credito_inicial - vertical_values['vertical_value']
    vertical_values['label'] = f'{label} [{strikes[0]}, {strikes[1]}] {strikes[2]}'

    # Agregar las columnas sell_strike y buy_strike
    vertical_values['sell_strike'] = strikes[0]
    vertical_values['buy_strike'] = strikes[1]

    return vertical_values

# Función para calcular valores de Makeka


def calcular_makeka(strikes, label, df, makeka_initialValue, primeraVez):
    # strikes= [5495.0, 5470.0, 5445.0, 'CALL', 'BUTTERFLY']
    option_type = strikes[3]
    filtered_df = df[df['strike'].isin(strikes[:3])]

    if option_type == 'CALL':
        buy_df1 = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        sell_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()
        buy_df2 = filtered_df[filtered_df['strike'] == strikes[2]].copy()

        buy_df1.loc[:, 'mean_buy1'] = 100 * (buy_df1['bid_call'] + buy_df1['ask_call']) / 2
        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_call'] + sell_df['ask_call']) / 2
        buy_df2.loc[:, 'mean_buy2'] = 100 * (buy_df2['bid_call'] + buy_df2['ask_call']) / 2

    elif option_type == 'PUT':

        buy_df1 = filtered_df[filtered_df['strike'] == strikes[0]].copy()
        sell_df = filtered_df[filtered_df['strike'] == strikes[1]].copy()
        buy_df2 = filtered_df[filtered_df['strike'] == strikes[2]].copy()

        buy_df1.loc[:, 'mean_buy1'] = 100 * (buy_df1['bid_put'] + buy_df1['ask_put']) / 2
        sell_df.loc[:, 'mean_sell'] = 100 * (sell_df['bid_put'] + sell_df['ask_put']) / 2
        buy_df2.loc[:, 'mean_buy2'] = 100 * (buy_df2['bid_put'] + buy_df2['ask_put']) / 2

    makeka_values = pd.DataFrame()

    makeka_values['timestamp'] = sell_df['timestamp']
    makeka_values['mean_sell'] = sell_df['mean_sell'].values
    makeka_values['mean_buy1'] = buy_df1['mean_buy1'].values
    makeka_values['mean_buy2'] = buy_df2['mean_buy2'].values

    makeka_values['makeka_value'] = (
        makeka_values['mean_sell'] * 2 -
        makeka_values['mean_buy1'] -
        makeka_values['mean_buy2']
    )

    if primeraVez == True:
        credito_inicial = makeka_values['makeka_value'].iloc[0]
    else:
        credito_inicial = makeka_initialValue
        makeka_values['makeka_value'].iloc[0] = credito_inicial  # Sobrescribir el primer valor

    makeka_values['diferencia'] = credito_inicial - makeka_values['makeka_value']
    makeka_values['label'] = f'{label} [{strikes[0]}, {strikes[1]}, {strikes[2]}] {strikes[3]}'

    return makeka_values


@app.route('/')
def index():
    return render_template('indexVer2.html')


@app.route('/tutorial')
def tutorial():
    return render_template('tutorial.html')


@app.route('/extract_strikes', methods=['POST'])
def extract_strikes():
    data = request.json
    text = data.get('text', '')

    symbol_match = re.search(r'Prediction for (\w+)', text)
    symbol = symbol_match.group(1)  # Captura el símbolo (XSP, SPY, etc.)

    num_digits = 3
    if symbol == 'RUT' or symbol == 'SPX':
        num_digits = 4

    # Expresión regular para extraer strikes y hora
    # Buscar los strikes de la estrategia Butterfly
    butterfly_pattern = r'Butterfly: .*? (\d{{{0}}})/(\d{{{0}}})/(\d{{{0}}}) (PUT|CALL)'.format(num_digits)
    butterfly_match = re.search(butterfly_pattern, text, re.IGNORECASE | re.DOTALL)
    if butterfly_match:
        butterfly_strike1, butterfly_strike2, butterfly_strike3, butterfly_option_type = butterfly_match.groups()
        print(butterfly_strike1, butterfly_strike2, butterfly_strike3)
    else:
        print("No se encontraron coincidencias de Butterfly.")

    # Buscar los strikes de la estrategia Iron Condor
    iron_condor_pattern = r'Iron Condor: .*?(\d{{{0}}})/(\d{{{0}}})/(\d{{{0}}})/(\d{{{0}}})'.format(num_digits)
    iron_condor_match = re.search(iron_condor_pattern, text, re.IGNORECASE | re.DOTALL)
    if iron_condor_match:
        ironCondor_strike1, ironCondor_strike2, ironCondor_strike3, ironCondor_strike4 = iron_condor_match.groups()
    else:
        print("No se encontraron coincidencias de Iron Condor.")

    # Buscar los strikes de la estrategia Sonar
    sonar_pattern = r'Sonar: Neutral .*?(\d{{{0}}})/(\d{{{0}}})/(\d{{{0}}})/(\d{{{0}}})'.format(num_digits)
    sonar_match = re.search(sonar_pattern, text, re.IGNORECASE | re.DOTALL)
    if sonar_match:
        sonar_strike1, sonar_strike2, sonar_strike3, sonar_strike4 = sonar_match.groups()
    else:
        print("No se encontraron coincidencias de Sonar.")

   # Buscar los strikes de la estrategia vertical
    vertical_strike_pattern = r'Vertical: .*? (\d{{{0}}})/(\d{{{0}}}) (PUT|CALL)'.format(num_digits)
    vertical_match = re.search(vertical_strike_pattern, text, re.IGNORECASE | re.DOTALL)
    if vertical_match:
        vertical_strike1, vertical_strike2, vertical_option_type = vertical_match.groups()
    else:
        print("No se encontraron coincidencias de Vertical.")

   # Completar (en base a Vertical) los strikes de la estrategia makeka
    if vertical_option_type == 'CALL':
        makeka_option_type = 'PUT'
        makeka_strike1 = int(vertical_strike1) - 10
        makeka_strike2 = int(vertical_strike1) - 5
        makeka_strike3 = vertical_strike2

    else:
        makeka_option_type = 'CALL'
        makeka_strike1 = int(vertical_strike1) + 10
        makeka_strike2 = int(vertical_strike1) + 5
        makeka_strike3 = vertical_strike2

    # Buscar dia y hora
    time_pattern = r'Prediction for {0} - (\d{{2}}-\d{{2}}-\d{{4}} \d{{2}}:\d{{2}}:\d{{2}})'.format(symbol)
    time_match = re.search(time_pattern, text, re.IGNORECASE)
    if time_match:
        date_time = time_match.group(1)

    print(butterfly_strike1, butterfly_strike2, butterfly_strike3)
    print(ironCondor_strike1, ironCondor_strike2, ironCondor_strike3, ironCondor_strike4)
    print(sonar_strike1, sonar_strike2, sonar_strike3, sonar_strike4)
    print(vertical_strike1, vertical_strike2)
    print(makeka_strike1, makeka_strike2, makeka_strike3)

    return jsonify({
        'butterfly_strike1': butterfly_strike1, 'butterfly_strike2': butterfly_strike2, 'butterfly_strike3': butterfly_strike3, 'butterfly_option_type': butterfly_option_type,
        'ironCondor_strike1': ironCondor_strike1, 'ironCondor_strike2': ironCondor_strike2, 'ironCondor_strike3': ironCondor_strike3, 'ironCondor_strike4': ironCondor_strike4,
        'sonar_strike1': sonar_strike1, 'sonar_strike2': sonar_strike2, 'sonar_strike3': sonar_strike3, 'sonar_strike4': sonar_strike4,
        'vertical_strike1': vertical_strike1, 'vertical_strike2': vertical_strike2, 'vertical_option_type': vertical_option_type,
        'makeka_strike1': makeka_strike1, 'makeka_strike2': makeka_strike2, 'makeka_strike3': makeka_strike3, 'makeka_option_type': makeka_option_type,
        'date_time': date_time,
        'symbol': symbol
    })


if __name__ == '__main__':
    app.run(debug=True, port=5002)  # Ejecutar la aplicación Flask en modo debug