From 4bf2422ebc3f8c9668605592d33b45abe206cdab Mon Sep 17 00:00:00 2001
From: Carlos Valente <carlosvalente@pm.me>
Date: Fri, 7 Jun 2024 20:57:49 +0200
Subject: [PATCH] refactor: show next when waiting to roll

---
 .../src/services/__tests__/timerUtils.test.ts | 66 +++++++++++++++++++
 apps/server/src/services/timerUtils.ts        | 14 ++--
 apps/server/src/stores/runtimeState.ts        |  4 ++
 3 files changed, 77 insertions(+), 7 deletions(-)

diff --git a/apps/server/src/services/__tests__/timerUtils.test.ts b/apps/server/src/services/__tests__/timerUtils.test.ts
index 480e7b828..01cb2d53b 100644
--- a/apps/server/src/services/__tests__/timerUtils.test.ts
+++ b/apps/server/src/services/__tests__/timerUtils.test.ts
@@ -978,6 +978,32 @@ describe('getRollTimers()', () => {
     expect(state).toStrictEqual(expected);
   });
 
+  it('loads upcoming event while waiting to roll', () => {
+    const singleEventList: Partial<OntimeEvent>[] = [
+      {
+        id: '1',
+        timeStart: 72000000, // 20:00
+        timeEnd: 72010000, // 20:10
+        isPublic: true,
+      },
+    ];
+    const now = 6000; // 00:01
+    const expected = {
+      nowIndex: null,
+      nowId: null,
+      publicIndex: null,
+      nextIndex: 0,
+      publicNextIndex: 0,
+      timeToNext: 72000000 - now,
+      nextEvent: singleEventList[0],
+      nextPublicEvent: singleEventList[0],
+      currentEvent: null,
+      currentPublicEvent: null,
+    };
+    const state = getRollTimers(singleEventList as OntimeEvent[], now);
+    expect(state).toStrictEqual(expected);
+  });
+
   it('handles roll that goes over midnight', () => {
     const singleEventList: Partial<OntimeEvent>[] = [
       {
@@ -1890,4 +1916,44 @@ describe('getTimerPhase()', () => {
     const phase = getTimerPhase(state);
     expect(phase).toBe(TimerPhase.Pending);
   });
+
+  it('#1042 identifies waiting to roll', () => {
+    const state = {
+      clock: 55691050,
+      eventNow: null,
+      publicEventNow: null,
+      eventNext: null,
+      publicEventNext: null,
+      runtime: {
+        selectedEventIndex: null,
+        numEvents: 1,
+        offset: null,
+        plannedStart: 55860000,
+        plannedEnd: 55880000,
+        actualStart: null,
+        expectedEnd: null,
+      },
+      timer: {
+        addedTime: 0,
+        current: null,
+        duration: null,
+        elapsed: 0,
+        expectedFinish: null,
+        finishedAt: null,
+        phase: 'none',
+        playback: 'roll',
+        secondaryTimer: 168950,
+        startedAt: null,
+      },
+      _timer: {
+        forceFinish: null,
+        totalDelay: 0,
+        pausedAt: null,
+        secondaryTarget: 55860000,
+      },
+    } as RuntimeState;
+
+    const phase = getTimerPhase(state);
+    expect(phase).toBe(TimerPhase.Pending);
+  });
 });
diff --git a/apps/server/src/services/timerUtils.ts b/apps/server/src/services/timerUtils.ts
index 6237f8fe1..af3dc83d2 100644
--- a/apps/server/src/services/timerUtils.ts
+++ b/apps/server/src/services/timerUtils.ts
@@ -120,13 +120,13 @@ type RollTimers = {
  * @param {number} timeNow - time now in ms
  */
 export const getRollTimers = (rundown: OntimeEvent[], timeNow: number, currentIndex?: number | null): RollTimers => {
-  let nowIndex: number | null = null; // index of event now
-  let nowId: string | null = null; // id of event now
-  let publicIndex: number | null = null; // index of public event now
-  let nextIndex: number | null = null; // index of next event
-  let publicNextIndex: number | null = null; // index of next public event
-  let timeToNext: number | null = null; // counter: time for next event
-  let publicTimeToNext: number | null = null; // counter: time for next public event
+  let nowIndex: MaybeNumber = null; // index of event now
+  let nowId: MaybeString = null; // id of event now
+  let publicIndex: MaybeNumber = null; // index of public event now
+  let nextIndex: MaybeNumber = null; // index of next event
+  let publicNextIndex: MaybeNumber = null; // index of next public event
+  let timeToNext: MaybeNumber = null; // counter: time for next event
+  let publicTimeToNext: MaybeNumber = null; // counter: time for next public event
 
   const hasLoaded = currentIndex !== null;
   const canFilter = hasLoaded && currentIndex === rundown.length - 1;
diff --git a/apps/server/src/stores/runtimeState.ts b/apps/server/src/stores/runtimeState.ts
index 3c39be5e0..f0ef1acb0 100644
--- a/apps/server/src/stores/runtimeState.ts
+++ b/apps/server/src/stores/runtimeState.ts
@@ -466,6 +466,10 @@ export function roll(rundown: OntimeEvent[]) {
       current: endTime - runtimeState.clock,
     });
   } else if (nextEvent) {
+    if (nextEvent.isPublic) {
+      runtimeState.publicEventNext = nextEvent;
+    }
+    runtimeState.eventNext = nextEvent;
     // account for day after
     const nextStart = nextEvent.timeStart < runtimeState.clock ? nextEvent.timeStart + dayInMs : nextEvent.timeStart;
     // nothing now, but something coming up