var wasm_solver = null
var word_count = 0
var words_str_len = 0
function init_wasm_solver(words_str) {
  words_str_len = words_str.length
  const fill_string = (offset) => {
    console.log("fill strings called " + offset)
    const str_buf = new Uint8Array(wasm_solver.exports.memory.buffer, offset)
    const buf = new TextEncoder().encode(words_str, "utf8")
    str_buf.set(buf, 0)
  }
  const log_num_idxs = i => {
    word_count = i
    console.log("wasm: found " + i + " words")
  }
  WebAssembly.instantiateStreaming(fetch("wordle_opt.wasm"), {
    env: {
      fill_string: fill_string,
      log_num_idxs: log_num_idxs,
    }
  }).then(wm => {
    wasm_solver = wm.instance

  })
}

function init_solver() {
  const exports = wasm_solver.exports
  console.log("wsl = ", words_str_len)
  const solver_ptr = wasm_solver.exports.init(words_str_len)
  return {
    ptr: solver_ptr,
    precalc: (nw) => exports.precalc(solver_ptr, nw),
    precalc_idx: () => exports.get_precalc(solver_ptr),
    precalc_done: () => exports.precalc_done(solver_ptr),

    reset: () => exports.reset(solver_ptr),
    eliminate_words: (guess_idx, guess_result) =>
        exports.eliminate_words(solver_ptr, guess_idx, guess_result),
    words_left: () => exports.words_left(solver_ptr),
    calc_entropy: (idx) => exports.calc_entropy(solver_ptr, idx),
    find_word: (w) => {
      const ary = new TextEncoder().encode(w, "utf8")
      const offset = exports.find_word_load(solver_ptr)
      const dst = new Uint8Array(exports.memory.buffer, offset, 5)
      dst.set(ary)
      return exports.find_word(solver_ptr)
    },
    best_word: () => {
      const idx = exports.best_word(solver_ptr)
      const entropy = exports.best_word_entropy(solver_ptr)
      console.log(idx)
      var word = null
      if (idx != -1) {
        const offset = exports.lookup_word(solver_ptr, idx)
        word_ary = new Uint8Array(exports.memory.buffer, offset, 5)
        word = new TextDecoder().decode(word_ary)
      }
      return [idx, entropy, word]
    },

    lookup_word: (idx) => {
      const offset = exports.lookup_word(solver_ptr, idx)
      if (offset == -1) return null
      word_ary = new Uint8Array(exports.memory.buffer, offset, 5)
      return new TextDecoder().decode(word_ary)
    },

    lookup_valid_word: (i) => {
      const idx = exports.get_valid_word(solver_ptr, i)
      if (idx != -1) {
        const offset = exports.lookup_word(solver_ptr, idx)
        word_ary = new Uint8Array(exports.memory.buffer, offset, 5)
        return new TextDecoder().decode(word_ary)
      } else {
        return null
      }
    }
  }
}