import type { Color } from "wordle-solver";
import SolverWorker from "./worker?worker";
import type { GuessResult, SolutionSpaceResult, EvaluateWordsResult, SolverRequest, SolverResponse, EvaluateWordsProgress } from "./types";

let solver_worker = new SolverWorker();
await init_solver();

let msg_id = 0;

const pending = new Map<number, {
  resolve: (value: any) => void;
  reject: (error: any) => void;
}>();

const progresses = new Map<number, (p: EvaluateWordsProgress) => void>();

function init_solver(): Promise<void> {
  return new Promise((resolve) => {
    solver_worker.onmessage = (event: any) => {
      if (event.data.type === "ready") {
        solver_worker.onmessage = workerHandleMsg;
        resolve();
      } else {
        workerHandleMsg(event);
      }
    };
  });
}

function create_solver_worker(): Promise<void> {
  solver_worker = new SolverWorker();

  return init_solver();
}

export function solver_guess(word: string[], colors: Color[]): Promise<GuessResult> {
  const id = msg_id++;

  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });

    const r: SolverRequest = {
      type: "guess",
      id: id,
      input: { word: word, colors: colors },
    };

    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
  });
}

export function solver_solution_space(): Promise<SolutionSpaceResult> {
  const id = msg_id++;

  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });

    const r: SolverRequest = {
      type: "solution_space",
      id: id,
      input: null,
    };

    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
  });
}

export function solver_evaluate_words(n: number, progress: ((p: EvaluateWordsProgress) => void) | null): Promise<EvaluateWordsResult> {
  const id = msg_id++;

  if (progress) {
    progresses.set(id, progress);
  }

  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });

    const r: SolverRequest = {
      type: "evaluate_words",
      id: id,
      input: { n },
    };

    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
  });
}

export async function solver_reset(wordle_answers: boolean): Promise<void> {
  solver_worker.terminate();

  await create_solver_worker();

  pending.forEach((v, _) => {
    v.reject("Solver was reset");
  });
  pending.clear();
  progresses.clear();

  const id = msg_id++;

  return new Promise((resolve, reject) => {
    pending.set(id, { resolve, reject });

    const r: SolverRequest = {
      type: "reload_wordlist",
      id: id,
      input: { use_wordle_ansers: wordle_answers },
    };

    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
  });
}


function workerHandleMsg(event: MessageEvent<SolverResponse>) {
  let res = event.data;

  if (res.type == "evaluate_words_progress") {
    let progress = progresses.get(res.id);

    if (progress) {
      progress(res.result);
    }

    return;
  }

  const pendingRequest = pending.get(res.id);

  if (!pendingRequest) {
    return;
  }

  pending.delete(res.id);
  progresses.delete(res.id);

  if (res.error) {
    pendingRequest.reject(res.error);
  } else if (res.result) {
    pendingRequest.resolve(res.result);
  } else {
    pendingRequest.reject("No result");
  }
}