from flask import Flask, render_template, request, jsonify, session, redirect, url_for
from flask_cors import CORS
import mysql.connector
from mysql.connector import Error
import smtplib
from email.message import EmailMessage
from datetime import datetime
import re
import os
from werkzeug.utils import secure_filename
import json

app = Flask(__name__)
app.secret_key = 'tu_clave_secreta_aqui_12345_cambiala_por_una_segura'
CORS(app)

# Configuración para subida de archivos
UPLOAD_FOLDER = 'static/uploads'
ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'webp'}
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max

# Crear carpeta de uploads si no existe
os.makedirs(UPLOAD_FOLDER, exist_ok=True)

def allowed_file(filename):
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

# ===== CONFIGURACIÓN BASE DE DATOS =====
db_config = {
    'host': 'localhost',
    'user': 'root',
    'password': '',  # Tu contraseña de MySQL
    'database': 'sistema_camillas'
}

# ===== CONFIGURACIÓN CORREO GMAIL =====
EMAIL_SENDER = "jorgedavidtorricocopali@gmail.com"
EMAIL_PASSWORD = "iedkrgyjxbzejxhx"

def get_db_connection():
    """Conectar a la base de datos"""
    try:
        conn = mysql.connector.connect(**db_config)
        return conn
    except Error as e:
        print(f"Error de conexión a BD: {e}")
        return None

def get_limite_reserva():
    """Obtener límite de reserva de la configuración"""
    conn = get_db_connection()
    if not conn:
        return 4
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT valor FROM configuraciones WHERE clave = 'limite_reserva'")
        result = cursor.fetchone()
        return int(result['valor']) if result else 4
    except:
        return 4
    finally:
        cursor.close()
        conn.close()

def get_email_destino():
    """Obtener email destino de la configuración"""
    conn = get_db_connection()
    if not conn:
        return 'torrijorge736@gmail.com'
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT valor FROM configuraciones WHERE clave = 'email_destino'")
        result = cursor.fetchone()
        return result['valor'] if result else 'torrijorge736@gmail.com'
    except:
        return 'torrijorge736@gmail.com'
    finally:
        cursor.close()
        conn.close()

def enviar_notificacion_reserva(datos_reserva):
    """Enviar correo con los datos de la reserva"""
    try:
        email_destino = get_email_destino()
        
        msg = EmailMessage()
        msg["Subject"] = f"🔔 NUEVA RESERVA - {datos_reserva['camilla']}"
        msg["From"] = EMAIL_SENDER
        msg["To"] = email_destino
        
        limite = get_limite_reserva()
        es_pedido_especial = datos_reserva['cantidad'] > limite
        
        cuerpo = f"""
        🏥 NUEVA RESERVA DE CAMILLA
        {'='*40}
        
        📋 DETALLES DE LA RESERVA:
        • Camilla: {datos_reserva['camilla']}
        • Cantidad: {datos_reserva['cantidad']}
        • Precio unitario: Bs. {datos_reserva['precio']:,.2f}
        • Total: Bs. {datos_reserva['total']:,.2f}
        
        👤 DATOS DEL USUARIO:
        • Nombre: {datos_reserva['usuario_nombre']}
        • Email: {datos_reserva['usuario_email']}
        
        📅 Fecha de reserva: {datos_reserva['fecha']}
        
        {'⚠️ PEDIDO ESPECIAL - Requiere contacto directo' if es_pedido_especial else '✅ Reserva dentro del límite permitido'}
        {'Este pedido excede las ' + str(limite) + ' unidades. Por favor contactar al cliente.' if es_pedido_especial else ''}
        
        ---
        Sistema de Gestión de Camillas Médicas - INDUSTRIA & SALUD
        Enviado automáticamente desde el sistema de reservas
        """
        
        msg.set_content(cuerpo)
        
        with smtplib.SMTP("smtp.gmail.com", 587) as server:
            server.starttls()
            server.login(EMAIL_SENDER, EMAIL_PASSWORD)
            server.send_message(msg)
        
        return True, "Notificación enviada"
    except Exception as e:
        print(f"Error al enviar correo: {e}")
        return False, str(e)

# ===== RUTAS PRINCIPALES =====

@app.route('/')
def index():
    """Página principal - lista de camillas"""
    conn = get_db_connection()
    if not conn:
        return render_template('index.html', camillas=[], limite=4, error="Error de conexión a la base de datos")
    
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT * FROM camillas ORDER BY FIELD(categoria, 'Examen', 'Sillón', 'Carrito', 'Biombo', 'Gradilla'), nombre")
        camillas = cursor.fetchall()
        for c in camillas:
            if 'precio_base' in c:
                c['precio'] = float(c['precio_base'])
            else:
                c['precio'] = 0.0
    except Exception as e:
        print(f"Error al cargar camillas: {e}")
        camillas = []
    finally:
        cursor.close()
        conn.close()
    
    limite = get_limite_reserva()
    return render_template('index.html', camillas=camillas, limite=limite)

@app.route('/login', methods=['GET', 'POST'])
def login():
    """Inicio de sesión"""
    if request.method == 'POST':
        email = request.form['email']
        password = request.form['password']
        
        conn = get_db_connection()
        if not conn:
            return render_template('login.html', error="Error de conexión a la base de datos")
        
        cursor = conn.cursor(dictionary=True)
        try:
            cursor.execute("SELECT * FROM usuarios WHERE email = %s AND password = %s", (email, password))
            usuario = cursor.fetchone()
        except Exception as e:
            print(f"Error en login: {e}")
            usuario = None
        finally:
            cursor.close()
            conn.close()
        
        if usuario:
            session['usuario_id'] = usuario['id']
            session['usuario_nombre'] = usuario['nombre']
            session['usuario_email'] = usuario['email']
            session['rol'] = usuario['rol']
            
            if usuario['rol'] == 'admin':
                return redirect(url_for('admin_dashboard'))
            else:
                return redirect(url_for('index'))
        else:
            return render_template('login.html', error="Credenciales incorrectas")
    
    return render_template('login.html')

@app.route('/registro', methods=['POST'])
def registro():
    """Registro de nuevos usuarios"""
    try:
        data = request.json
        nombre = data.get('nombre', '').strip()
        email = data.get('email', '').strip().lower()
        password = data.get('password', '')
        
        if not nombre or len(nombre) < 3:
            return jsonify({'success': False, 'message': 'El nombre debe tener al menos 3 caracteres'})
        
        if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
            return jsonify({'success': False, 'message': 'Correo electrónico inválido'})
        
        if len(password) < 6:
            return jsonify({'success': False, 'message': 'La contraseña debe tener al menos 6 caracteres'})
        
        conn = get_db_connection()
        if not conn:
            return jsonify({'success': False, 'message': 'Error de conexión a la base de datos'})
        
        cursor = conn.cursor(dictionary=True)
        
        cursor.execute("SELECT id FROM usuarios WHERE email = %s", (email,))
        existe = cursor.fetchone()
        
        if existe:
            cursor.close()
            conn.close()
            return jsonify({'success': False, 'message': 'El email ya está registrado'})
        
        cursor.execute("""
            INSERT INTO usuarios (nombre, email, password, rol)
            VALUES (%s, %s, %s, 'usuario')
        """, (nombre, email, password))
        conn.commit()
        
        cursor.close()
        conn.close()
        
        return jsonify({'success': True, 'message': 'Usuario registrado exitosamente'})
        
    except Exception as e:
        print(f"Error en registro: {e}")
        return jsonify({'success': False, 'message': f'Error: {str(e)}'})

@app.route('/logout')
def logout():
    """Cerrar sesión"""
    session.clear()
    return redirect(url_for('index'))

@app.route('/reservar', methods=['POST'])
def reservar():
    """Procesar reserva de camilla"""
    if 'usuario_id' not in session:
        return jsonify({'success': False, 'message': 'Debes iniciar sesión para reservar'}), 401
    
    usuario_id = session.get('usuario_id')
    
    if not usuario_id:
        return jsonify({'success': False, 'message': 'Sesión inválida. Por favor, inicia sesión nuevamente.'}), 401
    
    data = request.json
    camilla_id = data.get('camilla_id')
    cantidad = int(data.get('cantidad', 1))
    
    limite = get_limite_reserva()
    
    if cantidad > limite:
        return jsonify({'success': False, 'message': f'No puedes reservar más de {limite} unidades. Contacta con ventas para pedidos mayores.'}), 400
    
    if cantidad < 1:
        return jsonify({'success': False, 'message': 'La cantidad debe ser al menos 1'}), 400
    
    conn = get_db_connection()
    if not conn:
        return jsonify({'success': False, 'message': 'Error de conexión a la base de datos'}), 500
    
    cursor = conn.cursor(dictionary=True)
    
    try:
        cursor.execute("SELECT id FROM usuarios WHERE id = %s", (usuario_id,))
        usuario_existe = cursor.fetchone()
        
        if not usuario_existe:
            session.clear()
            return jsonify({'success': False, 'message': 'Usuario no encontrado. Por favor, inicia sesión nuevamente.'}), 401
        
        cursor.execute("SELECT * FROM camillas WHERE id = %s", (camilla_id,))
        camilla = cursor.fetchone()
        
        if not camilla:
            return jsonify({'success': False, 'message': 'Producto no encontrado'}), 404
        
        if camilla['stock'] < cantidad:
            return jsonify({'success': False, 'message': f'Stock insuficiente. Disponible: {camilla["stock"]}'}), 400
        
        cursor.execute("""
            INSERT INTO reservas (usuario_id, camilla_id, cantidad, estado) 
            VALUES (%s, %s, %s, 'pendiente')
        """, (usuario_id, camilla_id, cantidad))
        
        # NO restamos stock aquí, se resta al entregar la reserva
        
        conn.commit()
        
        precio = float(camilla.get('precio_base', 0))
        datos_correo = {
            'camilla': camilla['nombre'],
            'cantidad': cantidad,
            'precio': precio,
            'total': precio * cantidad,
            'usuario_nombre': session.get('usuario_nombre', 'Usuario'),
            'usuario_email': session.get('usuario_email', ''),
            'fecha': datetime.now().strftime('%d/%m/%Y %H:%M:%S')
        }
        
        try:
            enviar_notificacion_reserva(datos_correo)
        except Exception as e:
            print(f"Error al enviar notificación: {e}")
        
        return jsonify({'success': True, 'message': 'Reserva realizada con éxito. Espera confirmación del administrador.'})
        
    except Exception as e:
        conn.rollback()
        print(f"Error en reserva: {e}")
        return jsonify({'success': False, 'message': f'Error al procesar reserva: {str(e)}'}), 500
    finally:
        cursor.close()
        conn.close()

# ===== RUTAS DE ADMIN =====

@app.route('/admin')
def admin_dashboard():
    """Panel de administración"""
    if 'rol' not in session or session['rol'] != 'admin':
        return redirect(url_for('login'))
    
    conn = get_db_connection()
    if not conn:
        return render_template('admin/dashboard.html', error="Error de conexión a BD")
    
    cursor = conn.cursor(dictionary=True)
    
    try:
        # Estadísticas principales
        cursor.execute("SELECT COUNT(*) as total FROM camillas")
        total_camillas = cursor.fetchone()
        
        cursor.execute("SELECT COUNT(*) as total FROM reservas")
        total_reservas = cursor.fetchone()
        
        cursor.execute("SELECT SUM(cantidad) as total FROM reservas")
        total_unidades = cursor.fetchone()
        
        cursor.execute("SELECT COUNT(*) as total FROM usuarios WHERE rol = 'usuario'")
        total_usuarios = cursor.fetchone()
        
        # Reservas recientes
        cursor.execute("""
            SELECT r.*, c.nombre as camilla_nombre, u.nombre as usuario_nombre 
            FROM reservas r
            JOIN camillas c ON r.camilla_id = c.id
            JOIN usuarios u ON r.usuario_id = u.id
            ORDER BY r.fecha_reserva DESC
            LIMIT 10
        """)
        reservas_recientes = cursor.fetchall()
        
        # Stock de todas las camillas
        cursor.execute("""
            SELECT id, nombre, stock 
            FROM camillas 
            ORDER BY 
                CASE 
                    WHEN stock = 0 THEN 1
                    WHEN stock <= 2 THEN 2
                    WHEN stock <= 5 THEN 3
                    ELSE 4
                END,
                stock ASC
        """)
        stock_camillas = cursor.fetchall()
        
        # Detectar stock bajo para alerta
        alerta_stock = []
        for item in stock_camillas:
            if item['stock'] <= 5:
                alerta_stock.append({
                    'nombre': item['nombre'],
                    'stock': item['stock']
                })
        
    except Exception as e:
        print(f"Error en admin_dashboard: {e}")
        total_camillas = {'total': 0}
        total_reservas = {'total': 0}
        total_unidades = {'total': 0}
        reservas_recientes = []
        total_usuarios = {'total': 0}
        stock_camillas = []
        alerta_stock = []
    finally:
        cursor.close()
        conn.close()
    
    return render_template('admin/dashboard.html', 
                         total_camillas=total_camillas['total'] if total_camillas else 0,
                         total_reservas=total_reservas['total'] if total_reservas else 0,
                         total_unidades=total_unidades['total'] if total_unidades and total_unidades['total'] else 0,
                         total_usuarios=total_usuarios['total'] if total_usuarios else 0,
                         reservas=reservas_recientes,
                         stock_camillas=stock_camillas,
                         alerta_stock=alerta_stock)

@app.route('/admin/reserva/<int:id>/estado', methods=['POST'])
def cambiar_estado_reserva(id):
    """Cambiar estado de una reserva (admin) - SOLO ENTREGADO Y CANCELADO"""
    if 'rol' not in session or session['rol'] != 'admin':
        return jsonify({'success': False, 'message': 'No autorizado'}), 401
    
    data = request.json
    nuevo_estado = data.get('estado')
    
    # SOLO PERMITIR ENTREGADO Y CANCELADO
    estados_validos = ['entregado', 'cancelada']
    if nuevo_estado not in estados_validos:
        return jsonify({'success': False, 'message': 'Estado inválido. Solo se permite entregar o cancelar.'}), 400
    
    conn = get_db_connection()
    if not conn:
        return jsonify({'success': False, 'message': 'Error de conexión a BD'}), 500
    
    cursor = conn.cursor()
    try:
        # Verificar que la reserva existe
        cursor.execute("SELECT id, estado, camilla_id, cantidad FROM reservas WHERE id = %s", (id,))
        reserva = cursor.fetchone()
        
        if not reserva:
            return jsonify({'success': False, 'message': 'Reserva no encontrada'}), 404
        
        estado_actual = reserva[1]
        camilla_id = reserva[2]
        cantidad = reserva[3]
        
        # Si se cancela, devolver stock SOLO si estaba confirmada
        if nuevo_estado == 'cancelada' and estado_actual == 'confirmada':
            cursor.execute("UPDATE camillas SET stock = stock + %s WHERE id = %s", 
                         (cantidad, camilla_id))
        
        # Si se entrega una reserva pendiente, restar stock
        if nuevo_estado == 'entregado' and estado_actual == 'pendiente':
            cursor.execute("UPDATE camillas SET stock = stock - %s WHERE id = %s AND stock >= %s", 
                         (cantidad, camilla_id, cantidad))
            if cursor.rowcount == 0:
                return jsonify({'success': False, 'message': 'Stock insuficiente para entregar'}), 400
        
        # Si se entrega una reserva confirmada (no afecta stock porque ya se descontó)
        # Si se entrega una reserva cancelada (no debería pasar)
        
        # Actualizar estado
        cursor.execute("UPDATE reservas SET estado = %s WHERE id = %s", (nuevo_estado, id))
        conn.commit()
        
        mensaje = f'Reserva #{id} {"entregada" if nuevo_estado == "entregado" else "cancelada"} exitosamente'
        return jsonify({'success': True, 'message': mensaje})
        
    except Exception as e:
        conn.rollback()
        print(f"Error al cambiar estado: {e}")
        return jsonify({'success': False, 'message': f'Error: {str(e)}'}), 500
    finally:
        cursor.close()
        conn.close()

@app.route('/admin/agregar_camilla', methods=['GET', 'POST'])
def agregar_camilla():
    """Agregar nueva camilla"""
    if 'rol' not in session or session['rol'] != 'admin':
        return redirect(url_for('login'))
    
    if request.method == 'POST':
        # Procesar imagen
        imagen_url = ''
        if 'imagen' in request.files:
            file = request.files['imagen']
            if file and allowed_file(file.filename):
                filename = secure_filename(file.filename)
                # Añadir timestamp para evitar duplicados
                name, ext = os.path.splitext(filename)
                filename = f"{name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}{ext}"
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                imagen_url = f"/static/uploads/{filename}"
        
        # Si no se subió imagen, usar la URL proporcionada
        if not imagen_url and request.form.get('imagen_url'):
            imagen_url = request.form.get('imagen_url')
        
        codigo = request.form.get('codigo', '')
        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        categoria = request.form['categoria']
        precio_base = float(request.form['precio_base'])
        stock = int(request.form['stock'])
        caracteristicas = request.form.get('caracteristicas', '')
        opciones = request.form.get('opciones', '')
        
        largo_cm = int(request.form.get('largo_cm', 180))
        ancho_cm = int(request.form.get('ancho_cm', 60))
        alto_cm = int(request.form.get('alto_cm', 75))
        peso_max_kg = int(request.form.get('peso_max_kg', 300))
        espesor_mm = float(request.form.get('espesor_mm', 1.5))
        material = request.form.get('material', 'Estructura metálica reforzada')
        garantia_anios = int(request.form.get('garantia_anios', 1))
        
        conn = get_db_connection()
        if not conn:
            return render_template('admin/agregar.html', error="Error de conexión a BD")
        
        cursor = conn.cursor()
        try:
            cursor.execute("""
                INSERT INTO camillas (codigo, nombre, descripcion, categoria, precio_base, stock, 
                                    caracteristicas, opciones, imagen_url, largo_cm, ancho_cm, 
                                    alto_cm, peso_max_kg, espesor_mm, material, garantia_anios)
                VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
            """, (codigo, nombre, descripcion, categoria, precio_base, stock, 
                  caracteristicas, opciones, imagen_url, largo_cm, ancho_cm, 
                  alto_cm, peso_max_kg, espesor_mm, material, garantia_anios))
            conn.commit()
        except Exception as e:
            print(f"Error al agregar camilla: {e}")
            return render_template('admin/agregar.html', error=f"Error: {str(e)}")
        finally:
            cursor.close()
            conn.close()
        
        return redirect(url_for('admin_dashboard'))
    
    return render_template('admin/agregar.html')

@app.route('/admin/editar_camilla/<int:id>', methods=['GET', 'POST'])
def editar_camilla(id):
    """Editar camilla existente"""
    if 'rol' not in session or session['rol'] != 'admin':
        return redirect(url_for('login'))
    
    conn = get_db_connection()
    if not conn:
        return render_template('admin/editar.html', error="Error de conexión a BD")
    
    if request.method == 'POST':
        # Procesar nueva imagen si se subió
        nueva_imagen_url = ''
        if 'imagen' in request.files:
            file = request.files['imagen']
            if file and allowed_file(file.filename):
                filename = secure_filename(file.filename)
                name, ext = os.path.splitext(filename)
                filename = f"{name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}{ext}"
                file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
                nueva_imagen_url = f"/static/uploads/{filename}"
        
        codigo = request.form.get('codigo', '')
        nombre = request.form['nombre']
        descripcion = request.form['descripcion']
        categoria = request.form['categoria']
        precio_base = float(request.form['precio_base'])
        stock = int(request.form['stock'])
        caracteristicas = request.form.get('caracteristicas', '')
        opciones = request.form.get('opciones', '')
        imagen_url = nueva_imagen_url if nueva_imagen_url else request.form.get('imagen_actual', '')
        
        largo_cm = int(request.form.get('largo_cm', 180))
        ancho_cm = int(request.form.get('ancho_cm', 60))
        alto_cm = int(request.form.get('alto_cm', 75))
        peso_max_kg = int(request.form.get('peso_max_kg', 300))
        espesor_mm = float(request.form.get('espesor_mm', 1.5))
        material = request.form.get('material', 'Estructura metálica reforzada')
        garantia_anios = int(request.form.get('garantia_anios', 1))
        
        cursor = conn.cursor()
        try:
            cursor.execute("""
                UPDATE camillas SET 
                    codigo = %s, nombre = %s, descripcion = %s, categoria = %s, 
                    precio_base = %s, stock = %s, caracteristicas = %s, opciones = %s,
                    imagen_url = %s, largo_cm = %s, ancho_cm = %s, alto_cm = %s,
                    peso_max_kg = %s, espesor_mm = %s, material = %s, garantia_anios = %s
                WHERE id = %s
            """, (codigo, nombre, descripcion, categoria, precio_base, stock, 
                  caracteristicas, opciones, imagen_url, largo_cm, ancho_cm, 
                  alto_cm, peso_max_kg, espesor_mm, material, garantia_anios, id))
            conn.commit()
        except Exception as e:
            print(f"Error al editar camilla: {e}")
            return render_template('admin/editar.html', error=f"Error: {str(e)}", camilla=request.form)
        finally:
            cursor.close()
            conn.close()
        
        return redirect(url_for('admin_dashboard'))
    
    # GET - Mostrar formulario con datos actuales
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT * FROM camillas WHERE id = %s", (id,))
        camilla = cursor.fetchone()
        if not camilla:
            return redirect(url_for('admin_dashboard'))
    except Exception as e:
        print(f"Error: {e}")
        return redirect(url_for('admin_dashboard'))
    finally:
        cursor.close()
        conn.close()
    
    return render_template('admin/editar.html', camilla=camilla)

@app.route('/admin/configurar', methods=['GET', 'POST'])
def configurar():
    """Configurar email destino y límites"""
    if 'rol' not in session or session['rol'] != 'admin':
        return redirect(url_for('login'))
    
    if request.method == 'POST':
        email_destino = request.form.get('email_destino', '')
        limite_reserva = request.form.get('limite_reserva', '4')
        
        conn = get_db_connection()
        if not conn:
            return jsonify({'success': False, 'message': 'Error de conexión a BD'})
        
        cursor = conn.cursor()
        try:
            cursor.execute("SELECT * FROM configuraciones WHERE clave = 'email_destino'")
            if cursor.fetchone():
                cursor.execute("UPDATE configuraciones SET valor = %s WHERE clave = 'email_destino'", (email_destino,))
            else:
                cursor.execute("INSERT INTO configuraciones (clave, valor) VALUES ('email_destino', %s)", (email_destino,))
            
            cursor.execute("SELECT * FROM configuraciones WHERE clave = 'limite_reserva'")
            if cursor.fetchone():
                cursor.execute("UPDATE configuraciones SET valor = %s WHERE clave = 'limite_reserva'", (limite_reserva,))
            else:
                cursor.execute("INSERT INTO configuraciones (clave, valor) VALUES ('limite_reserva', %s)", (limite_reserva,))
            
            conn.commit()
            return jsonify({'success': True, 'message': 'Configuración actualizada correctamente'})
        except Exception as e:
            conn.rollback()
            return jsonify({'success': False, 'message': f'Error: {str(e)}'})
        finally:
            cursor.close()
            conn.close()
    
    conn = get_db_connection()
    email_destino = 'torrijorge736@gmail.com'
    limite = '4'
    
    if conn:
        cursor = conn.cursor(dictionary=True)
        try:
            cursor.execute("SELECT clave, valor FROM configuraciones")
            configs = {row['clave']: row['valor'] for row in cursor.fetchall()}
            email_destino = configs.get('email_destino', 'torrijorge736@gmail.com')
            limite = configs.get('limite_reserva', '4')
        except:
            pass
        finally:
            cursor.close()
            conn.close()
    
    return render_template('admin/configurar.html', 
                         email_destino=email_destino,
                         limite=limite,
                         now=datetime.now().strftime('%d/%m/%Y %H:%M:%S'))

@app.route('/admin/lista_camillas')
def lista_camillas():
    """Lista todas las camillas para gestionar"""
    if 'rol' not in session or session['rol'] != 'admin':
        return redirect(url_for('login'))
    return render_template('admin/lista_camillas.html')

@app.route('/api/camillas')
def api_camillas():
    """API para obtener camillas (AJAX)"""
    conn = get_db_connection()
    if not conn:
        return jsonify([])
    
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT * FROM camillas ORDER BY fecha_agregado DESC")
        camillas = cursor.fetchall()
        for c in camillas:
            if 'precio_base' in c:
                c['precio'] = float(c['precio_base'])
        return jsonify(camillas)
    except Exception as e:
        print(f"Error en API: {e}")
        return jsonify([])
    finally:
        cursor.close()
        conn.close()

@app.route('/api/camilla/<int:id>')
def api_camilla(id):
    """API para obtener detalle de una camilla específica"""
    conn = get_db_connection()
    if not conn:
        return jsonify({'error': 'Error de conexión a la base de datos'}), 500
    
    cursor = conn.cursor(dictionary=True)
    try:
        cursor.execute("SELECT * FROM camillas WHERE id = %s", (id,))
        camilla = cursor.fetchone()
        
        if not camilla:
            return jsonify({'error': 'Camilla no encontrada'}), 404
        
        # Convertir Decimal a float para JSON
        if 'precio_base' in camilla:
            camilla['precio_base'] = float(camilla['precio_base'])
        
        # Formatear fecha
        if 'fecha_agregado' in camilla and camilla['fecha_agregado']:
            camilla['fecha_agregado'] = camilla['fecha_agregado'].strftime('%Y-%m-%d %H:%M:%S')
        
        return jsonify(camilla)
    except Exception as e:
        print(f"Error en API camilla: {e}")
        return jsonify({'error': str(e)}), 500
    finally:
        cursor.close()
        conn.close()

@app.route('/admin/eliminar_camilla/<int:id>', methods=['DELETE'])
def eliminar_camilla(id):
    """Eliminar una camilla (solo admin)"""
    if 'rol' not in session or session['rol'] != 'admin':
        return jsonify({'success': False, 'message': 'No autorizado'}), 401
    
    conn = get_db_connection()
    if not conn:
        return jsonify({'success': False, 'message': 'Error de conexión'})
    
    cursor = conn.cursor()
    try:
        cursor.execute("SELECT COUNT(*) as total FROM reservas WHERE camilla_id = %s", (id,))
        tiene_reservas = cursor.fetchone()
        if tiene_reservas and tiene_reservas[0] > 0:
            return jsonify({'success': False, 'message': 'No se puede eliminar porque tiene reservas asociadas'})
        
        cursor.execute("DELETE FROM camillas WHERE id = %s", (id,))
        conn.commit()
        return jsonify({'success': True, 'message': 'Camilla eliminada correctamente'})
    except Exception as e:
        conn.rollback()
        return jsonify({'success': False, 'message': f'Error: {str(e)}'})
    finally:
        cursor.close()
        conn.close()

# ===== INICIALIZACIÓN =====
if __name__ == '__main__':
    print("=" * 50)
    print("🚀 Sistema de Gestión de Camillas iniciado!")
    print("📱 Abre: http://localhost:5000")
    print("👑 Admin - Email: admin@sistema.com | Contraseña: admin123")
    print("👤 Usuario - Email: usuario@test.com | Contraseña: usuario123")
    print("💰 Moneda: Bolivianos (Bs.)")
    print("=" * 50)
    print("⚠️  Asegúrate de tener:")
    print("   1. MySQL ejecutándose")
    print("   2. La base de datos 'sistema_camillas' creada")
    print("   3. Ejecutado el script SQL completo")
    print("=" * 50)
    app.run(debug=True, host='0.0.0.0', port=5000)