User: Task: "Create Check Availability for Booking Api "
    Description: "Generate a Node.js Check Availability for Booking Api with given dependenceis"
    Requirements:
    - Database: mongoose
    - Authentication: None specified
    - Output needed: Return only the function code as specified in dependencies
    - Dependencies: Create a function to check real-time availability. Export: exports.checkAvailability = async () => {...}, 
Accept parameters: checkInDate, checkOutDate, roomId (or serviceId)., 
Validate required fields: Ensure checkInDate, checkOutDate, and roomId are provided., 
Query the Booking model to check for any existing bookings during the specified date range., 
Ensure no double booking occurs for the same room or service in the selected date range., 
If the room or service is available, respond with a success message and availability status., 
If unavailable, respond with an error message indicating double booking., 
Handle errors like missing or invalid parameters, database connection errors.
    - Previous Code 
const mongoose = require('mongoose');
const Booking = require('../models/Booking'); // Assuming Booking model is in models/Booking.js

exports.checkAvailability = async (checkInDate, checkOutDate, roomId) => {
  // Validate required fields
  if (!checkInDate || !checkOutDate || !roomId) {
    throw new Error("Missing required parameters: checkInDate, checkOutDate, roomId are required.");
  }

  // Convert dates to proper Date objects
  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  // Validate date formats
  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }
  
  try {
    // Query the Booking model to find existing bookings within date range
    const existingBookings = await Booking.find({
      roomId: roomId,
      $or: [
        { checkInDate: { $lt: checkOut, $gte: checkIn } },
        { checkOutDate: { $gt: checkIn, $lte: checkOut } },
        { checkInDate: { $lte: checkIn }, checkOutDate: { $gte: checkOut } }
      ]
    });

    // Ensure no double booking
    if (existingBookings.length > 0) {
      return { available: false, message: "Room/service is already booked for these dates." };
    }

    // If no conflicting bookings found
    return { available: true, message: "Room/service is available for booking." };

  } catch (error) {
    // Handle database connection errors
    throw new Error("Database error: " + error.message);
  }
};

exports.manageTimeSlots = async ({ date, serviceId, availableSlots }) => {
  // Validate required fields
  if (!date || !serviceId || !Array.isArray(availableSlots) || availableSlots.length === 0) {
    throw new Error("Missing required parameters: date, serviceId, and availableSlots are required.");
  }

  // Convert date to a Date object
  const validDate = new Date(date);
  if (isNaN(validDate.getTime())) {
    throw new Error("Invalid date format provided.");
  }

  try {
    // Check for overlapping slots
    const overlappingSlots = await TimeSlot.find({
      serviceId: serviceId,
      date: validDate,
      time: { $in: availableSlots }
    });

    if (overlappingSlots.length > 0) {
      throw new Error("Some time slots are overlapping with existing bookings.");
    }

    // Create or update time slots
    await Promise.all(availableSlots.map(async (slot) => {
      await TimeSlot.updateOne(
        { serviceId: serviceId, date: validDate, time: slot },
        { $set: { serviceId, date: validDate, time: slot } },
        { upsert: true }
      );
    }));

    return { success: true, message: "Available time slots have been successfully managed." };

  } catch (error) {
    // Handle database errors
    throw new Error("Database error: " + error.message);
  }
};

exports.createRecurringBooking = async ({ startDate, endDate, frequency, roomId }) => {
  // Validate required fields
  if (!startDate || !endDate || !frequency || !roomId) {
    throw new Error("Missing required parameters: startDate, endDate, frequency, roomId are required.");
  }

  // Convert input dates to Date objects
  const start = new Date(startDate);
  const end = new Date(endDate);

  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  // Function to determine the next booking date based on frequency
  const getNextBookingDate = (currentDate) => {
    switch (frequency) {
      case 'weekly':
        return new Date(currentDate.setDate(currentDate.getDate() + 7));
      case 'monthly':
        return new Date(currentDate.setMonth(currentDate.getMonth() + 1));
      default:
        throw new Error("Invalid frequency. Supported values are: weekly, monthly.");
    }
  };

  try {
    let currentBookingDate = new Date(start);
    const bookings = [];

    // Loop through the dates based on the frequency until end date is reached
    while (currentBookingDate <= end) {
      // Check availability for the current booking date
      const { available, message } = await exports.checkAvailability(currentBookingDate, new Date(currentBookingDate), roomId);

      if (!available) {
        throw new Error(`Conflict: ${message} on ${currentBookingDate.toISOString().split('T')[0]}`);
      }

      // Create booking for the current date
      const booking = new Booking({
        checkInDate: currentBookingDate,
        checkOutDate: new Date(currentBookingDate), // assuming single-day booking for simplicity
        roomId
      });
      await booking.save();

      bookings.push(booking);

      // Get the next booking date
      currentBookingDate = getNextBookingDate(currentBookingDate);
    }

    return { success: true, bookings, message: "All recurring bookings have been successfully created." };

  } catch (error) {
    // Handle errors
    throw new Error("Error creating recurring bookings: " + error.message);
  }
};

// Exported async function to add a user to the waitlist
exports.addToWaitlist = async (userId, checkInDate, checkOutDate, roomId) => {
  // Step 1: Validate required fields
  if (!userId || !checkInDate || !checkOutDate || !roomId) {
    throw new Error("Missing required parameters: userId, checkInDate, checkOutDate, and roomId are required.");
  }

  // Step 2: Convert dates to Date objects
  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  // Step 3: Validate date formats
  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  try {
    // Step 4: Query Bookings to check if requested date is fully booked
    const existingBookings = await Booking.find({
      roomId: roomId,
      $or: [
        { checkInDate: { $lt: checkOut, $gte: checkIn } },
        { checkOutDate: { $gt: checkIn, $lte: checkOut } },
        { checkInDate: { $lte: checkIn }, checkOutDate: { $gte: checkOut } }
      ]
    });

    if (existingBookings.length === 0) {
      return { message: "Room/service is available. You don't need to join the waitlist." };
    }

    // Step 5: Add user to the waitlist
    const priorityLevel = existingBookings.length + 1;
    const newWaitlistEntry = new Waitlist({
      userId: userId,
      checkInDate: checkIn,
      checkOutDate: checkOut,
      roomId: roomId,
      priorityLevel: priorityLevel
    });

    await newWaitlistEntry.save();

    // Step 6: Respond with success message
    return { success: true, message: "User has been successfully added to the waitlist." };

  } catch (error) {
    // Handle potential errors such as database issues
    throw new Error("Error adding user to waitlist: " + error.message);
  }
};

exports.createRecurringBooking = async ({ startDate, endDate, frequency, roomId }) => {
  // Validate required fields
  if (!startDate || !endDate || !frequency || !roomId) {
    throw new Error("Missing required parameters: startDate, endDate, frequency, and roomId are required.");
  }

  // Convert input dates to Date objects
  const start = new Date(startDate);
  const end = new Date(endDate);

  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  // Determine frequency interval
  const getFrequencyInterval = (frequency) => {
    switch (frequency) {
      case 'weekly':
        return 7; // 7 days for weekly
      case 'monthly':
        return 30; // Approximate average of 30 days for monthly
      default:
        throw new Error("Invalid frequency. Supported values are: weekly, monthly.");
    }
  };

  try {
    const intervalDays = getFrequencyInterval(frequency);
    let currentBookingDate = new Date(start);
    const bookings = [];

    // Loop through the dates based on the frequency until end date is reached
    while (currentBookingDate <= end) {
      const checkOutDate = new Date(currentBookingDate);
      checkOutDate.setDate(checkOutDate.getDate() + intervalDays);

      // Check availability for the current booking date
      const { available, message } = await exports.checkAvailability(currentBookingDate, checkOutDate, roomId);

      if (!available) {
        throw new Error(`Conflict: ${message} on ${currentBookingDate.toISOString().split('T')[0]}`);
      }

      // Create booking for the current date
      const booking = new Booking({
        checkInDate: currentBookingDate,
        checkOutDate,
        roomId
      });
      await booking.save();
      
      bookings.push(booking);

      // Move to the next booking date
      currentBookingDate.setDate(currentBookingDate.getDate() + intervalDays);
    }

    return { success: true, bookings, message: "All recurring bookings have been successfully created." };

  } catch (error) {
    // Handle errors
    throw new Error("Error creating recurring bookings: " + error.message);
  }
};

exports.checkAvailability = async (checkInDate, checkOutDate, roomId) => {
  if (!checkInDate || !checkOutDate || !roomId) {
    throw new Error("Missing required parameters: checkInDate, checkOutDate, roomId are required.");
  }

  const checkIn = new Date(checkInDate);
  const checkOut = new Date(checkOutDate);

  if (isNaN(checkIn.getTime()) || isNaN(checkOut.getTime())) {
    throw new Error("Invalid date formats provided.");
  }
  
  try {
    const existingBookings = await Booking.find({
      roomId: roomId,
      $or: [
        { checkInDate: { $lt: checkOut, $gte: checkIn } },
        { checkOutDate: { $gt: checkIn, $lte: checkOut } },
        { checkInDate: { $lte: checkIn }, checkOutDate: { $gte: checkOut } }
      ]
    });

    if (existingBookings.length > 0) {
      return { available: false, message: "Room/service is already booked for these dates." };
    }

    return { available: true, message: "Room/service is available for booking." };

  } catch (error) {
    throw new Error("Database error: " + error.message);
  }
};

exports.createRecurringBooking = async ({ startDate, endDate, frequency, roomId }) => {
  if (!startDate || !endDate || !frequency || !roomId) {
    throw new Error("Missing required parameters: startDate, endDate, frequency, and roomId are required.");
  }

  const start = new Date(startDate);
  const end = new Date(endDate);

  if (isNaN(start.getTime()) || isNaN(end.getTime())) {
    throw new Error("Invalid date formats provided.");
  }

  const getNextBookingDate = (currentDate) => {
    switch (frequency) {
      case 'weekly':
        return new Date(currentDate.setDate(currentDate.getDate() + 7));
      case 'monthly':
        return new Date(currentDate.setMonth(currentDate.getMonth() + 1));
      default:
        throw new Error("Invalid frequency. Supported values are: weekly, monthly.");
    }
  };

  try {
    let currentBookingDate = new Date(start);
    const bookings = [];

    while (currentBookingDate <= end) {
      const { available, message } = await exports.checkAvailability(currentBookingDate, currentBookingDate, roomId);

      if (!available) {
        throw new Error(`Conflict: ${message} on ${currentBookingDate.toISOString().split('T')[0]}`);
      }

      const booking = new Booking({
        checkInDate: currentBookingDate,
        checkOutDate: new Date(currentBookingDate), // assuming single-day booking for simplicity
        roomId
      });
      await booking.save();

      bookings.push(booking);

      currentBookingDate = getNextBookingDate(currentBookingDate);
    }

    return { success: true, bookings, message: "All recurring bookings have been successfully created." };

  } catch (error) {
    throw new Error("Error creating recurring bookings: " + error.message);
  }
};

    - Supporting data 
    - Updating File undefined
    
    Please generate the code for this task, following the instructions and including comments for clarity.
    While creating router for specifict file your have to read supporing file data and create for that 

    **Output Formats**: 

Return dependencies like this `const bcrypt = require('bcrypt');`  in this formate
```dependencies
const bcrypt = require('bcrypt');
```

Ensure this format is consistently followed in responses.
    
User: 


    
Assistant: