brackt/server/overnight-pause-check.ts

import * as schema from "~/database/schema";
import { eq, sql } from "drizzle-orm";
import type { InferSelectModel } from "drizzle-orm";
import { isInOvernightWindow, getOvernightResumeUTC } from "~/lib/overnight-pause";
import { logger } from "./logger";
import { db } from "./db";

// Cached per-season timezone map to avoid a redundant query on every overnight-pause check.
// timer.ts calls evictOvernightPauseCache() when a season leaves active drafting.
const teamTimezoneCache = new Map<string, Map<string, string | null>>();

async function getTeamTimezone(seasonId: string, teamId: string): Promise<string | null> {
  let seasonMap = teamTimezoneCache.get(seasonId);
  if (!seasonMap) {
    try {
      const rows = await db
        .select({ teamId: schema.teams.id, timezone: schema.users.timezone })
        .from(schema.teams)
        .leftJoin(schema.users, sql`${schema.teams.ownerId}::uuid = ${schema.users.id}`)
        .where(eq(schema.teams.seasonId, seasonId));
      seasonMap = new Map(rows.map((r) => [r.teamId, r.timezone || null]));
    } catch (err) {
      logger.error("[OvernightPause] getTeamTimezone failed:", err);
      seasonMap = new Map();
    }
    teamTimezoneCache.set(seasonId, seasonMap);
  }
  return seasonMap.get(teamId) ?? null;
}

export async function checkOvernightPause(
  season: InferSelectModel<typeof schema.seasons>,
  currentTeamId: string
): Promise<{ active: boolean; resumesAtUTC?: number }> {
  const mode = season.overnightPauseMode;
  const start = season.overnightPauseStart;
  const end = season.overnightPauseEnd;

  if (mode === "none" || !start || !end) return { active: false };

  let tz: string | null = null;
  if (mode === "league") {
    tz = season.overnightPauseTimezone || null;
  } else {
    tz = await getTeamTimezone(season.id, currentTeamId);
    if (!tz) tz = season.overnightPauseTimezone || null;
  }

  if (!tz) return { active: false };

  if (isInOvernightWindow(tz, start, end)) {
    const resumesAt = getOvernightResumeUTC(tz, end);
    return { active: true, resumesAtUTC: resumesAt.getTime() };
  }
  return { active: false };
}

export function evictOvernightPauseCache(seasonId: string): void {
  teamTimezoneCache.delete(seasonId);
}

export function overnightPauseCacheKeys(): IterableIterator<string> {
  return teamTimezoneCache.keys();
}

export function clearAllOvernightPauseCaches(): void {
  teamTimezoneCache.clear();
}