// src/routes/agenda.routes.js
const express = require('express');
const router = express.Router();

const pool = require('../config/db');
const handleValidation = require('../middleware/handleValidation');

const {
  createAgendaValidator,
  updateAgendaValidator,
  agendaIdValidator,
  listAgendaValidator,
  startAgendaValidator,
  finishAgendaValidator,
  ESTADOS, // ['pendiente','realizada','omitida','reprogramada']
} = require('../validators/agenda.validators');

// 👇 nombre exacto de tu tabla de registros
const REG_TABLE = 'registro_actividad';

// LISTAR agendas
router.get('/', listAgendaValidator, handleValidation, async (req, res) => {
  const { user_id, estado, desde, hasta } = req.query;

  let sql = `
    SELECT id_agenda, id_usuario, id_actividad, fecha_programada, estado
      FROM agenda_actividades
     WHERE 1=1`;
  const params = [];

  if (user_id) { sql += ' AND id_usuario = ?'; params.push(Number(user_id)); }
  if (estado)  { sql += ' AND estado = ?'; params.push(estado); }
  if (desde)   { sql += ' AND fecha_programada >= ?'; params.push(desde); }
  if (hasta)   { sql += ' AND fecha_programada <= ?'; params.push(hasta); }

  sql += ' ORDER BY fecha_programada ASC';

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

// DETALLE
router.get('/:id', agendaIdValidator, handleValidation, async (req, res) => {
  try {
    const [rows] = await pool.query(
      'SELECT * FROM agenda_actividades WHERE id_agenda = ?',
      [req.params.id]
    );
    if (!rows.length) return res.status(404).json({ error: 'Agenda no encontrada' });
    res.json(rows[0]);
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al obtener agenda' });
  }
});

// CREAR  (si no envías "estado", la BD usa DEFAULT 'pendiente')
router.post('/', createAgendaValidator, handleValidation, async (req, res) => {
  const { id_usuario, id_actividad, fecha_programada, estado } = req.body;

  try {
    let sql, params;
    if (estado) {
      sql = `INSERT INTO agenda_actividades (id_usuario, id_actividad, fecha_programada, estado)
             VALUES (?, ?, ?, ?)`;
      params = [id_usuario, id_actividad, fecha_programada, estado]; // 'pendiente' | 'realizada' | 'omitida' | 'reprogramada'
    } else {
      sql = `INSERT INTO agenda_actividades (id_usuario, id_actividad, fecha_programada)
             VALUES (?, ?, ?)`;
      params = [id_usuario, id_actividad, fecha_programada];
    }

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

// ACTUALIZAR
router.put('/:id', updateAgendaValidator, handleValidation, async (req, res) => {
  const { id } = req.params;
  const {
    id_usuario = null, id_actividad = null,
    fecha_programada = null, estado = null
  } = req.body;

  try {
    const [result] = await pool.query(
      `UPDATE agenda_actividades
          SET id_usuario = COALESCE(?, id_usuario),
              id_actividad = COALESCE(?, id_actividad),
              fecha_programada = COALESCE(?, fecha_programada),
              estado = COALESCE(?, estado)
        WHERE id_agenda = ?`,
      [id_usuario, id_actividad, fecha_programada, estado, id]
    );
    if (result.affectedRows === 0) return res.status(404).json({ error: 'Agenda no encontrada' });
    res.json({ message: 'Agenda actualizada' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al actualizar agenda' });
  }
});

// ELIMINAR
router.delete('/:id', agendaIdValidator, handleValidation, async (req, res) => {
  try {
    const [result] = await pool.query('DELETE FROM agenda_actividades WHERE id_agenda = ?', [req.params.id]);
    if (result.affectedRows === 0) return res.status(404).json({ error: 'Agenda no encontrada' });
    res.json({ message: 'Agenda eliminada' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al eliminar agenda' });
  }
});

/**
 * INICIAR desde agenda:
 *  - Crea un registro en registro_actividad (fecha_inicio = NOW(), completada=0)
 *  - NO cambiamos estado (tu ENUM no tiene "iniciada"). Se mantiene 'pendiente'
 *  - Devuelve registro_id para luego llamar /api/agenda/:id/finish
 */
router.patch('/:id/start', startAgendaValidator, handleValidation, async (req, res) => {
  const idAgenda = Number(req.params.id);

  try {
    const [agRows] = await pool.query(
      'SELECT id_agenda, id_usuario, id_actividad, estado FROM agenda_actividades WHERE id_agenda = ?',
      [idAgenda]
    );
    if (!agRows.length) return res.status(404).json({ error: 'Agenda no encontrada' });

    const agenda = agRows[0];
    // Bloquea si ya se marcó como realizada u omitida
    if (agenda.estado === 'omitida' || agenda.estado === 'realizada') {
      return res.status(400).json({ error: `La agenda está en estado ${agenda.estado}` });
    }

    // Crear registro
    const [insReg] = await pool.query(
      `INSERT INTO ${REG_TABLE} (id_usuario, id_actividad, fecha_inicio, completada)
       VALUES (?, ?, NOW(), 0)`,
      [agenda.id_usuario, agenda.id_actividad]
    );

    res.json({
      message: 'Actividad iniciada desde agenda',
      registro_id: insReg.insertId,
    });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al iniciar desde agenda' });
  }
});

/**
 * FINALIZAR (vía agenda):
 *  - Cierra el registro (fecha_fin = NOW())
 *  - Guarda emoción, puntos y comentario si vienen
 *  - Marca la agenda como 'realizada'
 */
router.patch('/:id/finish', finishAgendaValidator, handleValidation, async (req, res) => {
  const idAgenda = Number(req.params.id);
  const { registro_id, emocion = null, puntos_obtenidos = null, comentario = null } = req.body;

  try {
    await pool.query(
      `UPDATE ${REG_TABLE}
          SET fecha_fin = COALESCE(fecha_fin, NOW()),
              emocion = COALESCE(?, emocion),
              puntos_obtenidos = COALESCE(?, puntos_obtenidos),
              comentario = COALESCE(?, comentario),
              completada = 1
        WHERE id_registro = ?`,
      [emocion, puntos_obtenidos, comentario, registro_id]
    );

    await pool.query(
      'UPDATE agenda_actividades SET estado = ? WHERE id_agenda = ?',
      ['realizada', idAgenda]
    );

    res.json({ message: 'Actividad finalizada; agenda marcada como realizada' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al finalizar desde agenda' });
  }
});

/**
 * REPROGRAMAR: cambia la fecha y marca 'reprogramada'
 */
router.patch('/:id/reprogramar', agendaIdValidator, handleValidation, async (req, res) => {
  const { fecha_programada } = req.body;
  if (!fecha_programada) return res.status(400).json({ error: 'fecha_programada requerida' });

  try {
    const [r] = await pool.query(
      `UPDATE agenda_actividades
         SET fecha_programada = ?, estado = 'reprogramada'
       WHERE id_agenda = ?`,
      [fecha_programada, req.params.id]
    );
    if (r.affectedRows === 0) return res.status(404).json({ error: 'Agenda no encontrada' });
    res.json({ message: 'Agenda reprogramada' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al reprogramar agenda' });
  }
});

/**
 * OMITIR: marca la agenda como 'omitida'
 */
router.patch('/:id/omitir', agendaIdValidator, handleValidation, async (req, res) => {
  try {
    const [r] = await pool.query(
      'UPDATE agenda_actividades SET estado = ? WHERE id_agenda = ?',
      ['omitida', req.params.id]
    );
    if (r.affectedRows === 0) return res.status(404).json({ error: 'Agenda no encontrada' });
    res.json({ message: 'Agenda marcada como omitida' });
  } catch (e) {
    console.error(e);
    res.status(500).json({ error: 'Error al omitir agenda' });
  }
});

module.exports = router;