Web version (work in progress)

7 files changed, 210 insertions, 20 deletions

diff --git a/web/adapter.cpp b/web/adapter.cpp
index 1774187..3613730 100644
--- a/web/adapter.cpp
+++ b/web/adapter.cpp
@@ -1,11 +1,15 @@
 #include "../cpp/nissy.h"
+#include "storage.h"
 
+#include <emscripten.h>
 #include <emscripten/bind.h>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
+EM_ASYNC_JS(void, fake_async, (), {});
+
 extern "C" {
         extern int addCallbackFunction(/* args intentionally unspecified */);
         extern void callFunction(int, const char *);
@@ -47,26 +51,43 @@ const std::set<std::string> available_solvers
 std::map<std::string, nissy::solver> loaded_solvers;
 
 // TODO: this should ask the user if they want to download or generate.
-// TODO: this should also save the data to a file (IDBFS / NODEFS)
 bool init_solver(const std::string& name)
 {
         auto se = nissy::solver::get(name);
         nissy::solver solver = std::get<nissy::solver>(se);
-        log("Generating data for solver " + solver.name + "\n");
-        auto err = solver.generate_data();
-        if (!err.ok()) {
-                log("Error generating the data!\n");
-                return false;
+
+        solver.data.resize(solver.size);
+        if (storage::read(solver.id, solver.size,
+            reinterpret_cast<char *>(solver.data.data()))) {
+                log("Data for solver " + solver.name + " read from storage\n");
+        } else {
+                log("Could not read data for solver " + solver.name +
+                    " from storage, generating it\n");
+                auto err = solver.generate_data();
+
+                if (!err.ok()) {
+                        log("Error generating the data!\n");
+                        return false;
+                }
         }
+
         log("Checking data integrity "
             "(this is done only once per session per solver)...\n");
         if (!solver.check_data().ok()) {
-                log("Error generating the data!\n");
+                log("Error! Data is corrupted!\n");
                 return false;
         }
         loaded_solvers.insert({name, solver});
-        log("Data generated successfully, but not saved "
-            "(feature not yet available)\n");
+
+        if (storage::write(solver.id, solver.size,
+            reinterpret_cast<const char *>(solver.data.data()))) {
+                log("Data for solver " + solver.name + " stored\n");
+        } else {
+                log("Error storing the data (the solver is usable, "
+                    "but the data will have to be re-generated next "
+                    "time you want to use it)");
+        }
+
         return true;
 }
 
@@ -87,17 +108,31 @@ bool solver_valid(const std::string& name)
 
 int poll_status(void *arg)
 {
+        return nissy::status::RUN.value;
+/*
+TODO: reintroduce poll status
         int id = *(int *)arg;
         if (id == -1)
                 return nissy::status::RUN.value;
         return callFunctionInt(id);
+*/
 }
 
+#if 0
+
 nissy::solver::solve_result solve(std::string name,
     nissy::cube cube, nissy::nissflag nissflag, unsigned minmoves,
     unsigned maxmoves, unsigned maxsols, unsigned optimal, unsigned threads,
     int poll_status_id)
 {
+        // Here we use a dirty trick to make this function always return the
+        // same kind of JavaScript object. If we did not do this, the returned
+        // object would be a Promise on the first run of the solver for each
+        // session (because when loading the table some async JS code is
+        // called), and a regular object otherwise.
+        // TODO figure out if there is a better way to do this.
+        fake_async();
+
         if (!solver_valid(name))
                 return nissy::solver::solve_result
                     {.err = nissy::error::INVALID_SOLVER};
@@ -106,6 +141,35 @@ nissy::solver::solve_result solve(std::string name,
             maxmoves, maxsols, optimal, threads, NULL, &poll_status_id);
 }
 
+#else
+
+std::string solve(std::string name,
+    nissy::cube cube, nissy::nissflag nissflag, unsigned minmoves,
+    unsigned maxmoves, unsigned maxsols, unsigned optimal, unsigned threads,
+    int poll_status_id)
+{
+        // Here we use a dirty trick to make this function always return the
+        // same kind of JavaScript object. If we did not do this, the returned
+        // object would be a Promise on the first run of the solver for each
+        // session (because when loading the table some async JS code is
+        // called), and a regular object otherwise.
+        // TODO figure out if there is a better way to do this.
+        fake_async();
+
+        if (!solver_valid(name))
+                return "";
+/*
+                return nissy::solver::solve_result
+                    {.err = nissy::error::INVALID_SOLVER};
+*/
+
+        return loaded_solvers.at(name).solve(cube, nissflag, minmoves,
+            maxmoves, maxsols, optimal, threads, NULL, &poll_status_id)
+            .solutions[0];
+}
+
+#endif
+
 EMSCRIPTEN_BINDINGS(Nissy)
 {
         emscripten::class_<nissy::nissflag>("NissFlag")
@@ -134,13 +198,11 @@ EMSCRIPTEN_BINDINGS(Nissy)
         emscripten::constant("statusRUN", nissy::status::RUN.value);
         emscripten::constant("statusSTOP", nissy::status::STOP.value);
         emscripten::constant("statusPAUSE", nissy::status::PAUSE.value);
-        /*
         emscripten::class_<nissy::status>("Status")
                 .class_property("run", &nissy::status::RUN)
                 .class_property("stop", &nissy::status::STOP)
                 .class_property("pause", &nissy::status::PAUSE)
                 ;
-        */
 
         emscripten::class_<nissy::cube>("Cube")
                 .constructor<>()
@@ -150,10 +212,17 @@ EMSCRIPTEN_BINDINGS(Nissy)
                 .function("toString", &nissy::cube::to_string)
                 ;
 
+        emscripten::register_vector<std::string>("StringVector");
+        emscripten::value_array<nissy::solver::solve_result>("SolveResult")
+                .element(&nissy::solver::solve_result::err)
+                .element(&nissy::solver::solve_result::solutions)
+                ;
+/*
         emscripten::class_<nissy::solver::solve_result>("SolveResult")
                 .property("err", &nissy::solver::solve_result::err)
                 .property("solutions", &nissy::solver::solve_result::solutions)
                 ;
+*/
 
         emscripten::function("countMoves", &nissy::count_moves);
         emscripten::function("solve", &solve,
diff --git a/web/callback.js b/web/callback.js
index 1b3028e..178b8e9 100644
--- a/web/callback.js
+++ b/web/callback.js
@@ -2,20 +2,44 @@ addToLibrary({
 
 cbfl: [],
 
+validateCallbackId__deps: [ 'cbfl' ],
+validateCallbackId: function(i) {
+  if (i < 0) {
+    console.log("--- WARNING ---");
+    console.log("Trying to access callback function of invalid id " + i);
+    console.log("--- WARNING ---");
+    return false;
+  }
+
+  if (i >= _cbfl.length) {
+    console.log("--- WARNING ---");
+    console.log("Trying to access callback function " + i + ", but only "
+      + _cbfl.length + " have been registered. This may be caused by a "
+      + "call outside of the main thread.");
+    console.log("--- WARNING ---");
+    return false;
+  }
+
+  return true;
+},
+
 addCallbackFunction__deps: [ 'cbfl' ],
 addCallbackFunction: function(f) {
   _cbfl.push(f)
   return _cbfl.length - 1
 },
 
-callFunction__deps: [ 'cbfl' ],
+callFunction__deps: [ 'cbfl', 'validateCallbackId' ],
 callFunction: function(id, arg) {
-  _cbfl[id](UTF8ToString(arg))
+  if (_validateCallbackId(id))
+    _cbfl[id](UTF8ToString(arg));
 },
 
-callFunctionInt__deps: [ 'cbfl' ],
+callFunctionInt__deps: [ 'cbfl', 'validateCallbackId' ],
 callFunctionInt: function(id) {
-  return _cbfl[id]()
+  if (_validateCallbackId(id))
+    return _cbfl[id]();
+  return 0;
 },
 
 });
diff --git a/web/examples/solve.mjs b/web/examples/solve.mjs
index c7bce71..8ff59c0 100644
--- a/web/examples/solve.mjs
+++ b/web/examples/solve.mjs
@@ -1,10 +1,12 @@
 import Nissy from '../nissy_web_module.mjs'
 
-const nissy = await Nissy()
+const nissy = await Nissy();
 
-nissy.setLogger(nissy._addCallbackFunction(console.log))
+var log = process.stdout.write.bind(process.stdout);
+//var log = console.log
+nissy.setLogger(nissy._addCallbackFunction(log))
 
-var cube = new nissy.Cube()
-cube.move('R\' U\' F')
+var cube = new nissy.Cube();
+cube.move('R\' U\' F');
 
-nissy.solve('h48h0k4', cube, nissy.NissFlag.normal, 0, 8, 2, 99, 4, -1)
+nissy.solve('h48h0k4', cube, nissy.NissFlag.normal, 0, 8, 2, 99, 4, -1);
diff --git a/web/http/index.html b/web/http/index.html
new file mode 100644
index 0000000..245205d
--- /dev/null
+++ b/web/http/index.html
@@ -0,0 +1,20 @@
+<!doctype html>
+<html lang="en-US">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width" />
+    <title>Nissy - H48 solver POC</title>
+    <script type="module" src="./solve.mjs"></script>
+  </head>
+  <body>
+    <input id="scrambleText" placeholder="Type the scramble here...">
+    <select id="solverSelector">
+      <option value="h48h0k4" selected="selected">h48 h=0 k=4 (59Mb)</option>
+      <option value="h48h3k2">h48 h=3 k=2 (283Mb)</option>
+      <option value="h48h7k2">h48 h=7 k=2 (3.6Gb)</option>
+    </select>
+    <button id="solveButton">Solve!</button>
+    <p>Solution:</p>
+    <p id="solution"></p>
+  </body>
+</html>
diff --git a/web/http/mime b/web/http/mime
new file mode 100644
index 0000000..8c956e1
--- /dev/null
+++ b/web/http/mime
@@ -0,0 +1 @@
+text/javascript       mjs
diff --git a/web/storage.cpp b/web/storage.cpp
new file mode 100644
index 0000000..4be3066
--- /dev/null
+++ b/web/storage.cpp
@@ -0,0 +1,67 @@
+#include "storage.h"
+
+#include "emscripten.h"
+#include <filesystem>
+#include <fstream>
+
+EM_JS(int, inbrowser, (), { return typeof window !== 'undefined'; });
+EM_JS(int, inworker, (), { return typeof WorkerGlobalScope !== 'undefined' &&
+    self instanceof WorkerGlobalScope; });
+
+std::string getprefix() {
+        return inbrowser() || inworker() ? "/tables/" : "./tables/";
+}
+
+EM_ASYNC_JS(int, loadfs, (), {
+  const dir = '/tables';
+  const inBrowser = typeof window !== 'undefined';
+  const inWorker = typeof WorkerGlobalScope !== 'undefined' &&
+    self instanceof WorkerGlobalScope;
+
+  if (!(inBrowser || inWorker)) return;
+
+  if (!FS.analyzePath(dir).exists)
+    FS.mkdir(dir);
+
+  if (FS.analyzePath(dir).object.mount.mountpoint != dir) {
+    FS.mount(IDBFS, { autoPersist: true }, dir);
+
+    await new Promise((resolve, reject) => {
+      FS.syncfs(true, function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(true);
+        }
+      });
+    });
+  }
+});
+
+bool storage::read(std::string key, size_t data_size, char *data)
+{
+        loadfs();
+
+        std::filesystem::path path(getprefix() + key);
+        if (!std::filesystem::exists(path))
+                return false;
+
+        std::ifstream ifs(path, std::ios::binary);
+        ifs.read(data, data_size);
+        ifs.close();
+
+        return !ifs.fail();
+}
+
+bool storage::write(std::string key, size_t data_size, const char *data)
+{
+        loadfs();
+
+        std::filesystem::path path(getprefix() + key);
+
+        std::ofstream ofs(path, std::ios::binary);
+        ofs.write(data, data_size);
+        ofs.close();
+
+        return !ofs.fail();
+}
diff --git a/web/storage.h b/web/storage.h
new file mode 100644
index 0000000..fa6b748
--- /dev/null
+++ b/web/storage.h
@@ -0,0 +1,7 @@
+#include <string>
+#include <fstream>
+
+namespace storage {
+        bool read(std::string, size_t, char *);
+        bool write(std::string, size_t, const char *);
+}