import { FastifyPluginAsync } from 'fastify'
import { db } from '../db'

type SlugParam = { Params: { slug: string } }
type RoomParam = { Params: { slug: string; roomId: string } }

const chatRoutes: FastifyPluginAsync = async (fastify) => {
  const getHotelId = async (slug: string) => {
    const { rows } = await db.query('SELECT id FROM hotels WHERE slug = $1', [slug])
    return rows[0]?.id as string | undefined
  }

  const canAccess = (userSlug: string | null, role: string, slug: string) =>
    role === 'super_admin' || userSlug === slug

  // Ensure general room exists for hotel
  const ensureGeneralRoom = async (hotelId: string) => {
    const { rows } = await db.query(
      `INSERT INTO chat_rooms (hotel_id, type, name)
       VALUES ($1, 'general', 'Общий чат')
       ON CONFLICT (hotel_id) WHERE type = 'general' DO NOTHING
       RETURNING id`,
      [hotelId],
    )
    if (rows[0]) return rows[0].id as string
    const { rows: existing } = await db.query(
      `SELECT id FROM chat_rooms WHERE hotel_id = $1 AND type = 'general'`,
      [hotelId],
    )
    return existing[0]?.id as string
  }

  // Ensure notifications room exists for hotel
  const ensureNotificationsRoom = async (hotelId: string) => {
    const { rows } = await db.query(
      `INSERT INTO chat_rooms (hotel_id, type, name)
       VALUES ($1, 'notifications', 'Уведомления')
       ON CONFLICT DO NOTHING
       RETURNING id`,
      [hotelId],
    )
    if (rows[0]) return rows[0].id as string
    const { rows: existing } = await db.query(
      `SELECT id FROM chat_rooms WHERE hotel_id = $1 AND type = 'notifications'`,
      [hotelId],
    )
    return existing[0]?.id as string
  }

  // GET /api/hotels/:slug/chat/rooms  — list rooms (general + notifications + directs for current user)
  fastify.get<SlugParam>(
    '/api/hotels/:slug/chat/rooms',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      await ensureGeneralRoom(hotelId)
      await ensureNotificationsRoom(hotelId)
      const userId = request.user.sub

      const { rows } = await db.query(
        `SELECT r.id, r.type, r.name,
                (SELECT COUNT(*) FROM chat_messages m
                  WHERE m.room_id = r.id
                    AND m.created_at > COALESCE(
                      (SELECT rs.last_read FROM chat_read_status rs WHERE rs.room_id = r.id AND rs.user_id = $2),
                      '1970-01-01'
                    )
                    AND (m.sender_id != $2 OR m.sender_id IS NULL)
                ) AS unread_count,
                (SELECT m.text FROM chat_messages m WHERE m.room_id = r.id ORDER BY m.created_at DESC LIMIT 1) AS last_message,
                (SELECT m.created_at FROM chat_messages m WHERE m.room_id = r.id ORDER BY m.created_at DESC LIMIT 1) AS last_message_at,
                (SELECT COALESCE(m.system_name, u.name) FROM chat_messages m LEFT JOIN users u ON u.id = m.sender_id WHERE m.room_id = r.id ORDER BY m.created_at DESC LIMIT 1) AS last_sender,
                -- for direct rooms: get the other user's name
                (SELECT u.name FROM chat_room_members crm JOIN users u ON u.id = crm.user_id WHERE crm.room_id = r.id AND crm.user_id != $2 LIMIT 1) AS other_user_name,
                (SELECT crm.user_id FROM chat_room_members crm WHERE crm.room_id = r.id AND crm.user_id != $2 LIMIT 1) AS other_user_id
           FROM chat_rooms r
          WHERE r.hotel_id = $1
            AND (r.type IN ('general', 'notifications') OR EXISTS (
              SELECT 1 FROM chat_room_members crm WHERE crm.room_id = r.id AND crm.user_id = $2
            ))
          ORDER BY last_message_at DESC NULLS LAST, r.type = 'general' DESC`,
        [hotelId, userId],
      )
      return rows
    },
  )

  // GET /api/hotels/:slug/chat/rooms/:roomId/messages
  fastify.get<RoomParam & { Querystring: { before?: string; limit?: string } }>(
    '/api/hotels/:slug/chat/rooms/:roomId/messages',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug, roomId } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      const limit = Math.min(Number(request.query.limit ?? 50), 100)
      const { rows } = await db.query(
        `SELECT m.id, m.room_id, m.sender_id, m.text, m.created_at,
                m.is_system, m.system_name,
                COALESCE(m.system_name, u.name) AS sender_name,
                COALESCE(u.role, 'system') AS sender_role
           FROM chat_messages m
           LEFT JOIN users u ON u.id = m.sender_id
          WHERE m.room_id = $1 AND m.hotel_id = $2
          ORDER BY m.created_at DESC
          LIMIT $3`,
        [roomId, hotelId, limit],
      )
      // Update read status
      await db.query(
        `INSERT INTO chat_read_status (room_id, user_id, last_read)
         VALUES ($1, $2, NOW())
         ON CONFLICT (room_id, user_id) DO UPDATE SET last_read = NOW()`,
        [roomId, request.user.sub],
      )
      return rows.reverse() // chronological order
    },
  )

  // POST /api/hotels/:slug/chat/rooms/:roomId/messages
  fastify.post<RoomParam & { Body: { text: string } }>(
    '/api/hotels/:slug/chat/rooms/:roomId/messages',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug, roomId } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      // Disallow posting to notifications room
      const { rows: roomRows } = await db.query('SELECT type FROM chat_rooms WHERE id = $1', [roomId])
      if (roomRows[0]?.type === 'notifications')
        return reply.code(403).send({ error: 'Cannot post to notifications room' })

      const { text } = request.body
      if (!text?.trim()) return reply.code(400).send({ error: 'Text required' })

      const { rows } = await db.query(
        `INSERT INTO chat_messages (room_id, hotel_id, sender_id, text)
         VALUES ($1, $2, $3, $4)
         RETURNING id, room_id, sender_id, text, created_at`,
        [roomId, hotelId, request.user.sub, text.trim()],
      )
      const msg = rows[0]
      const { rows: uRows } = await db.query('SELECT name, role FROM users WHERE id = $1', [request.user.sub])
      const result = { ...msg, sender_name: uRows[0]?.name, sender_role: uRows[0]?.role, is_system: false, system_name: null }
      return reply.code(201).send(result)
    },
  )

  // POST /api/hotels/:slug/chat/direct/:otherUserId  — create/get direct room
  fastify.post<{ Params: { slug: string; otherUserId: string } }>(
    '/api/hotels/:slug/chat/direct/:otherUserId',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug, otherUserId } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      const userId = request.user.sub
      const { rows: existing } = await db.query(
        `SELECT r.id FROM chat_rooms r
          JOIN chat_room_members m1 ON m1.room_id = r.id AND m1.user_id = $1
          JOIN chat_room_members m2 ON m2.room_id = r.id AND m2.user_id = $2
         WHERE r.hotel_id = $3 AND r.type = 'direct'
         LIMIT 1`,
        [userId, otherUserId, hotelId],
      )
      if (existing[0]) return { room_id: existing[0].id }

      const { rows: [room] } = await db.query(
        `INSERT INTO chat_rooms (hotel_id, type) VALUES ($1, 'direct') RETURNING id`,
        [hotelId],
      )
      await db.query(
        `INSERT INTO chat_room_members (room_id, user_id) VALUES ($1, $2), ($1, $3)`,
        [room.id, userId, otherUserId],
      )
      return reply.code(201).send({ room_id: room.id })
    },
  )

  // PATCH /api/hotels/:slug/chat/rooms/:roomId/read — mark as read
  fastify.patch<RoomParam>(
    '/api/hotels/:slug/chat/rooms/:roomId/read',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { roomId } = request.params
      await db.query(
        `INSERT INTO chat_read_status (room_id, user_id, last_read) VALUES ($1, $2, NOW())
         ON CONFLICT (room_id, user_id) DO UPDATE SET last_read = NOW()`,
        [roomId, request.user.sub],
      )
      return { ok: true }
    },
  )

  // GET /api/hotels/:slug/chat/search?q= — search messages across accessible rooms
  fastify.get<SlugParam & { Querystring: { q?: string } }>(
    '/api/hotels/:slug/chat/search',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      const q = (request.query.q ?? '').trim()
      if (!q) return []

      const userId = request.user.sub
      const { rows } = await db.query(
        `SELECT m.id, m.room_id, m.text, m.created_at,
                COALESCE(m.system_name, u.name) AS sender_name,
                r.type AS room_type, r.name AS room_name,
                (SELECT u2.name FROM chat_room_members crm2 JOIN users u2 ON u2.id = crm2.user_id
                  WHERE crm2.room_id = r.id AND crm2.user_id != $2 LIMIT 1) AS other_user_name
           FROM chat_messages m
           JOIN chat_rooms r ON r.id = m.room_id
           LEFT JOIN users u ON u.id = m.sender_id
          WHERE m.hotel_id = $1
            AND m.text ILIKE $3
            AND (r.type IN ('general', 'notifications') OR EXISTS (
              SELECT 1 FROM chat_room_members crm WHERE crm.room_id = r.id AND crm.user_id = $2
            ))
          ORDER BY m.created_at DESC
          LIMIT 30`,
        [hotelId, userId, `%${q}%`],
      )
      return rows
    },
  )

  // POST /api/hotels/:slug/chat/notify — post a system notification (manager/admin only)
  fastify.post<SlugParam & { Body: { text: string; system_name?: string } }>(
    '/api/hotels/:slug/chat/notify',
    { onRequest: [fastify.authenticate] },
    async (request, reply) => {
      const { slug } = request.params
      if (!canAccess(request.user.hotelSlug, request.user.role, slug))
        return reply.code(403).send({ error: 'Forbidden' })
      if (!['super_admin', 'hotel_admin', 'manager'].includes(request.user.role))
        return reply.code(403).send({ error: 'Insufficient permissions' })

      const hotelId = await getHotelId(slug)
      if (!hotelId) return reply.code(404).send({ error: 'Hotel not found' })

      const { text, system_name = 'Система' } = request.body
      if (!text?.trim()) return reply.code(400).send({ error: 'Text required' })

      const notifRoomId = await ensureNotificationsRoom(hotelId)
      const { rows } = await db.query(
        `INSERT INTO chat_messages (room_id, hotel_id, sender_id, text, is_system, system_name)
         VALUES ($1, $2, NULL, $3, true, $4)
         RETURNING id, room_id, text, created_at, is_system, system_name`,
        [notifRoomId, hotelId, text.trim(), system_name],
      )
      return reply.code(201).send({ ...rows[0], sender_name: system_name, sender_role: 'system' })
    },
  )
}

export default chatRoutes