import { ulid } from "ulid";

export type Task = {
  key: string;
  execute: () => Promise<void>;
};

type TaskStatus = {
  id: string;
  task: Task;
} & (
  | {
      status: "pending" | "completed" | "failed";
    }
  | {
      status: "running";
      promise: Promise<void>;
    }
);

type Options = {
  maxConcurrency: number;
};

export class TaskExecutor {
  private taskStatuses: TaskStatus[] = [];
  private executionPromise?: {
    resolve: () => void;
    reject: (reason?: unknown) => void;
    promise: Promise<void>;
  };
  private options: Options;

  constructor(options?: Partial<Options>) {
    this.options = {
      maxConcurrency: 10,
      ...options,
    };
  }

  private setExecutionPromise() {
    let resolveExecution: (() => void) | undefined;
    let rejectExecution: ((reason?: unknown) => void) | undefined;

    const promise = new Promise<void>((resolve, reject) => {
      resolveExecution = resolve;
      rejectExecution = reject;
    });

    if (resolveExecution === undefined || rejectExecution === undefined) {
      throw new Error("Illegal state: Promise not created");
    }

    this.executionPromise = {
      resolve: resolveExecution,
      reject: rejectExecution,
      promise,
    };
  }

  public setTasks(tasks: Task[]) {
    const newTaskStatuses: TaskStatus[] = tasks.map((task) => ({
      id: `${task.key}-${ulid()}`,
      status: "pending",
      task,
    }));

    this.taskStatuses.push(...newTaskStatuses);
  }

  private get pendingTasks() {
    return this.taskStatuses.filter((task) => task.status === "pending");
  }

  private get runningTasks() {
    return this.taskStatuses.filter((task) => task.status === "running");
  }

  private updateStatus(id: string, status: TaskStatus) {
    const found = this.taskStatuses.find((task) => task.id === id);

    if (!found) {
      throw new Error(`Task not found: ${id}`);
    }

    Object.assign(found, status);
  }

  public async execute() {
    this.setExecutionPromise();
    this.refresh();
    await this.executionPromise?.promise;
  }

  private refresh() {
    if (this.runningTasks.length === 0 && this.pendingTasks.length === 0) {
      this.executionPromise?.resolve();
      console.log("execution completed.");
      return;
    }

    const remainingTaskCount =
      this.options.maxConcurrency - this.runningTasks.length;

    if (remainingTaskCount <= 0) {
      return;
    }

    for (const task of this.pendingTasks.slice(0, remainingTaskCount)) {
      this.updateStatus(task.id, {
        id: task.id,
        status: "running",
        task: task.task,
        promise: (async () => {
          try {
            await task.task.execute();

            this.updateStatus(task.id, {
              id: task.id,
              status: "completed",
              task: task.task,
            });
          } catch (error) {
            console.error(error);

            this.updateStatus(task.id, {
              id: task.id,
              status: "failed",
              task: task.task,
            });
          } finally {
            this.refresh();
          }
        })(),
      });
    }
  }
}