index.js

require("dotenv").config();
const express = require("express");
const mongoose = require("mongoose");
const path = require("path");
const ejsMate = require("ejs-mate");
const flash = require("connect-flash");
const session = require("express-session");
const passport = require("passport");
const localStrategy = require("passport-local");
const bodyParser = require("body-parser");
const MongoStore = require("connect-mongo");
const methodOverride = require("method-override");

const expressError = require("./utils/expressError");
const User = require("./models/user");
const Bus = require("./models/bus");
const Route = require("./models/route");
const Booking = require("./models/booking");
const booking = require("./models/booking");

const app = express();
app.use(express.urlencoded({ extended: true }));

const dbUrl = "mongodb://127.0.0.1:27017/busBuddy";

mongoose.set("strictQuery", true);
mongoose.connect(dbUrl);

const db = mongoose.connection;
db.on("error", console.error.bind(console, "connection error:"));
db.once("open", () => {
  console.log("Database connected");
});

const sessionStore = new MongoStore({
  mongoUrl: dbUrl,
  mongooseConnection: mongoose.connection,
  collection: "sessions", // Collection name for sessions in MongoDB
});

const sessionConfig = {
  name: "tappu",
  secret: "thisShouldBeSecret",
  resave: false,
  saveUninitialized: true,
  store: sessionStore,
  cookie: {
    httpOnly: true,
    //  secure: true,
    expires: Date.now() + 1000 * 60 * 60 * 24 * 7,
    maxAge: 1000 * 60 * 60 * 24 * 7,
  },
};

app.engine("ejs", ejsMate);
app.use(session(sessionConfig));
app.set("view engine", "ejs");
app.set("views", path.join(__dirname, "views/"));
app.use(express.static(path.join(__dirname, "public")));
app.use(flash());
app.use(passport.initialize());
app.use(passport.session());
app.use(methodOverride("_method"));
passport.use(new localStrategy(User.authenticate()));

app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());

passport.serializeUser(User.serializeUser());
passport.deserializeUser(User.deserializeUser());

app.use((req, res, next) => {
  res.locals.currentUser = req.user;
  res.locals.originalUrl = req.originalUrl;
  res.locals.success = req.flash("success");
  res.locals.error = req.flash("error");
  next();
});

const isLoggedIn = (req, res, next) => {
  if (!req.isAuthenticated()) {
    req.flash("error", "You need to login first");
    return res.redirect("/login");
  }
  next();
};

const getCurrentTime = () => {
  const currentTime = new Date();

  // Extract hours and minutes
  const currentHours = currentTime.getHours();
  const currentMinutes = currentTime.getMinutes();
  return { currentHours, currentMinutes };
};

const hoursToMinute = (hour, min) => {
  return 60 * hour + min;
};

const getActiveTripForUser = (min, user) => {
  let activeTrips = 0,
    upcomingTrips = 0,
    finishedTrips = 0;
  if (user.buses.length) {
    for (let bus of user.buses) {
      if (bus && bus.routes && bus.routes.length > 0) {
        for (let route of bus.routes) {
          const startMin = hoursToMinute(
            route.startTime.hours,
            route.startTime.minutes
          );
          const endMin = hoursToMinute(
            route.endTime.hours,
            route.endTime.minutes
          );
          if (min < startMin) {
            upcomingTrips = upcomingTrips + 1;
          } else if (min >= startMin && min <= endMin) {
            activeTrips = activeTrips + 1;
          } else {
            finishedTrips = finishedTrips + 1;
          }
        }
      }
    }
  }
  return { activeTrips, upcomingTrips, finishedTrips };
};

const getActiveTripForTraveller = (min, routes) => {
  let activeTrips = 0,
    upcomingTrips = 0,
    finishedTrips = 0;
    if (routes.length){
      for (let route of routes) {
        const startMin = hoursToMinute(
          route.startTime.hours,
          route.startTime.minutes
        );
        const endMin = hoursToMinute(
          route.endTime.hours,
          route.endTime.minutes
        );
        if (min < startMin) {
          upcomingTrips = upcomingTrips + 1;
        } else if (min >= startMin && min <= endMin) {
          activeTrips = activeTrips + 1;
        } else {
          finishedTrips = finishedTrips + 1;
        }
      }
    }
  return { activeTrips, upcomingTrips, finishedTrips };
};

app.get("", async (req, res) => {
  // const id = "662a4f9d90c39952acbe1a9b";
  // const id = "662a735c10ed8a265ee7ee21";
  // const routeData = await routeModel.findOne({ id });

  // Extract coordinates from each stop
  // const stopCoordinates = routeData.stop.map((e) => ({
  //   lat: e.location.geometery.coordinates[0],
  //   long: e.location.geometery.coordinates[1],
  // }));

  // Log coordinates
  // console.log(stopCoordinates);

  // Render response
  res.render("home");
});

app.get("/dashboard", isLoggedIn, async (req, res) => {
  const user = await User.findById(req.user._id);

  let populatedUser;

  if (user.type === "operator") {
    // Populate buses and routes if the user is an operator
    populatedUser = await User.findById(req.user._id)
      .populate({
        path: "buses",
        populate: {
          path: "routes",
        },
      })
      .populate('booking');
      console.log(populatedUser);
       const { currentHours, currentMinutes } = getCurrentTime();
       const totalMin = hoursToMinute(currentHours, currentMinutes);
       const { activeTrips, finishedTrips, upcomingTrips } =
       getActiveTripForUser(totalMin, populatedUser);
      console.log(activeTrips,finishedTrips)
      res.render("dashboard", {
        user: populatedUser,
        activeTrips,
        finishedTrips,
        upcomingTrips,
      });
  } else if (user.type === "traveller") {
    // Populate bookings if the user is a traveller
    populatedUser = await User.findById(req.user._id)
      .populate({path: "booking",
        populate: {
          path: "route",
        }});
    console.log(populatedUser);
    res.render("dashboard", {
      user: populatedUser
    });
  }
});

app.get("/my-buses", isLoggedIn, async (req, res) => {
  const user = await User.findById(req.user._id).populate("buses");
  res.render("my-buses", { user });
});

app.post("/add-bus", isLoggedIn, async (req, res) => {
  const { busName, busNumber, type, driver, conductor, busContact, seats } =
    req.body;
  const user = await User.findById(req.user._id);
  const bus = await new Bus({
    busName,
    busNumber,
    type,
    driver,
    conductor,
    busContact,
    seats,
  });
  bus.user = req.user._id;
  user.buses.push(bus);
  await user.save();
  await bus.save();
  console.log(user);
  console.log(bus);
  req.flash("success", `Added new bus ${bus.busName}`);
  res.redirect("/my-buses");
});

app.get("/bus/:id", isLoggedIn, async (req, res) => {
  const busData = await Bus.findById(req.params.id).populate("routes");
  res.render("bus", { busData });
});

app.post("/bus/:id", async (req, res) => {
  const {
    routeName,
    totalStops,
    startTime,
    endTime,
    startStop,
    endStop,
    stop,
  } = req.body;

  const formatTime = (time) => {
    const [hours, minutes] = time.split(":").map(Number);
    return { hours, minutes };
  };

  const calculateTotalTime = (startTime, endTime) => {
    const parseTime = (time) => {
      const [hours, minutes] = time.split(":").map(Number);
      return { hours, minutes };
    };

    const start = parseTime(startTime);
    const end = parseTime(endTime);

    const startMinutes = start.hours * 60 + start.minutes;
    const endMinutes = end.hours * 60 + end.minutes;

    let totalMinutes;
    if (endMinutes >= startMinutes) {
      totalMinutes = endMinutes - startMinutes;
    } else {
      totalMinutes = 24 * 60 - startMinutes + endMinutes; // Crosses midnight
    }

    const hours = Math.floor(totalMinutes / 60);
    const minutes = totalMinutes % 60;

    return `${hours}:${minutes}`;
  };

  formattedStartTime = formatTime(startTime);
  formattedEndTime = formatTime(endTime);
  formattedTotalTime = formatTime(calculateTotalTime(startTime, endTime));

  // Process the stop array
  const formattedStops = stop.map((s) => ({
    name: s.name,
    coords: s.coords,
    arrivalTime: formatTime(s.arrTime),
    departureTime: formatTime(s.deptTime),
  }));
  console.log(formattedStops);
  const route = await new Route({
    routeName,
    totalStops,
    startStop,
    endStop,
    startTime: formattedStartTime,
    endTime: formattedEndTime,
    totalTime: formattedTotalTime,
    stops: formattedStops,
    bus: req.params.id,
  });
  await route.save();
  // formattedStartTime: startTime,
  // formattedEndTime: endTime,
  // stops: formattedStops,
  const bus = await Bus.findById(req.params.id);
  bus.routes.push(route._id);
  await bus.save();
  res.redirect(`/bus/${req.params.id}`);
});

app.delete("/bus/:id", async (req, res) => {
  try {
    const bus = await Bus.findByIdAndDelete(req.params.id).populate("routes");
    const routes = bus.routes.forEach(
      async (e) => await Route.findByIdAndDelete(e._id)
    );
    req.flash(
      "success",
      `Successfully deleted ${bus.busName} bus and its respective routes`
    );
    res.redirect("/my-buses");
  } catch (e) {
    req.flash("error", e.message);
    console.log("error" + e);
    res.redirect("/my-buses");
  }
});

app.get("/route/:routeId/booking", isLoggedIn, async(req,res) => {
  const route = await Route.findById(req.params.routeId);
  res.render('booking',{route});
})

app.post("/route/:routeId/booking", isLoggedIn, async(req,res) => {
  const {selectedSeats,selectedDate} = req.body;
  const {routeId} = req.params;
  const seats = selectedSeats.split(',').map(Number);
  const today = new Date();
  const bookingDate = new Date(
     today.setDate(today.getDate() + parseInt(selectedDate))
  );
  const route = await Route.findById(routeId);
  const ticket = await new Booking({route: routeId, seatsBooked: seats, user: req.user._id , travelDate: bookingDate })
  await ticket.save();
  const user = await User.findById(req.user._id);
  user.booking.push(ticket._id);
  await user.save();
  if(ticket){
  req.flash("success", `Booking done for ${route.startStop} - ${route.endStop}`);
  res.redirect("/dashboard");
  } else {
    req.flash("error","Encountered some error");
    res.redirect(`/route/${routeId}/booking`);
  }
  
})

app.get("/route/:routeId",async(req,res) => {
  const route = await Route.findById(req.params.routeId);
  res.render('route',{route});
})

app.delete("/route/:routeId", async (req, res) => {
  try {
    const route = await Route.findByIdAndDelete(req.params.routeId).populate(
      "bus"
    );
    console.log(route);
    const bus = await Bus.findById(route.bus._id);
    bus.routes.pull(req.params.routeId);
    await bus.save();
    req.flash("success", `Successfully deleted ${route.routeName} route`);
    res.redirect(`/bus/${route.bus._id}`); // Corrected redirection URL
  } catch (error) {
    console.error(error);
    req.flash("error", "An error occurred");
    res.redirect(`/bus/${route.bus._id}`);
  }
});

app.get("/register", (req, res) => {
  res.render("users/register");
});

app.get("/results", async (req, res) => {
  const { startStop, endStop } = req.query;
  try {
    // Validate input
    if (!startStop || !endStop) {
      req.flash("error", "Both start and end stops are required.");
      return res.redirect("/");
    }

    // Query the database
    const routes = await Route.find({
      "stops.name": { $all: [startStop, endStop] },
    }).populate("bus");
    // Filter routes to ensure the start stop comes before the end stop
    const filteredRoutes = routes.filter((route) => {
      const startIndex = route.stops.findIndex(
        (stop) => stop.name === startStop
      );
      const endIndex = route.stops.findIndex((stop) => stop.name === endStop);
      return startIndex !== -1 && endIndex !== -1 && startIndex < endIndex;
    });

    // Handle no results
    if (filteredRoutes.length === 0) {
      req.flash("error", "No routes found for the specified stops.");
      return res.redirect("/");
    }
    const { currentHours, currentMinutes } = getCurrentTime();
    const totalMin = hoursToMinute(currentHours, currentMinutes);
    // const { activeTrips, upcomingTrips, finishedTrips } =
    //   getActiveTripForTraveller(totalMin, filteredRoutes);

    // filter routes acc to current time
    filteredRoutes.sort((a, b) => {
      const aStartTime = hoursToMinute(a.startTime.hours, a.startTime.minutes);
      const aEndTime = hoursToMinute(a.endTime.hours, a.endTime.minutes);
      const bStartTime = hoursToMinute(b.startTime.hours, b.startTime.minutes);
      const bEndTime = hoursToMinute(b.endTime.hours, b.endTime.minutes);

      if (aStartTime >= totalMin && bStartTime >= totalMin) {
        return aStartTime - bStartTime; // Both are future starts, sort by closest start time
      } else if (aStartTime >= totalMin && bStartTime < totalMin) {
        return -1; // a is future, b is past, a comes first
      } else if (aStartTime < totalMin && bStartTime >= totalMin) {
        return 1; // a is past, b is future, b comes first
      } else {
        // Both are past starts, sort by closest end time
        return aEndTime - bEndTime;
      }
    });

    // Separate routes into active, upcoming, and finished
    const activeTrips = filteredRoutes.filter((route) => {
      const startTime = hoursToMinute(
        route.startTime.hours,
        route.startTime.minutes
      );
      const endTime = hoursToMinute(
        route.endTime.hours,
        route.endTime.minutes
      );
      return startTime <= totalMin && endTime >= totalMin;
    });

    const upcomingTrips = filteredRoutes.filter((route) => {
      const startTime = hoursToMinute(
        route.startTime.hours,
        route.startTime.minutes
      );
      return startTime > totalMin;
    });

    const finishedTrips = filteredRoutes.filter((route) => {
      const endTime = hoursToMinute(
        route.endTime.hours,
        route.endTime.minutes
      );
      return endTime < totalMin;
    })

   const totalTrips = [...activeTrips,...upcomingTrips,...finishedTrips];

    // Render the results page
    res.render("traveller", {
      filteredRoutes,
      startStop,
      endStop,
      activeTrips,
      upcomingTrips,
      finishedTrips,
      totalTrips,
    });
  } catch (error) {
    console.error("Error fetching routes:", error);
    req.flash("error", "Something went wrong. Please try again later.");
    res.send(error);
  }
});

app.post("/register", async (req, res) => {
  try {
    const { name, email, username, password, type } = req.body;
    const user = await new User({
      name,
      username,
      email,
      type,
    });
    const registeredUser = await User.register(user, password);
    req.login(registeredUser, (err) => {
      if (err) return next(err);
      req.flash("success", `Welcome ${req.user.name}`);
      console.log("Hogya regsiter bhai");
      res.redirect("/dashboard");
    });
  } catch (e) {
    req.flash("error", e.message);
    console.log("error" + e);
    res.redirect("/login");
  }
});

app.get("/login", (req, res) => {
  res.render("users/login");
});

app.post(
  "/login",
  passport.authenticate("local", {
    failureFlash: true,
    failureRedirect: "/login",
  }),
  async (req, res) => {
    req.flash("success", `Welcome ${req.user.name}`);
    res.redirect("/dashboard");
  }
);

app.get("/logout", (req, res) => {
  req.logout(function (err) {
    if (err) {
      res.send(err);
    }
    req.flash("success", "Successfully, Logged Out!");
    res.redirect("/");
  });
});

app.get("/about", (req, res) => {
  res.send("about");
});

app.post("/routes", async (req, res) => {});

app.all("*", (req, res, next) => {
  next(new expressError("Page not found", 404));
});

app.use((err, req, res, next) => {
  const { statusCode = 500 } = err;
  if (!err.message) err.message = "Something went wrong";
  res.status(statusCode).render("error", { error: err });
});

app.listen("3000", () => {
  console.log("Listening on port 3000");
});