!636
!modern

main {
  static S programID;
  
  psvm {
    if (args.length == 0) {
      print("Hello, I'm The Learner.");
      L<S> log = loadLog();
      print("Last log entries:");
      for (int i = Math.max(0, log.size()-2); i < log.size(); i++)
        print("  " + log.get(i));
      return;
    }
    
    S a = args[0];

    List<S> prog = null, intent = null;
    
    if (a == "mappings") {
      print(structure(allMappings()));
      return;
    }
    
    if (a == "good" || a == "ok") {
      L<S> log = loadLog();
      /*for (int i = 0; i < log.size(); i++)
        print(i + ": " + log.get(i));*/
      if (log.size() < 2) confused("Too few log lines.");
      prog = (List) unstructure(log.get(log.size()-1));
      intent = (List) unstructure(log.get(log.size()-2));
      print("prog: " + prog);
      print("intent: " + intent);
      if (!prog.get(0).equals("program")) fail("prog: wrong type");
      if (!intent.get(0).equals("intent")) fail("intent: wrong type");
      S p = prog.get(1), i = intent.get(1);
      
      if (a != "ok") {
        print("map? (type 'ok')");
      } else {
        S map = findMapping(i);
        if (map != null)
          print("Remapping from " + map);
        if (p.equals(map))
          print("Same mapping exists, skipping.");
        else {
          print("Mapping.");
          addMapping(intent.get(1), prog.get(1));
          map = findMapping(i);
          boolean sane = p.equals(map);
          print("Done. Sanity check " + (sane ? "OK" : "not OK"));
        }
      }
    } else if (isSnippetID(a)) {
      logProgramRun(args);
      Class c = hotwire(a);
      callMain(c, drop(1, args));
    } else {
      boolean ok = args[args.length-1].equals("ok");
      if (ok) args = dropLast(args, 1);
      logIntent(args);
      S i = smartJoin(args);
      S map = findMapping(i);
      if (map == null)
        print("No mapping found for intent");
      else {
        if (ok) {
          print("Invoking program: #" + map);
          S[] _args = map.split(" ");
          Class c = hotwire(_args[0]);
          callMain(c, drop(1, _args));
        } else {
          print("Suggested program: #" + map);
          print("Type " + quote(i + " ok") + " to invoke.");
        }
      }
    }
  }
  
  static S logFile() {
    return new File(userHome(), ".javax/" + programID + "/learnerlog.txt").getPath();
  }
  
  static S mapFile() {
    return new File(userHome(), ".javax/" + programID + "/learnermap.txt").getPath();
  }
  
  static S smartJoin(S[] list) {
    return join(" ", list);
  }
  
  static void logIntent(S[] args) {
    stringLogAppend(structure(new Object[] {"intent", smartJoin(args)}));
    print("Logged intent: " + smartJoin(args));
  }
  
  static void logProgramRun(S[] args) {
    stringLogAppend(structure(new Object[] {"program", smartJoin(args)}));
  }
  
  static void stringLogAppend(S s) {
    appendToFile(logFile(), "\n" + s + "\n");
  }
  
  static void appendToFile(String path, String s) ctex {
    new File(path).getParentFile().mkdirs();
    print("[Logging to " + path + "]");
    Writer writer = new BufferedWriter(new OutputStreamWriter(
      new FileOutputStream(path, true), "UTF-8"));
    writer.write(s);
    writer.close();
  }
  
  static L<S> loadLog() ctex {
    return toLinesFullTrim(readTextFile(logFile(), ""));
  }
  
  static class Consumer {
    L<S> list;
    int i;
    
    *(L<S> *list) {}
    
    S get() { return i < list.size() ? list.get(i) : null; }
    void next() { if (i < list.size()) ++i; }
    void next(int n) { i = Math.min(list.size(), i+n); }
    boolean has() { return i < list.size(); }
    boolean is(S s) { return s.equals(get()); }
    boolean isNot(S s) { return !s.equals(get()); }
  }
  
  static O unstructure(S s) {
    L<S> tok = javaTok(s);
    Consumer con = new Consumer(tok);
    con.next(); // skip whitespace
    return unstructure(con);
  }
  
  static O unstructure(Consumer con) {
    S t = con.get();
    if (t.startsWith("\"")) {
      con.next(2);
      return unquote(t);
    }
    
    if (t.equals("null")) {
      con.next(2);
      return null;
    }
    
    if (t.equals("{")) {
      new L list;
      con.next(2);
      while (con.has() && con.isNot("}")) {
        if (!con.has()) break;
        if (con.is(","))
          con.next(2);
        O o = unstructure(con);
        list.add(o);
      }
      if (con.is("}")) con.next(2);
      return list;
    }
    
    throw todo(t);
  }
  
  static void addMapping(S intent, S prog) {
    S s = structure(new Object[] {"map", intent, prog});
    appendToFile(mapFile(), "\n" + s + "\n");
  }
  
  static Map<S, S> allMappings() ctex {
    L<S> list = toLinesFullTrim(readTextFile(mapFile(), ""));
    new Map<S, S> map;
    for (int i = list.size()-1; i >= 0; i--) { // start from end to get newest mappings
      S s = list.get(i);
      List x = cast unstructure(s);
      if (x.get(0).equals("map") && !map.containsKey(x.get(1)))
        map.put((S) x.get(1), (S) x.get(2));
    }
    return map;
  }
  
  static S findMapping(S intent) ctex {
    L<S> list = toLinesFullTrim(readTextFile(mapFile(), ""));
    for (int i = list.size()-1; i >= 0; i--) { // start from end to get newest mappings
      S s = list.get(i);
      List x = cast unstructure(s);
      if (x.get(0).equals("map") && x.get(1).equals(intent))
        return (S) x.get(2);
    }
    return null;
  }
}