import express from 'express';
import {pool} from '../lib/database.js'; // Ajusta según tu configuración

const router = express.Router();

// Crear o obtener conversación entre dos usuarios
router.post('/conversation/get-or-create', async (req, res) => {
  const { usuario1Id, usuario2Id } = req.body;

  if (!usuario1Id || !usuario2Id) {
    return res.status(400).json({ error: 'Se requieren ambos IDs de usuarios' });
  }

  const client = await pool.connect();

  try {
    await client.query('BEGIN');

    // Verificar si ya existe una conversación entre estos dos usuarios (en cualquier orden)
    const existingConv = await client.query(
    `SELECT c.id_conversacion 
    FROM conversaciones c
    JOIN conversacion_participantes cp1 ON c.id_conversacion = cp1.id_conversacion
    JOIN conversacion_participantes cp2 ON c.id_conversacion = cp2.id_conversacion
    WHERE (cp1.id_usuario = $1 AND cp2.id_usuario = $2)
        OR (cp1.id_usuario = $2 AND cp2.id_usuario = $1)
    LIMIT 1`,
    [usuario1Id, usuario2Id]
    );


    let conversacionId;

    if (existingConv.rows.length > 0) {
      conversacionId = existingConv.rows[0].id_conversacion;
    } else {
      // Crear nueva conversación
      const convResult = await client.query(
        'INSERT INTO conversaciones DEFAULT VALUES RETURNING id_conversacion'
      );
      conversacionId = convResult.rows[0].id_conversacion;

      // Agregar participantes
      await client.query(
        `INSERT INTO conversacion_participantes (id_conversacion, id_usuario)
        VALUES ($1, $2), ($1, $3)
        ON CONFLICT DO NOTHING`,
        [conversacionId, usuario1Id, usuario2Id]
    );

    }

    await client.query('COMMIT');

    res.json({ conversacionId });

  } catch (error) {
    await client.query('ROLLBACK');
    console.error('Error al crear/obtener conversación:', error);
    res.status(500).json({ error: 'Error al crear conversación' });
  } finally {
    client.release();
  }
});

// Obtener conversaciones de un usuario con info del otro participante
router.get('/conversations/:userId', async (req, res) => {
  const { userId } = req.params;

  try {
    const result = await pool.query(
      `SELECT DISTINCT 
        c.id_conversacion, 
        c.fecha_creacion, 
        c.ultima_actualizacion,
        u.id_usuario as otro_usuario_id,
        u.nombre as otro_usuario_nombre,
        u.apellido_pa as otro_usuario_apellido,
        (SELECT contenido FROM mensajes 
         WHERE id_conversacion = c.id_conversacion 
         ORDER BY fecha_envio DESC LIMIT 1) as ultimo_mensaje,
        (SELECT fecha_envio FROM mensajes 
         WHERE id_conversacion = c.id_conversacion 
         ORDER BY fecha_envio DESC LIMIT 1) as fecha_ultimo_mensaje,
        (SELECT COUNT(*) FROM mensajes 
         WHERE id_conversacion = c.id_conversacion 
         AND leido = FALSE 
         AND id_remitente != $1) as mensajes_no_leidos
       FROM conversaciones c
       JOIN conversacion_participantes cp1 ON c.id_conversacion = cp1.id_conversacion
       JOIN conversacion_participantes cp2 ON c.id_conversacion = cp2.id_conversacion
       JOIN usuarios u ON cp2.id_usuario = u.id_usuario
       WHERE cp1.id_usuario = $1 AND cp2.id_usuario != $1
       ORDER BY c.ultima_actualizacion DESC`,
      [userId]
    );

    res.json(result.rows);

  } catch (error) {
    console.error('Error al obtener conversaciones:', error);
    res.status(500).json({ error: 'Error al obtener conversaciones' });
  }
});

// Obtener mensajes de una conversación
router.get('/messages/:conversacionId', async (req, res) => {
  const conversacionId = parseInt(req.params.conversacionId, 10);
  const limit = parseInt(req.query.limit ?? 50, 10);
  const offset = parseInt(req.query.offset ?? 0, 10);

  if (isNaN(conversacionId)) {
    return res.status(400).json({ error: 'ID de conversación inválido' });
  }

  try {
    const result = await pool.query(
      `SELECT m.*, u.nombre, u.apellido_pa, u.apellido_ma
       FROM mensajes m
       JOIN usuarios u ON m.id_remitente = u.id_usuario
       WHERE m.id_conversacion = $1
       ORDER BY m.fecha_envio ASC
       LIMIT $2 OFFSET $3`,
      [conversacionId, limit, offset]
    );

    res.json(result.rows);

  } catch (error) {
    console.error('Error al obtener mensajes:', error);
    res.status(500).json({ error: 'Error al obtener mensajes' });
  }
});

// Marcar mensajes como leídos
router.put('/messages/read/:conversacionId/:userId', async (req, res) => {
  const conversacionId = parseInt(req.params.conversacionId, 10);
  const userId = parseInt(req.params.userId, 10);

  if (isNaN(conversacionId) || isNaN(userId)) {
    return res.status(400).json({ error: 'Parámetros inválidos' });
  }

  await pool.query(
    `UPDATE mensajes 
     SET leido = TRUE 
     WHERE id_conversacion = $1 
     AND id_remitente != $2 
     AND leido = FALSE`,
    [conversacionId, userId]
  );

  res.json({ mensaje: 'Mensajes marcados como leídos' });
});


// Eliminar conversación
router.delete('/conversations/:conversacionId', async (req, res) => {
  const { conversacionId } = req.params;

  try {
    await pool.query(
      'DELETE FROM conversaciones WHERE id_conversacion = $1',
      [conversacionId]
    );

    res.json({ mensaje: 'Conversación eliminada exitosamente' });

  } catch (error) {
    console.error('Error al eliminar conversación:', error);
    res.status(500).json({ error: 'Error al eliminar conversación' });
  }
});

export default router;