Feature/session wide algorithm

src/app/LoginPage.tsx

@@ -8,6 +8,7 @@ import { useAuth } from "@/auth/useAuth";
 import { signInWithGooglePopup } from "@/auth/authN";
 import Image from "next/image";
 import { signInWithMicrosoftPopup } from "@/auth/authN";
+import { generateSession } from "@/features/scheduling/test/generateEmulatorData";
 
 export default function LoginPage() {
   const [error, setError] = useState<string>("");
@@ -33,6 +34,16 @@ export default function LoginPage() {
     }
   }
 
+  const generateTestData = async () => {
+    try {
+      const data = await generateSession();
+      console.log(data);
+    }
+    catch {
+      setError("An error occurred while trying to sign in. Please try again.");
+    }
+  }
+
   return (
     <div className="relative min-h-full w-full flex items-center justify-center bg-primary-300 overflow-hidden">
       <div className="absolute inset-0 h-full">
@@ -67,6 +78,14 @@ export default function LoginPage() {
           Sign in with Microsoft
         </button>
 
+        <button
+          onClick={generateTestData}
+          className="flex flex-row justify-around items-center w-5/6 max-w-[344px] bg-white 
+                    mt-5 py-4 px-12 rounded-full shadow-[0_4px_4px_-1px_rgba(0,0,0,0.2)] font-lato text-xl text-gray-600"
+        >
+          <Image src={MicrosoftIcon.src} alt="Microsoft" width={32} height={32} />
+          Generate Test
+        </button>
 
         {/* Error Message */}
         {errorDisplay && (

src/features/scheduling/generation/SessionScheduler.ts

@@ -1,5 +1,6 @@
-
-import { StaffAttendeeID, AdminAttendeeID, NightShiftID, SessionID, SectionID } from "@/types/sessionTypes";
+import { StaffAttendeeID, AdminAttendeeID, NightShiftID, SessionID, SectionID, NightShift } from "@/types/sessionTypes";
+import { Moment } from "moment";
+import moment from "moment";
 
 export class SessionScheduler {
   session: SessionID | undefined;
@@ -17,9 +18,226 @@ export class SessionScheduler {
 
   withNightShifts(nightShifts: NightShiftID[]): SessionScheduler { this.nightShifts = nightShifts; return this; }
 
-  assignDaysOff(): SessionScheduler { return this; }
+  private shuffleArray<T>(arr: T[]): T[] { 
+    return arr .map(value => ({ value, sort: Math.random() })) 
+    .sort((a, b) => a.sort - b.sort) 
+    .map(({ value }) => value); 
+  }
+  private toISO(date: Moment): string {
+    return date.format("YYYY-MM-DD");
+  }
+
+  private getDateStringsInRange(start: Moment, end: Moment): string[] {
+    const dates: string[] = [];
+    const curr = start.clone();
+    while (curr.isSameOrBefore(end)) {
+      dates.push(this.toISO(curr));
+      curr.add(1, "day");
+    }
+    return dates;
+  }
+
+  private isJamboreeISO(dateISO: string, sections: SectionID[]): boolean {
+    const date = moment(dateISO);
+    return sections.some(section => {
+      if (!('type' in section)) return false;
+      const s = moment(section.startDate);
+      const e = moment(section.endDate).subtract(1, "day");
+      return (
+        (section.type === "BUNK-JAMBO" || section.type === "NON-BUNK-JAMBO") &&
+        date.isSameOrAfter(s) &&
+        date.isSameOrBefore(e)
+      );
+    });
+  }
+
+
+  private assignOneDayOff(
+    employee: StaffAttendeeID | AdminAttendeeID,
+    candidateDates: string[],
+    dayCounts: Map<string, number>,
+    allEmployees: (StaffAttendeeID | AdminAttendeeID)[],
+    maxStaffOffPerDay: number
+  ): boolean {
+
+    for (const date of candidateDates) {
+    if ((dayCounts.get(date) ?? 0) >= maxStaffOffPerDay){
+      console.log("Max staff off per day reached");
+      continue;
+    };
+    // bunk constraint (HARD)
+      if ('bunk' in employee && maxStaffOffPerDay !== Infinity) {
+        const bunkConflict = allEmployees.some(e =>
+          'bunk' in e &&
+          e.bunk === employee.bunk &&
+          e.daysOff.includes(date)
+        );
+
+        if (bunkConflict) continue;
+      }
+
+      // assign
+      employee.daysOff.push(date);
+      dayCounts.set(date, (dayCounts.get(date) ?? 0) + 1);
+      return true;
+    }
+
+
+
+    return false;
+  }
+
+
+
+  assignDaysOff(session: SessionID, employees: (StaffAttendeeID | AdminAttendeeID)[]): SessionScheduler {
+    try {
+      const start = moment(session.startDate);
+
+      // Define windows (days 2–6 and 7–12) (TEMP Set for default session. Need to change to handle multiple sessions)
+      const window1 = this.getDateStringsInRange(start.clone().add(1, "day"), start.clone().add(5, "day"));
+      const window2 = this.getDateStringsInRange(start.clone().add(6, "day"), start.clone().add(11, "day"));
+
+      const allDates = [...window1, ...window2];
+      let maxStaffOffPerDay = Math.ceil(employees.length / allDates.length);
+
+      const dayCounts = new Map<string, number>();
+      allDates.forEach(d => dayCounts.set(d, 0));
+
+      // Separate program counselors
+      const nonWFProgramCounselors = employees.filter(
+        e => 'programCounselor' in e && e.programCounselor && e.programCounselor.id !== "WF"
+      );
+      const WFProgramCounselors = employees.filter(
+        e => 'programCounselor' in e && e.programCounselor && e.programCounselor.id === "WF"
+      );
+      // ---- Choose exact number of WF counselors for Jamboree ----
+      const numWFWindow1 = Math.ceil(WFProgramCounselors.length/window1.length); // example: 3 WF on Jamboree in window1
+      const numWFWindow2 = Math.ceil(WFProgramCounselors.length/window2.length); // example: 2 WF on Jamboree in window2
+
+      const shuffledWF = this.shuffleArray(WFProgramCounselors);
+      const selectedWFWindow1 = shuffledWF.slice(0, numWFWindow1);
+      const selectedWFWindow2 = shuffledWF.slice(numWFWindow1, numWFWindow1 + numWFWindow2);
+
+      // ---- Build Jamboree sets ----
+      const jamboreeWindow1 = new Set([...nonWFProgramCounselors, ...selectedWFWindow1]);
+      const jamboreeWindow2 = new Set([...nonWFProgramCounselors, ...selectedWFWindow2]);
+
+      // ---- PASS 1: window1 ----
+      for (const employee of employees) {
+        maxStaffOffPerDay = Math.ceil(employees.length / window1.length);
+        const dates =
+          'programCounselor' in employee && jamboreeWindow1.has(employee)
+            ? window1.filter(d => this.isJamboreeISO(d, this.sections))
+            : window1;
+
+        if (dates.length === 1){
+          // set maxStaffOffPerDay to Infinity
+          maxStaffOffPerDay = Infinity;
+        };
+
+        if (!this.assignOneDayOff(employee, dates, dayCounts, employees, maxStaffOffPerDay)) {
+          console.warn(`Failed to assign window-1 day off for ${employee.id}`);
+        }
+      }
+
+      // ---- PASS 2: window2 ----
+      for (const employee of employees) {
+        maxStaffOffPerDay = Math.ceil(employees.length / window2.length);
+
+        const dates =
+          'programCounselor' in employee && jamboreeWindow2.has(employee)
+            ? window2.filter(d => this.isJamboreeISO(d, this.sections))
+            : window2;
+
+        if (dates.length === 1){
+
+          maxStaffOffPerDay = Infinity;
+        };
+
+        if (!this.assignOneDayOff(employee, dates, dayCounts, employees, maxStaffOffPerDay)) {
+          console.warn(`Failed to assign window-2 day off for ${employee.id}`);
+        }
+      }
+
+    } catch (e) {
+      console.error(e);
+    }
+
+    return this;
+  }
+
+
+
+  assignNightShifts(session: SessionID, employees: StaffAttendeeID[]): SessionScheduler {
+    const bunks = new Set<number>();
+    const endDate = moment(session.endDate).subtract(1, 'day');
+    const startDate = moment(session.startDate);
+
+
+    // Collect unique bunks
+    for (let i = 0; i < employees.length; i++) {
+      bunks.add(employees[i].bunk);
+    }
+
+
+
+    const currDate = startDate;
+
+    // Create a night bunk object for each night
+    while (currDate.isSameOrBefore(endDate)) {
+      const shift: NightShiftID = {
+        sessionId: session.id,
+        id: `night-${this.toISO(currDate)}`
+      };
+      // looping through all unique bunks that the employees have
+      for (const bunkNumber of bunks) {
+        // Create NightShift object for this bunk
+        shift[bunkNumber] = {
+          counselorsOnDuty: [],
+          nightBunkDuty: [],
+        };
+
+        // choosing 4 employees
+        const employeesInBunk = employees.filter((e) => e.bunk === bunkNumber);
+        const PER_SPLIT = Math.ceil(employeesInBunk.length / 2);
+
+        if (employeesInBunk.length === 0) continue;
+        let selected: StaffAttendeeID[] = []
+
+        for (const employee of employeesInBunk) {
+
+          if (employee.daysOff.includes(this.toISO(currDate))) {
+            continue;
+          }
+          const prevDate = currDate.clone().subtract(1, 'day');
+          const nextDate = currDate.clone().add(1, 'day');
+
+          const hasAdjacentDayOff =
+            employee.daysOff.includes(this.toISO(prevDate)) ||
+            employee.daysOff.includes(this.toISO(nextDate));
+
+          if (!hasAdjacentDayOff && shift[bunkNumber].counselorsOnDuty.length + 1 < PER_SPLIT ) {
+            shift[bunkNumber].counselorsOnDuty.push(employee.id);
+            selected.push(employee);
+          }
+
+          else {
+            shift[bunkNumber].nightBunkDuty.push(employee.id);
+            selected.push(employee);
+          }
+        }
+
+      }
+      // Save the shift object
+      this.nightShifts.push(shift);
+      currDate.add(1, "day");
+    }
+    return this;
+
+
+
 
-  assignNightShifts(): SessionScheduler { return this; }
+  }
 
   getSchedule(): { nightShifts: NightShiftID[] } { return { nightShifts: this.nightShifts }; }
 }