import { Router } from "express";
import { parseISO, startOfDay, endOfDay } from "date-fns";
import Company from "../models/Company.js";
import ScheduledSession from "../models/ScheduledSession.js";
import Schedule from "../models/Schedule.js";
import User from "../models/User.js";

const router = Router();

// router.get("/", async (_req, res) => {
//   const companies = await Company.find();

//   res.json(companies);
// });

router.get("/:id", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  const company = await Company.findById(req.params.id);

  res.json(company);
});

router.get("/:id/builds", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  const company: any = await Company.findById(req.params.id).populate("builds");
  const { builds } = company;

  res.json(builds);
});

router.get("/:id/users", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  const company: any = await Company.findById(req.params.id).populate("users");
  const { users } = company;

  res.json(users);
});

router.get("/:id/builds/:buildId/users", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  const buildUsers: any = await User.find({
    buildIds: req.params.buildId,
  });

  const users = [];

  for (const buildUser of buildUsers) {
    const user = await User.findById(buildUser.userId);
    users.push(user);
  }

  res.json(users);
});

router.get("/:id/builds/:buildId/scheduled_sessions", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  if (!req.query.date) {
    res.json({ error: "Query parameter `date` is required" });
    return;
  }

  const date = parseISO(req.query.date as string);

  const company: any = await Company.findById(req.params.id).populate({
    path: "builds",
    match: {
      _id: req.params.buildId,
    },
    populate: {
      path: "scheduledSessions",
      match: {
        startAt: {
          $gte: startOfDay(date),
          $lte: endOfDay(date),
        },
      },
    },
  });

  const { scheduledSessions } = company.builds[0];

  res.json(scheduledSessions);
});

// router.post(
//   "/:id/builds/:buildId/scheduled_sessions",
//   async (req, res) => {
//     if (req.params.id != res.locals.user.companyId) {
//       res.json({ error: "Access denied" });
//       return;
//     }

//     if (!req.params.buildId) {
//       res.json({ error: "req.params.buildId" });
//       return;
//     }

//     const scheduledSession = await ScheduledSession.create({
//       companyId: req.params.id,
//       buildId: req.params.buildId,
//       ...req.body,
//     });

//     res.json(scheduledSession);
//   }
// );

router.put("/:id/scheduled_sessions/:scheduledSessionId", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  try {
    const scheduledSession = await ScheduledSession.findById(
      req.params.scheduledSessionId
    );

    const scheduledSessionAtSameTime = await ScheduledSession.findOne({
      startAt: scheduledSession?.startAt,
      userId: req.body.userId,
    });

    if (scheduledSessionAtSameTime && req.body.userId !== null) {
      await ScheduledSession.updateMany(
        {
          userId: req.body.userId,
          startAt: scheduledSession?.startAt,
        },
        {
          userId: null,
        }
      );

      await ScheduledSession.findByIdAndUpdate(req.params.scheduledSessionId, {
        userId: req.body.userId,
      });
      res.json({ error: "Scheduled session at same time" });
      return;
    }

    const updatedScheduledSession = await ScheduledSession.findByIdAndUpdate(
      req.params.scheduledSessionId,
      req.body,
      {
        new: true,
        upsert: true,
      }
    );

    res.json(updatedScheduledSession);
  } catch (error) {
    if (error instanceof Error) {
      res.json({ error });
    }
  }
});

router.get(
  "/:id/builds/:buildId/scheduled_sessions/:scheduledSessionId/availableManagers",
  async (req, res) => {
    if (!req.query.startAt) {
      res.json({ error: "Query parameter `startAt` is required" });
      return;
    }

    try {
      const scheduledSession = await ScheduledSession.findById(
        req.params.scheduledSessionId
      );

      if (!scheduledSession) {
        res.json({ error: "Scheduled session not found" });
        return;
      }

      const buildUsers = await User.find({ buildIds: req.params.buildId });
      let buildUserIds = buildUsers.map((buildUser) => buildUser.toString());

      const scheduledSessionsAtTime = await ScheduledSession.find({
        buildId: req.params.buildId,
        startAt: req.query.startAt,
      });

      const scheduledSessionAtTimeUserIds: any[] = [];

      for (const scheduledSessionAtTime of scheduledSessionsAtTime) {
        if (scheduledSessionAtTime.userId) {
          scheduledSessionAtTimeUserIds.push(
            scheduledSessionAtTime.userId.toString()
          );
        }
      }

      const filteredUserIds: any[] = buildUserIds.filter(
        (buildUserId) => !scheduledSessionAtTimeUserIds.includes(buildUserId)
      );

      if (scheduledSession.userId) {
        filteredUserIds.push(scheduledSession.userId);
      }

      res.json(filteredUserIds);
    } catch (error) {
      if (error instanceof Error) {
        res.json({ error });
      }
    }
  }
);

router.get("/:id/builds/:buildId/schedules", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  const schedules = await Schedule.find({
    companyId: req.params.id,
    buildId: req.params.buildId,
  });

  res.json(schedules);
});

router.post("/:id/builds/:buildId/schedules", async (req, res) => {
  if (req.params.id != res.locals.user.companyId) {
    res.json({ error: "Access denied" });
    return;
  }

  try {
    const schedule = await Schedule.create({
      companyId: req.params.id,
      buildId: req.params.buildId,
      ...req.body,
    });
    res.json(schedule);
  } catch (error) {
    if (error instanceof Error) {
      res.json({ error: error.message });
    }
  }
});

router.get(
  "/:companyId/builds/:buildId/last_scheduled_session",
  async (req, res) => {
    const { buildId } = req.params;

    try {
      const lastScheduledSession = await ScheduledSession.findOne({
        buildId,
      }).sort({ startAt: -1 });

      res.json(lastScheduledSession);
    } catch (error) {
      res.json({ error: (error as Error).message });
    }
  }
);

const companiesRouter = router;

export default companiesRouter;