const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

mongoose.connect('mongodb://localhost:27017/lovable', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const AppointmentSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  startTime: { type: Date, required: true },
  endTime: { type: Date, required: true },
  recurring: {
    repeatType: { type: String, enum: ['daily', 'weekly', 'monthly'], default: null },
    count: { type: Number, default: 0 }
  },
  createdAt: { type: Date, default: Date.now }
});

const Appointment = mongoose.model('Appointment', AppointmentSchema);

const app = express();
app.use(bodyParser.json());

app.post('/api/appointments', async (req, res) => {
  try {
    const { userId, startTime, endTime, recurring } = req.body;
    
    // Check for overlapping appointments for the same user.
    const overlapping = await Appointment.findOne({
      userId,
      $or: [
        {
          startTime: { $lt: new Date(endTime) },
          endTime: { $gt: new Date(startTime) }
        }
      ]
    });
    
    if (overlapping) {
      return res.status(400).json({ error: 'Time slot overlaps with an existing appointment' });
    }
    
    const appointment = new Appointment({ userId, startTime, endTime, recurring });
    await appointment.save();
    res.status(201).json({ success: true, appointment });
  } catch (err) {
    res.status(500).json({ error: 'Internal server error' });
  }
});

app.listen(3000, () => {
  console.log('Scheduling API running on port 3000');
});

const express = require('express');
const axios = require('axios');
const bodyParser = require('body-parser');
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/lovable', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const ExternalEventSchema = new mongoose.Schema({
  externalId: { type: String, required: true, unique: true },
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  title: { type: String, required: true },
  startTime: { type: Date, required: true },
  endTime: { type: Date, required: true }
});

const ExternalEvent = mongoose.model('ExternalEvent', ExternalEventSchema);

const app = express();
app.use(bodyParser.json());

app.post('/api/webhooks/external-calendar', async (req, res) => {
  try {
    const event = req.body;
    // Assume validation of the webhook signature is done here

    const filter = { externalId: event.id };
    const update = {
      userId: event.user\_id,
      title: event.title,
      startTime: new Date(event.start\_time),
      endTime: new Date(event.end\_time)
    };

    const options = { upsert: true, new: true };
    const savedEvent = await ExternalEvent.findOneAndUpdate(filter, update, options);
    res.status(200).json({ success: true, savedEvent });
  } catch (error) {
    res.status(500).json({ error: 'Error syncing external event' });
  }
});

async function syncUserExternalEvents(userId) {
  try {
    const response = await axios.get(`https://api.externalcalendar.com/users/${userId}/events`, {
      headers: { Authorization: 'Bearer YOUR_API_TOKEN' }
    });
    const events = response.data.events;
    for (const event of events) {
      await ExternalEvent.findOneAndUpdate(
        { externalId: event.id },
        {
          userId,
          title: event.title,
          startTime: new Date(event.start\_time),
          endTime: new Date(event.end\_time)
        },
        { upsert: true, new: true }
      );
    }
  } catch (err) {
    console.error('Failed to sync events:', err.message);
  }
}

app.listen(3000, () => {
  console.log('Scheduling app API running on port 3000');
});

const express = require('express');
const bodyParser = require('body-parser');
const moment = require('moment');
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/lovable', { 
  useNewUrlParser: true, 
  useUnifiedTopology: true 
});

const AppointmentSchema = new mongoose.Schema({
  userId: { type: mongoose.Schema.Types.ObjectId, ref: 'User', required: true },
  startTime: { type: Date, required: true },
  endTime: { type: Date, required: true }
});
const Appointment = mongoose.model('Appointment', AppointmentSchema);

const app = express();
app.use(bodyParser.json());

// This endpoint calculates common available time slots for a set of users on a given day.
app.post('/api/common-availability', async (req, res) => {
  const { userIds, date, durationInMinutes } = req.body;
  try {
    const dayStart = moment(date).startOf('day');
    const dayEnd = moment(date).endOf('day');

    // Fetch all appointments for the given users on that day.
    const appointments = await Appointment.find({
      userId: { $in: userIds },
      startTime: { $gte: dayStart.toDate() },
      endTime: { $lte: dayEnd.toDate() }
    }).sort({ startTime: 1 }).exec();

    // Build busy time slots for every user.
    const busyForUser = userIds.reduce((acc, id) => {
      acc[id] = [];
      return acc;
    }, {});
    
    appointments.forEach(appt => {
      busyForUser[appt.userId.toString()].push({
        start: moment(appt.startTime),
        end: moment(appt.endTime)
      });
    });

    // Calculate free slots for one user given their busy intervals.
    function calculateFreeSlots(busyIntervals, startOfDay, endOfDay, minDuration) {
      busyIntervals.sort((a, b) => a.start - b.start);
      const free = [];
      let current = startOfDay.clone();
      busyIntervals.forEach(interval => {
        if (current.isBefore(interval.start)) {
          const freeSlot = { start: current.clone(), end: interval.start.clone() };
          if (freeSlot.end.diff(freeSlot.start, 'minutes') >= minDuration) {
            free.push(freeSlot);
          }
        }
        if (current.isBefore(interval.end)) {
          current = interval.end.clone();
        }
      });
      if (current.isBefore(endOfDay)) {
        const freeSlot = { start: current.clone(), end: endOfDay.clone() };
        if (freeSlot.end.diff(freeSlot.start, 'minutes') >= minDuration) {
          free.push(freeSlot);
        }
      }
      return free;
    }

    // Build free slots per user.
    const freeSlotsByUser = {};
    userIds.forEach(id => {
      freeSlotsByUser[id] = calculateFreeSlots(busyForUser[id], dayStart, dayEnd, durationInMinutes);
    });

    // Function to compute intersection between two lists of free slots.
    function intersectTwoSlotLists(slotsA, slotsB, minDuration) {
      let i = 0, j = 0;
      const intersections = [];
      while (i < slotsA.length && j < slotsB.length) {
        const start = moment.max(slotsA[i].start, slotsB[j].start);
        const end = moment.min(slotsA[i].end, slotsB[j].end);
        if (end.diff(start, 'minutes') >= minDuration) {
          intersections.push({ start, end });
        }
        if (slotsA[i].end.isBefore(slotsB[j].end)) {
          i++;
        } else {
          j++;
        }
      }
      return intersections;
    }

    // Intersection of free slots across all users.
    let commonSlots = freeSlotsByUser[userIds[0]];
    for (let idx = 1; idx < userIds.length; idx++) {
      commonSlots = intersectTwoSlotLists(commonSlots, freeSlotsByUser[userIds[idx]], durationInMinutes);
    }

    const availableSlots = commonSlots.map(slot => ({
      startTime: slot.start.toISOString(),
      endTime: slot.end.toISOString()
    }));

    res.json({ availableSlots });
  } catch (error) {
    res.status(500).json({ error: 'Failed to compute common availability.' });
  }
});

app.listen(3000, () => {
  console.log('Common availability API running on port 3000');
});