brackt/server/timer.ts

import * as schema from "~/database/schema";
import { eq, and, asc, lte, isNotNull } from "drizzle-orm";
import type { InferSelectModel } from "drizzle-orm";
import { getSocketIO } from "./socket";
import { executeAutoPick, calculatePickInfo } from "~/models/draft-utils";
import { isInOvernightWindow, getOvernightResumeUTC } from "~/lib/overnight-pause";
import { logger } from "./logger";
import { db } from "./db";
import { startDraft } from "~/services/draft-autostart";

// Per-season in-memory state
const pickTimeouts = new Map<string, NodeJS.Timeout>();         // seasonId → active setTimeout
const overnightResumeTimeouts = new Map<string, NodeJS.Timeout>(); // seasonId → resume setTimeout
const schedulingInProgress = new Set<string>();                 // prevents concurrent scheduling

// Draft slots never change during an active draft — cache them to avoid a redundant query.
const draftSlotsCache = new Map<string, { teamId: string; draftOrder: number }[]>();

// Team timezone cache for per_user overnight pause mode (seasonId → teamId → timezone).
const teamTimezoneCache = new Map<string, Map<string, string | null>>();

let recoveryInterval: NodeJS.Timeout | null = 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, eq(schema.teams.ownerId, schema.users.id))
        .where(eq(schema.teams.seasonId, seasonId));
      seasonMap = new Map(rows.map((r) => [r.teamId, r.timezone || null]));
    } catch (err) {
      logger.error("[Timer] getTeamTimezone failed:", err);
      seasonMap = new Map();
    }
    teamTimezoneCache.set(seasonId, seasonMap);
  }
  return seasonMap.get(teamId) ?? null;
}

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 };
}

async function getDraftSlotsCached(seasonId: string): Promise<{ teamId: string; draftOrder: number }[]> {
  let slots = draftSlotsCache.get(seasonId);
  if (!slots) {
    slots = await db.query.draftSlots.findMany({
      where: eq(schema.draftSlots.seasonId, seasonId),
      orderBy: asc(schema.draftSlots.draftOrder),
    });
    draftSlotsCache.set(seasonId, slots);
  }
  return slots;
}

async function checkAndAutoStartDrafts(): Promise<void> {
  const io = getSocketIO();
  const seasonsToStart = await db.query.seasons.findMany({
    where: and(
      eq(schema.seasons.status, "pre_draft"),
      eq(schema.seasons.autoStartDraft, true),
      isNotNull(schema.seasons.draftDateTime),
      lte(schema.seasons.draftDateTime, new Date())
    ),
  });

  for (const season of seasonsToStart) {
    logger.log(`[Timer] Auto-starting draft for season ${season.id}`);
    const result = await startDraft({
      seasonId: season.id,
      actorUserId: "system",
      actorDisplayName: "System (auto-start)",
      db,
      io,
    });
    if (result.success) continue;
    if (result.error === "Draft already started or completed") continue;

    logger.error(`[Timer] Auto-start failed for season ${season.id}: ${result.error}`);

    if (result.error === "No draft slots found for this season") {
      await db
        .update(schema.seasons)
        .set({ autoStartDraft: false })
        .where(eq(schema.seasons.id, season.id));
      logger.log(`[Timer] Disabled autoStartDraft for season ${season.id} — no draft order set`);
    }
  }
}

function cancelPickTimeout(seasonId: string): void {
  const existing = pickTimeouts.get(seasonId);
  if (existing) {
    clearTimeout(existing);
    pickTimeouts.delete(seasonId);
  }
}

function cancelOvernightResumeTimeout(seasonId: string): void {
  const existing = overnightResumeTimeouts.get(seasonId);
  if (existing) {
    clearTimeout(existing);
    overnightResumeTimeouts.delete(seasonId);
  }
}

async function pauseDraftOnError(seasonId: string, teamId: string): Promise<void> {
  logger.error(`[Timer] Pausing draft ${seasonId} — pick failed for team ${teamId}`);
  await db.update(schema.seasons).set({ draftPaused: true }).where(eq(schema.seasons.id, seasonId));
  try {
    getSocketIO().to(`draft-${seasonId}`).emit("draft-paused", { seasonId, paused: true });
  } catch (err) {
    logger.error("[Timer] Failed to emit draft-paused:", err);
  }
}

async function triggerAutoPick(
  seasonId: string,
  teamId: string,
  pickNumber: number,
  autodraftSettings: InferSelectModel<typeof schema.autodraftSettings> | null
): Promise<boolean> {
  try {
    const result = await executeAutoPick({
      seasonId,
      teamId,
      pickNumber,
      triggeredBy: "timer",
      autodraftSettings,
      db,
    });

    if (!result.success) {
      if (result.error === "Pick already made") return true;
      logger.error(`[Timer] Auto-pick failed: ${result.error}`);
      return false;
    }

    return true;
  } catch (error) {
    logger.error("[Timer] Error in triggerAutoPick:", error);
    return false;
  }
}

// Core scheduling logic — called after acquiring the schedulingInProgress lock.
async function _schedulePickForSeason(seasonId: string): Promise<void> {
  const season = await db.query.seasons.findFirst({
    where: eq(schema.seasons.id, seasonId),
  });
  if (!season || season.status !== "draft" || season.draftPaused) return;

  const draftSlots = await getDraftSlotsCached(seasonId);
  const totalTeams = draftSlots.length;
  if (totalTeams === 0) return;

  const currentPickNumber = season.currentPickNumber ?? 1;
  const { pickInRound } = calculatePickInfo(currentPickNumber, totalTeams);
  const currentDraftSlot = draftSlots.find((s) => s.draftOrder === pickInRound);
  if (!currentDraftSlot) return;

  const currentTeamId = currentDraftSlot.teamId;

  const autodraftSettings = await db.query.autodraftSettings.findFirst({
    where: and(
      eq(schema.autodraftSettings.seasonId, seasonId),
      eq(schema.autodraftSettings.teamId, currentTeamId)
    ),
  });
  const shouldAutodraft = autodraftSettings?.isEnabled ?? false;
  const isWhileOn = shouldAutodraft && autodraftSettings?.mode === "while_on";

  if (isWhileOn) {
    logger.log(`[Timer] ⚡ while_on autodraft — immediate pick for team ${currentTeamId} in season ${seasonId} (pick ${currentPickNumber})`);
    try {
      getSocketIO().to(`draft-${seasonId}`).emit("timer-pick-started", {
        seasonId,
        teamId: currentTeamId,
        pickNumber: currentPickNumber,
        expiresAt: Date.now(),
        timeRemaining: 0,
      });
    } catch (_) { /* non-fatal */ }

    const success = await triggerAutoPick(seasonId, currentTeamId, currentPickNumber, autodraftSettings ?? null);
    if (!success) {
      await pauseDraftOnError(seasonId, currentTeamId);
      return;
    }
    // The chain may have advanced currentPickNumber past all while_on teams — reschedule.
    await _schedulePickForSeason(seasonId);
    return;
  }

  // Overnight pause: freeze timer; schedule a wakeup for when the window ends.
  const overnightPause = await checkOvernightPause(season, currentTeamId);
  const isOvernightFreeze = overnightPause.active && !shouldAutodraft;

  if (isOvernightFreeze) {
    try {
      getSocketIO().to(`draft-${seasonId}`).emit("timer-overnight-paused", {
        seasonId,
        teamId: currentTeamId,
        resumesAtUTC: overnightPause.resumesAtUTC,
      });
    } catch (_) { /* non-fatal */ }

    if (overnightPause.resumesAtUTC) {
      const msUntilResume = Math.max(0, overnightPause.resumesAtUTC - Date.now());
      const resumeTimeout = setTimeout(async () => {
        overnightResumeTimeouts.delete(seasonId);
        await schedulePickForSeason(seasonId);
      }, msUntilResume + 2_000); // 2 s buffer in case clocks drift
      overnightResumeTimeouts.set(seasonId, resumeTimeout);
    }
    return;
  }

  // Get or create timer row for this team.
  let timer = await db.query.draftTimers.findFirst({
    where: and(
      eq(schema.draftTimers.seasonId, seasonId),
      eq(schema.draftTimers.teamId, currentTeamId)
    ),
  });

  if (!timer) {
    const initialTime =
      season.draftTimerMode === "standard"
        ? (season.draftIncrementTime || 30)
        : (season.draftInitialTime || 120);
    const startedAt = new Date();
    const expiresAt = new Date(startedAt.getTime() + initialTime * 1000);
    await db.insert(schema.draftTimers).values({
      seasonId,
      teamId: currentTeamId,
      timeRemaining: initialTime,
      picksExpiresAt: expiresAt,
      picksStartedAt: startedAt,
    });
    // Re-fetch to get the full row (including generated id)
    timer = await db.query.draftTimers.findFirst({
      where: and(
        eq(schema.draftTimers.seasonId, seasonId),
        eq(schema.draftTimers.teamId, currentTeamId)
      ),
    });
    if (!timer) return; // unexpected
  }

  const now = Date.now();
  let expiresAt: Date;

  if (timer.picksExpiresAt && timer.picksExpiresAt.getTime() > now) {
    // Timer was already running (e.g. process restarted mid-pick). Honour the existing expiry.
    expiresAt = timer.picksExpiresAt;
  } else {
    // Fresh start of this team's turn (normal path after a pick or on startup).
    const bank = timer.timeRemaining;
    if (bank <= 0) {
      // Bank depleted — trigger autopick immediately.
      const success = await triggerAutoPick(
        seasonId,
        currentTeamId,
        currentPickNumber,
        shouldAutodraft ? (autodraftSettings ?? null) : null
      );
      if (!success) { await pauseDraftOnError(seasonId, currentTeamId); return; }
      await _schedulePickForSeason(seasonId);
      return;
    }
    expiresAt = new Date(now + bank * 1000);
    await db
      .update(schema.draftTimers)
      .set({ picksExpiresAt: expiresAt, picksStartedAt: new Date() })
      .where(
        and(
          eq(schema.draftTimers.seasonId, seasonId),
          eq(schema.draftTimers.teamId, currentTeamId)
        )
      );
  }

  const msUntilExpiry = expiresAt.getTime() - now;
  const timeRemaining = Math.max(0, Math.ceil(msUntilExpiry / 1000));

  // Tell clients to start their local countdown.
  try {
    getSocketIO().to(`draft-${seasonId}`).emit("timer-pick-started", {
      seasonId,
      teamId: currentTeamId,
      pickNumber: currentPickNumber,
      expiresAt: expiresAt.getTime(),
      timeRemaining,
    });
  } catch (_) { /* non-fatal */ }

  if (msUntilExpiry <= 0) {
    // Already expired (e.g. picked up on recovery interval after a long pause).
    const success = await triggerAutoPick(
      seasonId,
      currentTeamId,
      currentPickNumber,
      shouldAutodraft ? (autodraftSettings ?? null) : null
    );
    if (!success) { await pauseDraftOnError(seasonId, currentTeamId); return; }
    await _schedulePickForSeason(seasonId);
    return;
  }

  const timeout = setTimeout(async () => {
    pickTimeouts.delete(seasonId);
    logger.log(
      `[Timer] ⚠️  Timer expired for team ${currentTeamId} in season ${seasonId} (pick ${currentPickNumber})`
    );
    const success = await triggerAutoPick(
      seasonId,
      currentTeamId,
      currentPickNumber,
      shouldAutodraft ? (autodraftSettings ?? null) : null
    );
    if (!success) {
      await pauseDraftOnError(seasonId, currentTeamId);
      return;
    }
    await schedulePickForSeason(seasonId);
  }, msUntilExpiry);

  pickTimeouts.set(seasonId, timeout);
}

async function schedulePickForSeason(seasonId: string): Promise<void> {
  if (schedulingInProgress.has(seasonId)) return;
  schedulingInProgress.add(seasonId);
  try {
    await _schedulePickForSeason(seasonId);
  } catch (err) {
    logger.error(`[Timer] schedulePickForSeason error for ${seasonId}:`, err);
  } finally {
    schedulingInProgress.delete(seasonId);
  }
}

async function scheduleAllActiveDrafts(): Promise<void> {
  await checkAndAutoStartDrafts();

  const activeDrafts = await db.query.seasons.findMany({
    where: eq(schema.seasons.status, "draft"),
  });

  // Evict caches for seasons no longer drafting.
  const activeIds = new Set(activeDrafts.map((s) => s.id));
  for (const id of draftSlotsCache.keys()) {
    if (!activeIds.has(id)) draftSlotsCache.delete(id);
  }
  for (const id of teamTimezoneCache.keys()) {
    if (!activeIds.has(id)) teamTimezoneCache.delete(id);
  }

  for (const season of activeDrafts) {
    // Only schedule if not already scheduled (avoids duplicate timeouts).
    if (!pickTimeouts.has(season.id) && !overnightResumeTimeouts.has(season.id)) {
      await schedulePickForSeason(season.id);
    }
  }
}

export function startDraftTimerSystem(): void {
  if (recoveryInterval) {
    logger.log("[Timer] Timer system already running");
    return;
  }

  // Schedule any in-progress drafts immediately on startup.
  scheduleAllActiveDrafts().catch((err) =>
    logger.error("[Timer] Error during startup scheduling:", err)
  );

  // Recovery interval: re-schedule any draft whose in-memory timeout was lost
  // (process restart, overnight pause end, etc.). Runs every 30 s, not every 1 s.
  recoveryInterval = setInterval(() => {
    scheduleAllActiveDrafts().catch((err) =>
      logger.error("[Timer] Error in recovery interval:", err)
    );
  }, 30_000);

  logger.log("[Timer] Draft timer system started (event-driven)");
}

export function stopDraftTimerSystem(): void {
  if (recoveryInterval) {
    clearInterval(recoveryInterval);
    recoveryInterval = null;
  }
  for (const t of pickTimeouts.values()) clearTimeout(t);
  pickTimeouts.clear();
  for (const t of overnightResumeTimeouts.values()) clearTimeout(t);
  overnightResumeTimeouts.clear();
  schedulingInProgress.clear();
  draftSlotsCache.clear();
  teamTimezoneCache.clear();
  logger.log("[Timer] Draft timer system stopped");
}

/**
 * Called by pick routes after a pick is made so the timer immediately
 * reschedules for the next team rather than waiting for the recovery interval.
 */
export async function rescheduleTimer(seasonId: string): Promise<void> {
  cancelPickTimeout(seasonId);
  cancelOvernightResumeTimeout(seasonId);
  draftSlotsCache.delete(seasonId); // pick may have changed the draft order state
  await schedulePickForSeason(seasonId);
}