export type PublishSchedulerRouting = "rabbitmq-primary" | "db-recovery";

type PublishTaskState = "queued" | "leasing" | "active";

export interface PublishSchedulerTaskRecord {
  taskId: string;
  platform: string;
  routing: PublishSchedulerRouting;
  state: PublishTaskState;
  enqueuedAt: number;
  updatedAt: number;
  lastStartedAt: number | null;
}

export interface PublishSchedulerSelection {
  taskId: string;
  platform: string;
  routing: PublishSchedulerRouting;
}

export interface PublishSchedulerSnapshot {
  queueDepth: number;
  queuedCount: number;
  leasingCount: number;
  activeCount: number;
  cooldownCount: number;
  tasks: PublishSchedulerTaskRecord[];
  cooldownUntil: Record<string, number>;
}

interface PublishSchedulerSelectionOptions {
  now?: number;
  maxConcurrency: number;
  activePlatforms?: ReadonlySet<string>;
  activeCount: number;
}

const publishPlatformCooldownMinMs = 3_000;
const publishPlatformCooldownMaxMs = 6_000;

const tasks = new Map<string, PublishSchedulerTaskRecord>();
const cooldownUntil = new Map<string, number>();

export function initPublishScheduler(): void {
  tasks.clear();
  cooldownUntil.clear();
}

export function enqueuePublishTask(input: {
  taskId: string;
  platform: string;
  routing: PublishSchedulerRouting;
}): void {
  const taskId = input.taskId.trim();
  const platform = input.platform.trim();
  if (!taskId || !platform) {
    return;
  }

  const now = Date.now();
  const existing = tasks.get(taskId);
  tasks.set(taskId, {
    taskId,
    platform,
    routing: input.routing,
    state: existing?.state === "active" ? "active" : "queued",
    enqueuedAt: existing?.enqueuedAt ?? now,
    updatedAt: now,
    lastStartedAt: existing?.lastStartedAt ?? null,
  });
}

export function selectNextPublishTask(
  options: PublishSchedulerSelectionOptions,
): PublishSchedulerSelection | null {
  const now = options.now ?? Date.now();
  pruneCooldowns(now);

  if (options.activeCount >= options.maxConcurrency) {
    return null;
  }

  const activePlatforms = new Set(options.activePlatforms ?? []);
  for (const task of tasks.values()) {
    if (task.state === "active" || task.state === "leasing") {
      activePlatforms.add(task.platform);
    }
  }

  const candidates = [...tasks.values()]
    .filter((task) => task.state === "queued")
    .sort((left, right) => {
      if (left.enqueuedAt !== right.enqueuedAt) {
        return left.enqueuedAt - right.enqueuedAt;
      }
      return left.updatedAt - right.updatedAt;
    });

  for (const candidate of candidates) {
    if (activePlatforms.has(candidate.platform)) {
      continue;
    }

    const platformCooldown = cooldownUntil.get(candidate.platform) ?? 0;
    if (platformCooldown > now) {
      continue;
    }

    candidate.state = "leasing";
    candidate.updatedAt = now;
    tasks.set(candidate.taskId, candidate);
    return {
      taskId: candidate.taskId,
      platform: candidate.platform,
      routing: candidate.routing,
    };
  }

  return null;
}

export function notePublishTaskActivated(taskId: string, platform: string): void {
  const normalizedTaskId = taskId.trim();
  const normalizedPlatform = platform.trim();
  if (!normalizedTaskId || !normalizedPlatform) {
    return;
  }

  const now = Date.now();
  const existing = tasks.get(normalizedTaskId);
  tasks.set(normalizedTaskId, {
    taskId: normalizedTaskId,
    platform: normalizedPlatform,
    routing: existing?.routing ?? "db-recovery",
    state: "active",
    enqueuedAt: existing?.enqueuedAt ?? now,
    updatedAt: now,
    lastStartedAt: now,
  });
}

export function notePublishTaskLeaseMiss(taskId: string): void {
  tasks.delete(taskId);
}

export function notePublishTaskCompleted(taskId: string, platform?: string): void {
  const existing = tasks.get(taskId);
  const resolvedPlatform = (platform ?? existing?.platform ?? "").trim();
  tasks.delete(taskId);

  if (resolvedPlatform) {
    cooldownUntil.set(resolvedPlatform, Date.now() + randomPublishCooldownMs());
  }
}

export function notePublishTaskCanceled(taskId: string): void {
  tasks.delete(taskId);
}

export function getPublishSchedulerSnapshot(): PublishSchedulerSnapshot {
  const now = Date.now();
  pruneCooldowns(now);
  const sortedTasks = [...tasks.values()].sort((left, right) => {
    if (left.state !== right.state) {
      return stateRank(left.state) - stateRank(right.state);
    }
    return left.enqueuedAt - right.enqueuedAt;
  });

  return {
    queueDepth: sortedTasks.filter((task) => task.state === "queued" || task.state === "leasing").length,
    queuedCount: sortedTasks.filter((task) => task.state === "queued").length,
    leasingCount: sortedTasks.filter((task) => task.state === "leasing").length,
    activeCount: sortedTasks.filter((task) => task.state === "active").length,
    cooldownCount: cooldownUntil.size,
    tasks: sortedTasks.map((task) => ({ ...task })),
    cooldownUntil: Object.fromEntries(cooldownUntil.entries()),
  };
}

function pruneCooldowns(now: number): void {
  for (const [platform, until] of cooldownUntil.entries()) {
    if (until <= now) {
      cooldownUntil.delete(platform);
    }
  }
}

function randomPublishCooldownMs(): number {
  const spread = publishPlatformCooldownMaxMs - publishPlatformCooldownMinMs;
  return publishPlatformCooldownMinMs + Math.floor(Math.random() * (spread + 1));
}

function stateRank(state: PublishTaskState): number {
  if (state === "active") {
    return 0;
  }
  if (state === "leasing") {
    return 1;
  }
  return 2;
}