from flask import Flask, render_template, request, url_for, redirect, flash, session

from markupsafe import Markup
from flask_bootstrap import Bootstrap
import csv
import funcionesV2
from datetime import datetime

import json
from itertools import zip_longest
from config import config
from flask_mysqldb import MySQL
from flask_login import LoginManager, login_user, logout_user, login_required, current_user
from flask_wtf.csrf import CSRFProtect
from flask import jsonify
from config import Config
from flask_compress import Compress
import fear_and_greed
import secrets
from flask_talisman import Talisman
import pprint
# Models
from models.ModelUser import ModelUser

# Entities
from models.entities.User import User

app = Flask(__name__)
Compress(app)
app.secret_key = Config.SECRET_KEY
bootstrap = Bootstrap(app)
db = MySQL(app)
login_manager_app = LoginManager(app)
csrf = CSRFProtect()


@login_manager_app.user_loader
def load_user(id):
    return ModelUser.get_by_id(db, id)


# Ruta para el directorio raiz
@app.route('/')
def index():
    return render_template('/index.html')


# Ruta para el about page
@app.route('/about')
def about():
    return render_template('about.html')


# Ruta para el pricing page
@app.route('/pricing')
def pricing():
    return render_template('pricing.html')

# Ruta para el terminos y condiciones


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


# Ruta para el contact page y el envio del formulario de contacto (segun sea GET o POST)!!!
@app.route('/contact', methods=['GET', 'POST'])
def contact():
    if request.method == 'POST':
        first_name = request.form['firstName']
        last_name = request.form['lastName']
        email = request.form['email']
        message = f"""\
         Contact From Website
         --------------------

         Name: {first_name} {last_name}
         Email: {email}
         Message: {request.form['message']}
         """
        recipient_email = 'info@spxbutterflies.com'
        funcionesV2.send_email_general(
            "Contact from website", first_name, last_name, recipient_email, message)
        flash('We have been receipt your message. Thank you.', 'success')
        return render_template('contact.html')
    else:
        return render_template('contact.html')


@app.route('/reenviar_email_validation')
def reenviar_email_validation():
    token = secrets.token_hex(10)
    # Obtener el valor del parámetro 'username' de la solicitud
    username = request.args.get('username')
    saveToken = ModelUser.saveToken(db, username, token)
    if saveToken:
        funcionesV2.send_email_(
            "SPX Butterflies - Validate your email.", "To validate your email, please click on the following link: \n", username, token, "FreeTrial")
        flash('We have sent a validation link to your email.', 'success')
        return redirect(url_for('validate_email_sent'))


# Ruta para login!!!
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        user = User(0, request.form['username'], request.form['password'])
        logged_user = ModelUser.login(db, user)
        if logged_user != None:
            if logged_user.password:
                login_user(logged_user)
                username = logged_user.username
                session['userID'] = (logged_user.id)
                session['userPlan'] = (logged_user.userPlan)
                session['username'] = username

                # Controla si el usuario ha validado su email
                if logged_user.userPlan == 33:
                    flash(Markup('Your email account has not been verified. Please check your mailbox and follow the instructions provided. <a href="/reenviar_email_validation?username={}">Click here</a> to send the link again.'.format(username)), 'warning')
                    return render_template('/auth/login.html')

                # Registra el ID y el timestamp en el archivo CSV
                try:
                    funcionesV2.registrar_log(session['userID'])
                except Exception as e:
                    return jsonify({"error": str(e)})

                # Entra a la aplicacion!!!!
                return redirect(url_for('dashboard'))
            else:
                flash("Invalid password")
                return render_template('/auth/login.html')
        else:
            flash("User not found")
            return render_template('/auth/login.html')
    else:
        return render_template('/auth/login.html')


# Ruta para registrarse y empezar el free Trial la  gratis!!!
@app.route('/startFreeTrial', methods=['GET', 'POST'])
def startFreeTrial():
    if request.method == 'GET':
        return render_template('/auth/start_free_trial.html')
    
    else:
        username = request.form.get('username')  # Username = email
        name = request.form.get('name')
        password = request.form.get('password')
        password1 = request.form.get('password1')
        if len(username) == 0 or len(username) > 40:
            flash('An email is required to create an account.')
            session['stored_username'] = username
            return redirect(url_for('startFreeTrial'))
        if len(password) < 8 or len(password) > 20:
            flash('The password must be at least 8 characters.')
            session['stored_username'] = username
            return redirect(url_for('startFreeTrial'))
        if password != password1:
            flash('Passwords do not match.')
            session['stored_username'] = username
            return redirect(url_for('startFreeTrial'))
        if len(name) < 2 or len(name) > 50:
            flash('Please enter a valid name.')
            return redirect(url_for('startFreeTrial'))

        # Comienza el codigo para conectarse a la base de datos y chequear que todo este OK!!!
        # Chequeando si existe el usuario/email!!!
        user = User(0, username, "")
        logged_user = ModelUser.login(db, user)

        if logged_user == None:
            userPlan = 33
            ModelUser.create(db, username, password, name, userPlan)

            token = secrets.token_hex(10)
            saveToken = ModelUser.saveToken(db, username, token)
            if saveToken:
                funcionesV2.send_email_(
                    "SPX Butterflies - Validate your email.", "\To validate your email, please click on the following link: \n", username, token, "FreeTrial")
                flash('We have sent a validation link to your email.', 'success')
                return redirect(url_for('validate_email_sent'))
            else:
                flash('Error. Try again!!!')
                return redirect(url_for('login'))

        else:
            flash('User already exist.')
            return redirect(url_for('starFreeTrial'))


# Ruta para registrarse gratis!!!
@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'GET':
        return render_template('/auth/register.html')
    else:
        username = request.form.get('username')  # Username = email
        name = request.form.get('name')
        password = request.form.get('password')
        password1 = request.form.get('password1')
        if len(username) == 0 or len(username) > 40:
            flash('An email is required to create an account.')
            session['stored_username'] = username
            return redirect(url_for('register'))
        if len(password) < 8 or len(password) > 20:
            flash('The password must be at least 8 characters.')
            session['stored_username'] = username
            return redirect(url_for('register'))
        if password != password1:
            flash('Passwords do not match.')
            session['stored_username'] = username
            return redirect(url_for('register'))
        if len(name) < 2 or len(name) > 50:
            flash('Please enter a valid name.')
            return redirect(url_for('register'))

        # Comienza el codigo para conectarse a la base de datos y chequear que todo este OK!!!
        # Chequeando si existe el usuario/email!!!
        user = User(0, username, "")
        logged_user = ModelUser.login(db, user)

        if logged_user == None:
            userPlan = 33
            ModelUser.create(db, username, password, name, userPlan)
            flash('User created successfully. You can log in now.')
            return redirect(url_for('login'))
        else:
            flash('User already exist.')
            return redirect(url_for('register'))


# Ruta para suscribirse!!!
@app.route('/suscribe', methods=['GET', 'POST'])
def suscribe():
    if request.method == 'GET':
        session['registro_exitoso'] = False
        session['stored_name'] = ""
        session['stored_username'] = ""
        return render_template('/auth/suscribe.html')
    else:
        session['registro_exitoso'] = False
        username = request.form.get('username')  # Username = email
        name = request.form.get('name')
        password = request.form.get('password')
        password1 = request.form.get('password1')
        if len(username) == 0 or len(username) > 40:
            flash('An email is required to create an account.')
            session['stored_username'] = username
            return redirect(url_for('suscribe'))

        if len(password) < 8 or len(password) > 32:
            flash('The password must be at least 8 characters.')
            session['stored_username'] = username
            return redirect(url_for('suscribe'))

        if password != password1:
            flash('Passwords do not match.')
            session['stored_username'] = username
            return redirect(url_for('suscribe'))

        if len(name) < 2 or len(name) > 50:
            flash('Please enter a valid name.')
            return redirect(url_for('suscribe'))

        # Comienza el codigo para conectarse a la base de datos y chequear que todo este OK.
        # Chequeando si existe el usuario/email
        user = User(0, username, "")
        logged_user = ModelUser.login(db, user)
        # Si el usuario se pudo registrar (si eligio SUSCRIBE) ahora debe continuar yendo a la parte de pago mediante REGISTRO EXITOSO= True
        if logged_user == None:
            userPlan = 33
            ModelUser.create(db, username, password, name, userPlan)
            session['stored_name'] = name
            session['stored_username'] = username
            session['registro_exitoso'] = True
            return render_template('auth/suscribe.html')
        else:
            flash('User already exist.')
            return redirect(url_for('suscribe'))


# Funcion para obtener y cargar los valores del profile de cada usuario!!!
@app.route('/get_modal_data')
@login_required
def get_modal_data():
    settingData = ModelUser.get_by_id(db, session['userID'])
    data = vars(settingData)
    print (data)
    return jsonify(data)


@app.route('/dashboard')
@login_required
def dashboard():
    return render_template('/dashboard.html', is_dashboard=True)


@app.route('/heatmap')
@login_required
def heatmap():
    if 'userPlan' in session and session['userPlan'] == 1:
        return redirect(url_for('login'))
    else:
        return render_template('/heatmap.html')


@app.route('/alerts')
@login_required
def alerts():
    if 'userPlan' in session and session['userPlan'] == 1:
        return redirect(url_for('login'))
    else:
        return render_template('/alerts.html')


@app.route('/chart_live')
@login_required
def chart_live():
    if 'userPlan' in session and session['userPlan'] == 1:
        return redirect(url_for('login'))
    else:
        return render_template('/chart_live.html')


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


# Funcion para obtener los dias que el mercado estuvo abierto y/o si cada estrategia tiene datos!!!
@app.route('/get_label_data/<string:EstrategiaNumber>')
@login_required
def get_label_data(EstrategiaNumber):
    diasHabilitados = funcionesV2.obtener_Dias(EstrategiaNumber)
    return jsonify({
        'diasHabilitados': diasHabilitados
    })

# Ruta para recuperar y mostrar los datos en el chart_live!!!


@app.route('/chart_live/<estrategia>/<takeProfit>/<stopLoss>/<offset>/<dollarOrPerc>', methods=['GET'])
@login_required
def mostrar_chart_live(estrategia, takeProfit, stopLoss, offset, dollarOrPerc):
    x_data = []
    y_data = []
    z_data = []
    w_data = []
    data, cabecera = funcionesV2.listaParaGraficoDiario(estrategia, offset)
    x_data = data.iloc[:, 0].tolist()
    if dollarOrPerc == 'P':
        y_data = data.iloc[:, 5].tolist() # Columna 5 tiene los porcentanjes de movimiento
    else:
        y_data = data.iloc[:, 4].tolist() # Columa 4 tiene los precios de movimiento

    z_data = data.iloc[:, 3].tolist() # Columna 3 tiene el VIX
    w_data = data.iloc[:, 2].tolist() # Columna 2 tiene el SPX
    ultimoPrecioSPX = "{:.2f}".format(data.iloc[-1, 2])
    profitLossPercentage = "{:.2f}".format(data.iloc[-1, 5]*100) # Columna 5 tiene los porcentanjes de movimiento
    profitLossDollar = "{:.2f}".format(data.iloc[-1, 4]) # Columa 4 tiene los precios de movimiento

    credit = float(data.iloc[0, 1]) - float(offset)
    primerSPX = data.iloc[0, 2]
    ModDif = primerSPX % 5
    creditLess = float(primerSPX)-ModDif
    if ModDif > 2.5:
        strikeSPX = int(creditLess+5)
    else:
        strikeSPX = int(creditLess)

    # if estrategia == '5':
    #     anchoAlas = 30
    # else:
    #     anchoAlas = 40

    # wing1 = "BTO CALL " + str((strikeSPX + anchoAlas))
    # wing2 = "STO CALL " + str(strikeSPX)
    # wing3 = "STO PUT " + str(strikeSPX)
    # wing4 = "BTO PUT " + str(strikeSPX - anchoAlas)
    
    wing1 = "BTO CALL " + str(cabecera.iloc[0, 2])
    wing2 = "STO CALL " + str(cabecera.iloc[0, 0])
    wing3 = "STO PUT " + str(cabecera.iloc[0, 1])
    wing4 = "BTO PUT " + str(cabecera.iloc[0, 3])



    response_data = {
        'x_data': x_data,
        'y_data': y_data,
        'z_data': z_data,
        'w_data': w_data,
        'strikeSPX': strikeSPX,
        'wing1': wing1,
        'wing2': wing2,
        'wing3': wing3,
        'wing4': wing4,
        'ultimoPrecioSPX': ultimoPrecioSPX,
        'profitLossPercentage': profitLossPercentage,
        'profitLossDollar': profitLossDollar,
        'credit': credit,
    }

    json_response = json.dumps(response_data)
    return json_response


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


@app.route('/chart_historical/<fecha>/<estrategia>/<takeProfit>/<stopLoss>/<offset>/<dollarOrPerc>', methods=['GET'])
@login_required
def mostrar_chart(fecha, estrategia, takeProfit, stopLoss, offset, dollarOrPerc):
    x_data = []
    y_data = []
    # z_data= []
    data = funcionesV2.listaParaGrafico(fecha, estrategia, float(offset))
    x_data = data.iloc[:, 0].tolist()
    # z_data = data.iloc[:, 3].tolist()
    
    # price 1
    # spx   2
    # vix   3
    # P/L $ 4
    # P/L % 5

   
    if dollarOrPerc == 'P':
        y_data = data.iloc[:, 5].tolist()
    else:
        y_data = data.iloc[:, 4].tolist()

    hayNoticias = funcionesV2.verificarFeriados(fecha)
    primerSPX = data.iloc[0, 2]
    credit = float(data.iloc[0, 1]) - float(offset)

    # Generar estructura del IB en base al 1er precio del SPX
    ModDif = primerSPX % 5
    creditLess = float(primerSPX)-ModDif
    if ModDif > 2.5:
        strikeSPX = int(creditLess) + 5
    else:
        strikeSPX = int(creditLess)

    if estrategia == '5':
        anchoAlas = 30
    else:
        anchoAlas = 40

    wing1 = "BTO CALL " + str((strikeSPX + anchoAlas))
    wing2 = "STO CALL " + str(strikeSPX)
    wing3 = "STO PUT " + str(strikeSPX)
    wing4 = "BTO PUT " + str(strikeSPX - anchoAlas)

    response_data = {
        'x_data': x_data,
        'y_data': y_data,
        # 'z_data': z_data,
        'strikeSPX': strikeSPX,
        'wing1': wing1,
        'wing2': wing2,
        'wing3': wing3,
        'wing4': wing4,
        'credit': credit,
        'hayNoticias': hayNoticias
    }

    json_response = json.dumps(response_data)
    return json_response


@app.route('/update_table', methods=['POST'])
@login_required
def update_table():
    take_profit = float(request.form['takeProfit'])
    stop_loss = float(request.form['stopLoss'])
    contracts_ = float(request.form['contracts'])
    estrategia_Number_ = request.form['estrategiaNumber']
    offset_ = float(request.form['offset'])
    dollarOrPerc_ = request.form['dollarOrPerc']
    updated_data = funcionesV2.obtener_Datos(
        take_profit/100, stop_loss/100, contracts_, estrategia_Number_, offset_, dollarOrPerc_)
    return jsonify(updated_data)


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


@app.route('/comparative_data', methods=['POST'])
@login_required
def process_data():
    takeProfit1_Percen = float(request.form['takeProfit1_Percen'])/100
    takeProfit2_Percen = float(request.form['takeProfit2_Percen'])/100
    takeProfit3_Percen = float(request.form['takeProfit3_Percen'])/100
    takeProfit4_Percen = float(request.form['takeProfit4_Percen'])/100
    stopLoss1_Percen = float(request.form['stopLoss1_Percen'])/100
    stopLoss2_Percen = float(request.form['stopLoss2_Percen'])/100
    stopLoss3_Percen = float(request.form['stopLoss3_Percen'])/100
    stopLoss4_Percen = float(request.form['stopLoss4_Percen'])/100
    offset = float(request.form['offset'])
    contracts = float(request.form['contracts'])
    miniComparative = request.form.get('miniComparative')
    IBList = request.form.get('IBList').split(',')

    listaFechas, listaNews, lista1, lista2, lista3, lista4, credito1, credito2, credito3, credito4, TPMinutes1, TPMinutes2, TPMinutes3, TPMinutes4, profitOrLoss1, profitOrLoss2, profitOrLoss3, profitOrLoss4 = funcionesV2.listaComparativa(
        takeProfit1_Percen, takeProfit2_Percen, takeProfit3_Percen, takeProfit4_Percen, stopLoss1_Percen, stopLoss2_Percen, stopLoss3_Percen, stopLoss4_Percen, offset, contracts, miniComparative, IBList)

    listaNombreDias = [obtener_nombre_dia(fecha) for fecha in listaFechas]

    listas = [listaFechas, listaNombreDias, listaNews, lista1,
              lista2, lista3, lista4, credito1, credito2, credito3, credito4, TPMinutes1, TPMinutes2, TPMinutes3, TPMinutes4, profitOrLoss1, profitOrLoss2, profitOrLoss3, profitOrLoss4]

    # convierte las listas en una unica lista poniendo "-" donde no hay datos!!!
    lista_unica = list(zip_longest(*listas))

    return jsonify(data=lista_unica)


@app.route('/saveOnDB', methods=['POST'])
def guardar_valores():
    try:
        data = request.get_json()  # Obtener los datos enviados desde el cliente
        
        ModelUser.saveData(db, data, session['userID'])
        return "Valores guardados correctamente", 200

    except Exception as e:
        return str(e), 400  # Devuelve un error 400 en caso de problemas


@app.route('/update_BestPair', methods=['POST'])
@login_required
def update_BestPair():
    data = request.get_json()
    dollarOrPerc = data.get('dollarOrPerc')
    newsDays = data.get('newsDays')
    estrategia = data.get('estrategia')
    resultsIn = data.get('resultsIn')
    contracts = float(data.get('contracts'))
    offset = float(data.get('offset'))
    sinceDate = data.get('sinceDate')
    untilDate = data.get('untilDate')
    dataIB1 = funcionesV2.obtenerBestPair(
        estrategia, dollarOrPerc, newsDays, resultsIn, contracts, offset, sinceDate, untilDate)
    return jsonify(dataIB1)


@app.route('/obtener_fear_and_greed')
def obtener_fear_and_greed():
    fearGreed = fear_and_greed.get()
    fear_greed_info = {
        "value": fearGreed.value,
        "description": fearGreed.description,
        "last_update": fearGreed.last_update.isoformat(),
    }

    return jsonify(fear_greed_info)


@app.route('/obtener_datos_best_pair')
@login_required
def obtener_datos_best_pair():
    datos = funcionesV2.obtener_datos_best_pair()
    return (datos)


@app.route('/logout')
def logout():
    logout_user()
    return redirect(url_for('index'))


def obtener_nombre_dia(fecha_str):
    fecha = datetime.strptime(fecha_str, '%m/%d/%Y')
    nombre_dia = fecha.strftime('%A')  # %A devuelve el nombre completo del día
    return nombre_dia


def guardar_evento_paypal(data):
    # Esta función guarda los datos del evento de PayPal en un archivo CSV
    with open('/var/www/html/flask_project/eventos_paypal.csv', mode='a', newline='') as file:
        writer = csv.writer(file)
        writer.writerow([
            data['event_type'],  # Tipo de evento de PayPal
            data['summary'],     # Resumen del evento
            data['create_time'],  # Hora de creación del evento
            data['resource']['subscriber']['name']['given_name'] + \
            ' ' + data['resource']['subscriber']['name']['surname'],
            data['resource']['subscriber']['email_address'],
            data['resource']['id']
        ])


@app.route('/pp_webhook', methods=['POST'])
def pp_webhook():

    # Verificar si la solicitud proviene de PayPal
    # if request.headers.get('User-Agent') == 'PayPal IPN ( https://www.paypal.com/ipn )':

    # Obtener los datos del evento de PayPal
    paypal_data = request.json
    print("paypal")
   # Convertir el objeto JSON a una cadena

    # Procesar el evento de PayPal
    guardar_evento_paypal(paypal_data)

    # Envía una respuesta al servidor de PayPal para confirmar la recepción del evento
    return jsonify({'status': 'success'}), 200

    # else:
    #     #Si la solicitud no proviene de PayPal, responde con un error
    #     return jsonify({'error': 'Unauthorized'}), 401


@app.route('/saveOnDBVIPUser', methods=['POST'])
def saveONDBVIPuser():
    try:
        data = request.get_json()  # Obtener los datos enviados desde el cliente

        ModelUser.saveDataVIP(db, data['usernameVIP'], data['transactionID'])
        return "Saving OK", 200

    except Exception as e:
        return str(e), 400  # Devuelve un error 400 en caso de problemas


@app.route('/forgot_password', methods=['GET'])
def forgot_password():
    return render_template('forgot_password.html')


@app.route('/suscribeUserRegistrado')
def suscribeUserRegistrado():
    session['registro_exitoso'] = True
    return redirect(url_for('suscribe'))


# Funcion para cheequear si el usuario existe y enviar un email de recuperacion de password!!!
@app.route('/check_user', methods=['POST'])
def check_user():
    if request.method == 'POST':
        username = request.form['username']
        # Verifica si el usuario existe en la base de datos
        user_exists = ModelUser.check_user_exists(db, username)
        if user_exists:
            token = secrets.token_hex(10)
            saveToken = ModelUser.saveToken(db, username, token)
            if saveToken:
                funcionesV2.send_email_(
                    "Password Request", "There was a request to change your password!\nIf you did not make this request then please ignore this email.\nOtherwise, please click this link to change your password: \n", username, token, "ResetPassword")
                flash('We have sent a recovery link to your email.', 'success')
                return redirect(url_for('password_reset_sent'))

            else:
                flash('Error. Try again!!!')

            return redirect(url_for('forgot_password'))
        else:
            flash("No account found for this email.")
            return redirect(url_for('forgot_password'))
    else:
        # Si se accede a esta ruta mediante un método diferente a POST, devuelve un error
        return jsonify({'error': 'Method not allowed'}), 405


# Ruta que chequea el token enviado para validar el email


@app.route('/validate_email', methods=['GET'])
def validate_email():
    if request.method == 'GET':
        token = request.args.get('token')
        username = request.args.get('username')
        if ModelUser.token_exists(db, token):
            try:
                # cambiar el userPlan de 33 a VIP
                ModelUser.saveDataVIP_validatedEmail(db, username)
            except Exception as e:
                # Devuelve un error 400 en caso de problemas
                return str(e), 400

            # Renderizar el formulario para mostrar que el email ha sido validado
            return render_template('validate_email.html')
        else:
            token = secrets.token_hex(10)
            saveToken = ModelUser.saveToken(db, username, token)
            if saveToken:
                funcionesV2.send_email_(
                    "SPX Butterflies - Validate your email.", "To validate your email, please click on the following link: \n", username, token, "FreeTrial")
                flash('We have sent a validation link to your email.', 'success')
            else:
                flash('Error. Try again!!!')

            return render_template('validate_email_error.html')

# Ruta que chequea el token enviado para resetear el password


@app.route('/reset_password', methods=['GET', 'POST'])
def reset_password():
    if request.method == 'GET':
        token = request.args.get('token')
        if ModelUser.token_exists(db, token):
            # Renderizar el formulario de restablecimiento de contraseña
            return render_template('reset_password.html', token=token)

        # Flash mensaje de error si el token no es válido
        else:
            flash('The link has expired or is incorrect.', 'error')
            return redirect(url_for('index'))
    else:  # eL request viene de un POST
        # Recuperar token y las nuevas contraseñas del formulario
        token = request.form['token']
        new_password = request.form['new_password']
        confirm_password = request.form['confirm_password']

        # Verificar que las contraseñas coincidan
        if new_password == confirm_password:
            # Restablecer la contraseña del usuario en la base de datos
            ModelUser.reset_password(db, token, new_password)

            # Flash mensaje de éxito
            flash('Your password has been successfully reset.', 'success')

            # Redirigir al usuario a la página de inicio de sesión
            return redirect(url_for('login'))
        else:
            # Flash mensaje de error si las contraseñas no coinciden
            flash('Passwords do not match. Please try again.', 'error')
            # Redirigir al usuario de vuelta al formulario de restablecimiento de contraseña
            return render_template('reset_password.html', token=token)


# Vista para la página de confirmación de envío de correo electrónico de restablecimiento de contraseña
@app.route('/password_reset_sent')
def password_reset_sent():
    return render_template('password_reset_sent.html')

# Vista para la página de confirmación de envío de correo electrónico de validacion de email


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

# Vista para la página de error cuando el token enviado no coincide


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


@app.route('/newsletter', methods=['GET', 'POST'])
@login_required
def newsletter():
    if request.method == 'POST':
        first_name = request.form['firstName']
        last_name = request.form['lastName']
        email = request.form['email']
        message = f"""\
         Please suscribe me to the Newsletter
         ------------------------------------

         Name: {first_name} {last_name}
         Email: {email}
         """

        recipient_email = 'info@spxbutterflies.com'
        funcionesV2.send_email_general(
            "Contact from website", first_name, last_name, recipient_email, message)

        flash('You have been suscribe to the newsletter. Thank you.', 'success')
    return redirect(url_for('prueba'))


@app.route('/get_alerts_data')
@login_required
def get_alerts_data():
    data = funcionesV2.get_alert_data()
    return data


@app.route('/change_language')
@login_required
def change_language():
    # Obtener el idioma seleccionado de los parámetros de la URL
    lang = request.args.get('lang')
    return redirect('/')


@app.errorhandler(401)
def unauthorized(error):
    return render_template('error_401.html'), 401


@app.errorhandler(404)
def page_not_found(error):
    return render_template('error_404.html'), 404


@app.route('/tradingview_webhook', methods=['POST'])
def tradingview_webhook():
    PATH_FILE = "/var/www/html/flask_project/"
    data = request.get_json()  # Obtener los datos JSON del cuerpo de la solicitud POST
    if data:
        # Procesar los datos JSON recibidos
        action = data.get('action')
        ticker = data.get('ticker')
        close = data.get('close')
        interval = data.get('interval')
        timestamp_ = data.get('timestamp')

        # Guardar los datos en un archivo CSV
        with open(PATH_FILE + 'tradingview_data.csv', mode='a', newline='') as file:
            writer = csv.writer(file)
            writer.writerow([action, ticker, close, interval, timestamp_])

    return 'OK', 200


@app.route('/tradingview_webhook_strategy', methods=['POST'])
def tradingview_webhook_strategy():
    PATH_FILE = "/var/www/html/flask_project/"
    data = request.get_json()  # Obtener los datos JSON del cuerpo de la solicitud POST
    if data:
        # Procesar los datos JSON recibidos
        action = data.get('action')
        strategy_order_action = data.get('strategyOrderAction')
        strategy_order_contracts = data.get('strategyOrderContracts')
        strategy_position_size = data.get('strategyPositionSize')
        strategy_order_comment = data.get('strategyOrderComment')
        ticker = data.get('ticker')
        close = data.get('close')
        interval = data.get('interval')
        timestamp_ = data.get('timestamp')

        # Guardar los datos en un archivo CSV
        with open(PATH_FILE + 'tradingview_data_strategy.csv', mode='a', newline='') as file:
            writer = csv.writer(file)
            writer.writerow([action, strategy_order_action, strategy_order_contracts,
                            strategy_position_size, strategy_order_comment, ticker, close, interval, timestamp_])

    return 'OK', 200


# MAIN *** MAIN *** MAIN
if __name__ == '__main__':
    app.run(debug=True)