// src/server/features/rooms/rooms.routes.ts
// HTTP handlers for rooms routes

import { FastifyPluginAsync } from 'fastify';
import { ZodTypeProvider } from 'fastify-type-provider-zod';
import { z } from 'zod';
import { logger } from '@serverShared/lib/logger';
import { requireAuth } from '@serverShared/lib/auth';
import { AppPermission } from '@shared/contracts/permissions';
import {
  createRoom,
  getAllRooms,
  getRoomById,
  updateRoom,
  deleteRoom,
} from './rooms.service';
import {
  createRoomSchema,
  updateRoomSchema,
  roomResponseSchema,
  roomListResponseSchema,
  roomResponseWrapperSchema,
  errorResponseSchema,
} from './rooms.schema';

const roomsRoutes: FastifyPluginAsync = async (fastify, opts) => {
  const server = fastify.withTypeProvider<ZodTypeProvider>();

  // Create room (PBAC + role guard)
  server.post('/', {
    preHandler: requireAuth(),
    onRequest: fastify.can(AppPermission.ROOMS_WRITE),
    schema: {
      body: createRoomSchema,
      response: {
        201: roomResponseWrapperSchema,
      },
    },
    handler: async (request) => {
      const result = await createRoom(request.body);
      logger.info(`[Rooms] Room created: ${result.id}`);
      return {
        success: true,
        data: result,
      };
    },
  });

  // Get all rooms
  server.get('/', {
    preHandler: requireAuth(),
    onRequest: fastify.can(AppPermission.ROOMS_READ),
    schema: {
      response: {
        200: roomListResponseSchema,
      },
    },
    handler: async () => {
      const result = await getAllRooms();
      return {
        success: true,
        data: result,
      };
    },
  });

  // Get room by ID
  server.get('/:id', {
    preHandler: requireAuth(),
    onRequest: fastify.can(AppPermission.ROOMS_READ),
    schema: {
      params: z.object({
        id: z.string(),
      }),
      response: {
        200: roomResponseWrapperSchema,
      },
    },
    handler: async (request) => {
      const { id } = request.params as { id: string };
      const result = await getRoomById(id);
      return {
        success: true,
        data: result,
      };
    },
  });

  // Update room (PBAC + role guard)
  server.put('/:id', {
    preHandler: requireAuth(),
    onRequest: fastify.can(AppPermission.ROOMS_WRITE),
    schema: {
      params: z.object({
        id: z.string(),
      }),
      body: updateRoomSchema,
      response: {
        200: roomResponseWrapperSchema,
      },
    },
    handler: async (request) => {
      const { id } = request.params as { id: string };
      const result = await updateRoom(id, request.body);
      logger.info(`[Rooms] Room updated: ${id}`);
      return {
        success: true,
        data: result,
      };
    },
  });

  // Delete room (PBAC + role guard)
  server.delete('/:id', {
    preHandler: requireAuth(),
    onRequest: fastify.can(AppPermission.ROOMS_DELETE),
    schema: {
      params: z.object({
        id: z.string(),
      }),
      response: {
        200: z.object({
          success: z.boolean(),
          message: z.string(),
        }),
      },
    },
    handler: async (request) => {
      const { id } = request.params as { id: string };
      await deleteRoom(id);
      logger.info(`[Rooms] Room deleted: ${id}`);
      return {
        success: true,
        message: 'Room deleted successfully',
      };
    },
  });
};

export default roomsRoutes;