// Logic thread

static class LThread {
  new L<Lisp> statements;
  new SNLMatches m; // current variable assignments
  L<Lisp> ops;
  int opIdx;
  new L<Lisp> output;
  L<S> log;
  
  *(Lisp code) {
    ops = splitOps(code);
  }
  
  boolean done() {
    ret opIdx >= l(ops);
  }
  
  // returns false if failed
  boolean step() {
    Lisp code = ops.get(opIdx++);
    boolean ok = stepImpl(code);
    if (log != null)
      log.add((ok ? "[OK] ": "[FAIL] ") + " step " + snlFromTree(code) + " with " + structure(m));
    ret ok;
  }
  
  boolean stepImpl(Lisp code) {
    if (code.isic("if *", "and *")) {
      Lisp a = code.get(0);
      Lisp b = snlApply(a, m.map);
      
      // try all statements in context
      
      for (Lisp s : statements) {
        S x;
        if (snlMatch2(b, s, m))
          ret true;
      }

      // try the low-level engine
      
      pcall {
        if (yo(b, m)) // todo: rename vars
          ret true;
      }

      // Not matched, fail
      ret false;
    }
    
    if (code.isic("say *")) {
      Lisp b = code.get(0);
      //print ("m: " + structure (m) + ", b: " + structure (b));
      output.add(snlApply(b, m.map));
      ret true;
    }
    
    if (code.isic("memorize *")) {
      Lisp b = snlApply(code.get(0), m.map);
      callOpt(mc(), "memorize", b);
      ret true;
    }
    
    // unknown code
    ret false;
  }
  
  // true if succeeded, false if failed
  boolean run() {
    while (!done())
      if (!step()) {
        print("fail");
        ret false;
      }
    ret true;
  }
  
  // split smth like "if * then *" into "if *" and "then *"
  L<Lisp> splitOps(Lisp code) {
    S ops = code.head;
    L<S> tok = codeTokensOnly(javaTok(ops));
    new L<Lisp> out;
    for (int i = 0; i < l(tok); i += 2) {
      S op = tok.get(i);
      assertEquals("*", tok.get(i+1));
      out.add(lisp(op + " *", code.get(i/2)));
    }
    print("splitOps => " + structure(out));
    ret out;
  }
}