// src/routes/registroActividad.routes.js
const express = require('express');
const router = express.Router();
const pool = require('../config/db');
const handleValidation = require('../middleware/handleValidation');
const { requireAuth } = require('../utils/jwt'); // ✅ Importa el middleware

const {
  createRegistroValidator,
  updateRegistroValidator,
  registroIdValidator,
  listRegistrosValidator,
  finishRegistroValidator,
} = require('../validators/registroActividad.validators');

/* ==========================================
   POST /api/registroactividad/start
   Body: { id_actividad:number }
   Crea un registro con fecha_inicio = NOW()
   y completada = 0 para el usuario autenticado
   ➜ Bloquea si ya está 'realizada' para ese usuario
   ========================================== */
router.post('/start', requireAuth, async (req, res) => {
  try {
    const { id_usuario } = req.user;
    const { id_actividad } = req.body;

    if (!id_actividad) {
      return res.status(400).json({ error: 'Falta id_actividad' });
    }

    // Bloquear si ya fue realizada por este usuario (tabla de estado)
    const [done] = await pool.query(
      `SELECT 1
         FROM usuario_actividad_estado
        WHERE id_usuario = ? AND id_actividad = ? AND estado = 'realizada'
        LIMIT 1`,
      [id_usuario, id_actividad]
    );
    if (done.length) {
      return res.status(409).json({ error: 'Esta actividad ya fue realizada por el usuario' });
    }

    const [result] = await pool.query(
      `INSERT INTO registro_actividad
         (id_usuario, id_actividad, fecha_inicio, completada)
       VALUES (?, ?, NOW(), 0)`,
      [id_usuario, id_actividad]
    );

    return res.status(201).json({ ok: true, id_registro: result.insertId });
  } catch (e) {
    console.error('POST /registroactividad/start', e);
    return res.status(500).json({ error: 'Error al iniciar registro' });
  }
});

/* ===========================================================
   PATCH /api/registroactividad/finish/:id
   Body opcional: { emocion?, puntos_obtenidos?, comentario? }
   Marca fecha_fin = NOW() (si estaba null) y completada = 1.
   Valida que el registro pertenezca al usuario del token.
   ➜ Además, hace UPSERT en usuario_actividad_estado a 'realizada'
   =========================================================== */
router.patch(
  '/finish/:id',
  requireAuth,
  finishRegistroValidator,
  handleValidation,
  async (req, res) => {
    try {
      const { id_usuario } = req.user;
      const { id } = req.params;
      const {
        emocion = null,
        puntos_obtenidos = null,
        comentario = null,
      } = req.body || {};

      // Actualiza el registro (solo del usuario autenticado)
      const [r] = await pool.query(
        `UPDATE registro_actividad
            SET fecha_fin = COALESCE(fecha_fin, NOW()),
                emocion = COALESCE(?, emocion),
                puntos_obtenidos = COALESCE(?, puntos_obtenidos),
                comentario = COALESCE(?, comentario),
                completada = 1
          WHERE id_registro = ? AND id_usuario = ?`,
        [emocion, puntos_obtenidos, comentario, id, id_usuario]
      );

      if (r.affectedRows === 0) {
        return res.status(404).json({ error: 'Registro no encontrado' });
      }

      // Obtener la actividad de ese registro para marcar estado global del usuario
      const [[reg]] = await pool.query(
        `SELECT id_actividad
           FROM registro_actividad
          WHERE id_registro = ? AND id_usuario = ?`,
        [id, id_usuario]
      );
      if (!reg) {
        return res.status(404).json({ error: 'Registro no encontrado' });
      }

      // UPSERT en usuario_actividad_estado ➜ realizada
      await pool.query(
        `INSERT INTO usuario_actividad_estado (id_usuario, id_actividad, estado, fecha_realizada)
         VALUES (?, ?, 'realizada', NOW())
         ON DUPLICATE KEY UPDATE
           estado = 'realizada',
           fecha_realizada = COALESCE(usuario_actividad_estado.fecha_realizada, NOW())`,
        [id_usuario, reg.id_actividad]
      );

      return res.json({ ok: true });
    } catch (e) {
      console.error('PATCH /registroactividad/finish/:id', e);
      return res.status(500).json({ error: 'Error al finalizar registro' });
    }
  }
);

/* =====================================================
   GET /api/registroactividad
   Con filtros (?user_id, actividad_id, completada, desde, hasta)
   ===================================================== */
router.get('/', listRegistrosValidator, handleValidation, async (req, res) => {
  const { user_id, actividad_id, completada, desde, hasta } = req.query;

  let sql = `
    SELECT id_registro, id_usuario, id_actividad, fecha_inicio, fecha_fin,
           emocion, completada, puntos_obtenidos, comentario
      FROM registro_actividad
     WHERE 1=1`;
  const params = [];

  if (user_id)       { sql += ' AND id_usuario = ?'; params.push(Number(user_id)); }
  if (actividad_id)  { sql += ' AND id_actividad = ?'; params.push(Number(actividad_id)); }
  if (completada !== undefined) { sql += ' AND completada = ?'; params.push(Number(completada)); }
  if (desde)         { sql += ' AND fecha_inicio >= ?'; params.push(desde); }
  if (hasta)         { sql += ' AND fecha_inicio <= ?'; params.push(hasta); }

  sql += ' ORDER BY id_registro DESC';

  try {
    const [rows] = await pool.query(sql, params);
    res.json(rows);
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al listar registros' });
  }
});

/* ===============================
   GET /api/registroactividad/:id
   =============================== */
router.get('/:id', registroIdValidator, handleValidation, async (req, res) => {
  try {
    const [rows] = await pool.query(
      'SELECT * FROM registro_actividad WHERE id_registro = ?',
      [req.params.id]
    );
    if (!rows.length) return res.status(404).json({ error: 'Registro no encontrado' });
    res.json(rows[0]);
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al obtener registro' });
  }
});

/* ==========================================================
   POST /api/registroactividad (genérico)
   Si no envías fecha_inicio, se inserta sin ese campo.
   ========================================================== */
router.post('/', createRegistroValidator, handleValidation, async (req, res) => {
  const {
    id_usuario, id_actividad, fecha_inicio = null,
    emocion = null, completada = 0, puntos_obtenidos = 0, comentario = null
  } = req.body;

  try {
    let sql, params;
    if (fecha_inicio) {
      sql = `
        INSERT INTO registro_actividad
          (id_usuario, id_actividad, fecha_inicio, emocion, completada, puntos_obtenidos, comentario)
        VALUES (?, ?, ?, ?, ?, ?, ?)`;
      params = [id_usuario, id_actividad, fecha_inicio, emocion, completada, puntos_obtenidos, comentario];
    } else {
      sql = `
        INSERT INTO registro_actividad
          (id_usuario, id_actividad, emocion, completada, puntos_obtenidos, comentario)
        VALUES (?, ?, ?, ?, ?, ?)`;
      params = [id_usuario, id_actividad, emocion, completada, puntos_obtenidos, comentario];
    }

    const [ins] = await pool.query(sql, params);
    res.status(201).json({ message: 'Registro creado', id: ins.insertId });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al crear registro' });
  }
});

/* ===================================
   PUT /api/registroactividad/:id
   Actualización parcial
   =================================== */
router.put('/:id', updateRegistroValidator, handleValidation, async (req, res) => {
  const { id } = req.params;
  const {
    id_usuario = null, id_actividad = null,
    fecha_inicio = null, fecha_fin = null,
    emocion = null, completada = null, puntos_obtenidos = null, comentario = null,
  } = req.body;

  try {
    const [r] = await pool.query(
      `UPDATE registro_actividad
          SET id_usuario = COALESCE(?, id_usuario),
              id_actividad = COALESCE(?, id_actividad),
              fecha_inicio = COALESCE(?, fecha_inicio),
              fecha_fin = COALESCE(?, fecha_fin),
              emocion = COALESCE(?, emocion),
              completada = COALESCE(?, completada),
              puntos_obtenidos = COALESCE(?, puntos_obtenidos),
              comentario = COALESCE(?, comentario)
        WHERE id_registro = ?`,
      [id_usuario, id_actividad, fecha_inicio, fecha_fin, emocion, completada, puntos_obtenidos, comentario, id]
    );
    if (r.affectedRows === 0) return res.status(404).json({ error: 'Registro no encontrado' });
    res.json({ message: 'Registro actualizado' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al actualizar registro' });
  }
});

/* ================================
   DELETE /api/registroactividad/:id
   ================================ */
router.delete('/:id', registroIdValidator, handleValidation, async (req, res) => {
  try {
    const [r] = await pool.query('DELETE FROM registro_actividad WHERE id_registro = ?', [req.params.id]);
    if (r.affectedRows === 0) return res.status(404).json({ error: 'Registro no encontrado' });
    res.json({ message: 'Registro eliminado' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al eliminar registro' });
  }
});

module.exports = router;