from flask import Blueprint, request, jsonify
from database import db
from auth import token_required
import mysql.connector
import logging

logger = logging.getLogger(__name__)

entrenamientos_bp = Blueprint('entrenamientos', __name__, url_prefix='/v1/entrenamientos')

@entrenamientos_bp.route('', methods=['POST'])
@token_required
def crear_entrenamiento():
    data = request.get_json()
    
    required_fields = ['idEntrena', 'fecha', 'distancia', 'tiempo', 'velocidad']
    for field in required_fields:
        if not data.get(field):
            return jsonify({
                "status": "error",
                "message": f"Campo {field} es obligatorio"
            }), 400
    
    id_entrena = data['idEntrena']
    fecha = data['fecha']
    distancia = data['distancia']
    tiempo = data['tiempo']
    velocidad = data['velocidad']
    valoracion = data.get('valoracion')
    comentarios = data.get('comentarios')
    tipo_entrena = data.get('tipoEntrena')
    
    connection = db.get_connection()
    if not connection:
        return jsonify({
            "status": "error", 
            "message": "Error de conexión a la base de datos"
        }), 500
    
    try:
        cursor = connection.cursor()
        
        cursor.execute(
            """INSERT INTO Xalarrazabal025_entrenamientos 
            (usuario_id, id_local, idActividad, fechaHora, tiempo, distancia, velocidad, valoracion, comentarios) 
            VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)""",
            (request.user_id, id_entrena, tipo_entrena, fecha, tiempo, distancia, 
             velocidad, valoracion, comentarios)
        )
        
        connection.commit()
        
        return jsonify({
            "status": "success", 
            "message": "Entrenamiento guardado correctamente"
        }), 201
        
    except mysql.connector.Error as e:
        connection.rollback()
        logger.error(f"Database error: {e}")
        return jsonify({
            "status": "error",
            "message": f"Error al guardar el entrenamiento: {str(e)}"
        }), 500
    finally:
        cursor.close()
        connection.close()

@entrenamientos_bp.route('/<int:id_entrena>', methods=['PUT'])
@token_required
def actualizar_entrenamiento(id_entrena):
    data = request.get_json()
    
    valoracion = data.get('valoracion')
    comentario = data.get('comentario')
    
    if id_entrena <= 0:
        return jsonify({
            "status": "error",
            "message": "ID de entrenamiento inválido"
        }), 400
    
    connection = db.get_connection()
    if not connection:
        return jsonify({
            "status": "error", 
            "message": "Error de conexión a la base de datos"
        }), 500
    
    try:
        cursor = connection.cursor()
        
        cursor.execute(
            """UPDATE Xalarrazabal025_entrenamientos 
            SET valoracion = %s, comentarios = %s 
            WHERE id_local = %s 
            AND usuario_id = %s""",
            (valoracion, comentario, id_entrena, request.user_id)
        )
        
        connection.commit()
        
        if cursor.rowcount > 0:
            return jsonify({
                "status": "success",
                "message": "Datos actualizados correctamente"
            })
        else:
            return jsonify({
                "status": "error",
                "message": "No se encontró el entrenamiento o no tienes permisos"
            }), 404
            
    except mysql.connector.Error as e:
        connection.rollback()
        logger.error(f"Database error: {e}")
        return jsonify({
            "status": "error",
            "message": f"Error al actualizar: {str(e)}"
        }), 500
    finally:
        cursor.close()
        connection.close()

@entrenamientos_bp.route('/<int:id_entrena>', methods=['DELETE'])
@token_required
def eliminar_entrenamiento(id_entrena):
    if id_entrena <= 0:
        return jsonify({
            "status": "error",
            "message": "ID de entrenamiento inválido"
        }), 400
    
    connection = db.get_connection()
    if not connection:
        return jsonify({
            "status": "error", 
            "message": "Error de conexión a la base de datos"
        }), 500
    
    try:
        cursor = connection.cursor()
        
        # Start transaction
        connection.start_transaction()
        
        try:
            # Delete associated route
            cursor.execute(
                "DELETE FROM Xalarrazabal025_Ruta WHERE id_local = %s",
                (id_entrena,)
            )
            
            # Delete training
            cursor.execute(
                "DELETE FROM Xalarrazabal025_entrenamientos WHERE usuario_id = %s AND id_local = %s",
                (request.user_id, id_entrena)
            )
            
            if cursor.rowcount == 0:
                raise Exception("No se encontró el entrenamiento para este usuario")
            
            connection.commit()
            
            return jsonify({
                "status": "success",
                "message": "Entrenamiento eliminado correctamente"
            })
            
        except Exception as e:
            connection.rollback()
            return jsonify({
                "status": "error",
                "message": f"Error al eliminar: {str(e)}"
            }), 500
            
    except mysql.connector.Error as e:
        logger.error(f"Database error: {e}")
        return jsonify({
            "status": "error",
            "message": f"Error de base de datos: {str(e)}"
        }), 500
    finally:
        cursor.close()
        connection.close()

@entrenamientos_bp.route('/no-locales', methods=['POST'])
@token_required
def obtener_entrenamientos_no_locales():
    data = request.get_json()
    ids_locales = data.get('ids_locales', [])
    
    connection = db.get_connection()
    if not connection:
        return jsonify({
            "status": "error", 
            "message": "Error de conexión a la base de datos"
        }), 500
    
    try:
        cursor = connection.cursor(dictionary=True)
        
        if ids_locales:
            placeholders = ','.join(['%s'] * len(ids_locales))
            query = f"""SELECT * FROM Xalarrazabal025_entrenamientos 
                       WHERE usuario_id = %s AND id_local NOT IN ({placeholders})"""
            params = [request.user_id] + ids_locales
            cursor.execute(query, params)
        else:
            cursor.execute(
                "SELECT * FROM Xalarrazabal025_entrenamientos WHERE usuario_id = %s",
                (request.user_id,)
            )
        
        entrenamientos = cursor.fetchall()
        
        # Get routes for each training
        for entrenamiento in entrenamientos:
            cursor.execute(
                "SELECT id, id_local, latitud, longitud FROM Xalarrazabal025_Ruta WHERE id_local = %s",
                (entrenamiento['id_local'],)
            )
            rutas = cursor.fetchall()
            entrenamiento['rutas'] = rutas
        
        return jsonify({
            "status": "success",
            "data": entrenamientos
        })
        
    except mysql.connector.Error as e:
        logger.error(f"Database error: {e}")
        return jsonify({
            "status": "error",
            "message": "Error de base de datos"
        }), 500
    finally:
        cursor.close()
        connection.close()

@entrenamientos_bp.route('/ruta', methods=['POST'])
@token_required
def agregar_ruta():
    data = request.get_json()
    
    required_fields = ['idEntrena', 'latitud', 'longitud']
    for field in required_fields:
        if not data.get(field):
            return jsonify({
                "status": "error",
                "message": f"Campo {field} es obligatorio"
            }), 400
    
    id_entrena = int(data['idEntrena'])
    latitud = float(data['latitud'])
    longitud = float(data['longitud'])
    
    connection = db.get_connection()
    if not connection:
        return jsonify({
            "status": "error", 
            "message": "Error de conexión a la base de datos"
        }), 500
    
    try:
        cursor = connection.cursor()
        
        cursor.execute(
            """INSERT INTO Xalarrazabal025_Ruta 
            (id_local, latitud, longitud) 
            VALUES (%s, %s, %s)""",
            (id_entrena, latitud, longitud)
        )
        
        connection.commit()
        
        return jsonify({
            "status": "success",
            "message": "Ubicación guardada correctamente"
        }), 201
        
    except mysql.connector.Error as e:
        connection.rollback()
        logger.error(f"Database error: {e}")
        return jsonify({
            "status": "error",
            "message": f"Error al guardar la ubicación: {str(e)}"
        }), 500
    finally:
        cursor.close()
        connection.close()