// Idea: For every position, store the productions recognized to start there, then infer up to higher classes

!752

// a recognition is identified by (startPos, className, endPos)


// key 1 = start position, key 2 = class name, value = end position
static Map<Integer, MultiMap<S, Integer>> recog;

static MultiMap<S, L<S>> productionMap = new MultiMap;

static boolean debug = false;

p {
  S rulesText = loadSnippet("#1002281");
  S inputText = loadSnippet("#1002286") + "\n" + loadSnippet("#1002280");
  S mainProd = "line";
  
  for (S rule : toLinesFullTrim(rulesText)) pcall {
    //printF("Processing rule: *", rule);
    L<S> lr = splitAtJavaToken(rule, "=");
    if (l(lr) != 2) {
      print("Weird rule: " + rule);
      continue;
    }
    S l = lr.get(0), r = lr.get(1);
    L<S> tokr = javaTok(r);
    assertEquals(structure(tokr), 3, l(tokr));
    S className = assertIdentifier(get(tokr, 1));
    L<S> tok = javaTok(l);
    tok = mergeBracketThingies(tok);
    //printStructure(tok);
    productionMap.put(className, tok);
  }
  
  print(n(productionMap.size(), "production") + ".");
  print();
  
  for (S line : toLinesFullTrim(inputText)) {
    print();
    print(line);
    L<S> tok = javaTok(line);
    //printStructure(tok);
    Pos pos = new Pos(tok);
    L<Integer> x = parseTop(pos, mainProd);
    if (x.contains(l(tok)))
      print("  parsed");
    else if (!empty(x))
      print("  beginning matches");
    else
      print("  not parsed");
    print("  " + structure(recog));
    if (!empty(x)) {
      L out = explainMatch(new Pos(tok), x.get(0), mainProd);
      print("Analysis: " + structure(out));
    }
  }
}

static L<Integer> parseTop(Pos pos, S mainProd) {
  // init structures
  recog = new TreeMap;
  for (int i = pos.i; i < l(pos.tok); i += 2)
    recog.put(i, new MultiMap);

  boolean anyChange;
  do {
    anyChange = false;
    for (int i = pos.i; i < l(pos.tok); i += 2) {
      Pos pos2 = new Pos(pos.tok, i);
      for (S className : productionMap.keySet()) {
        MultiMap<S, Integer> rr = recog.get(i);
        L<Integer> recs = rr.getActual(className);
        L<L<S>> prods = productionMap.get(className);
        for (L<S> prod : prods) {
          int n = l(recs);
          matchProd(pos2, new Pos(prod), className, recs);
          anyChange = anyChange || l(recs) > n;
        }
        rr.clean(className);
      }
    }
  } while (anyChange);
  
  ret recog.get(pos.i).get(mainProd);
}

static class Pos {
  L<S> tok;
  int i = 1;
  
  *() {}
  *(L<S> *tok) {}
  *(L<S> *tok, int *i) {}
  
  boolean end() { ret i >= l(tok)-1; }
  S get() { ret tok.get(i); }
  public Pos clone() { ret new Pos(tok, i); }
  public boolean equals(O o) {
    if (!(o instanceof Pos)) ret false;
    Pos pos = cast o;
    ret tok == pos.tok && i == pos.i;
  }
  
  S rest() {
    ret join(subList(tok, i));
  }

  Pos plus(int x) { ret new Pos(tok, i + x); }
}

static void copy(Pos a, Pos b) {
  b.tok = a.tok;
  b.i = a.i;
}

static void debug(S bla, Pos pos) {
  if (debug)
    print(bla + " on " + quote(pos.rest()));
}

static void matchProd(Pos pos, Pos prod, S forClass, L<Integer> out) {
  if (prod.end())
    setAdd(out, pos.i);
  else {
    S p = prod.get();
    
    if (isBracketedID(p) && neq(p, "<quoted>")) {
      L<Integer> r = recog.get(pos.i).get(unbracket(p));
      
      // keep parsing for every option
  
      for (int i : cloneList(r))
        matchProd(new Pos(pos.tok, i), prod.plus(2), forClass, out);
      
    } else {
      // it's a literal
      if (pos.end()) ret; // need a token to match
      S t = pos.get();
      if (!matchToken(p, t))
        ret;
      
      matchProd(pos.plus(2), prod.plus(2), forClass, out);
    }
  }
}

static boolean matchToken(S p, S t) {
  if (eq(p, "<quoted>")) {
    if (!isQuoted(t)) ret false;
  } else if (!(eq(p, "*") || eqic(p, t)))
    ret false; // token mismatch
  ret true;
}

// assumes that there is a match (pos, class, endPos)
// and gives explanations of how it was probably matched
static L explainMatch(Pos pos, int endPos, S forClass) {
  L<L<S>> prods = productionMap.get(forClass);
  new L out;
  for (L<S> prod : prods)
    explainMatch2(pos, new Pos(prod), endPos, forClass, litlist(forClass, join(prod)), out);
  ret out;
}

// same, but with fixed production
static void explainMatch2(Pos pos, Pos prod, int endPos, S forClass, L match, L out) {
  if (prod.end()) {
    if (pos.i == endPos)
      out.add(cloneList(match));
  } else {
    S p = prod.get();
    
    if (isBracketedID(p) && neq(p, "<quoted>")) {
      S className = unbracket(p);
      L<Integer> r = recog.get(pos.i).get(className);

      // keep parsing for every option
  
      for (int i : cloneList(r)) {
        match.add(litlist(pos.i, i));
        explainMatch2(new Pos(pos.tok, i), prod.plus(2), endPos, forClass, match, out);
        removeLast(match);
      }
    } else {
      // it's a literal
      if (pos.end()) ret; // need a token to match
      S t = pos.get();
      if (!matchToken(p, t))
        ret;
      
      //match.add(litlist(pos.i, p, pos.i+2));
      explainMatch2(pos.plus(2), prod.plus(2), endPos, forClass, match, out);
      removeLast(match);
    }
  }
}