!636
!quicknew
!688 // buf.isEmpty
!standard functions

abstract class Predictor {
  public abstract String predict(String s, int chars);
  public void preload(String s) {}
}

main {
  static new (Hash)Set<String> debug;
  
  psvm {
    String input = "abcdefghijklmnopqrstuvwxyz";
    new List<String> preloads;
    
    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      if (arg.equals("debug")) {
        String s = args[++i];
        debug.add(s);
        debugOn(s);
      } else if (isSnippetID(arg))
        input = loadSnippet(arg);
      else if (arg.equals("preload")) {
        String s = args[++i];
        preloads.add(loadSnippet(s));
      }
    }
 
    input = input.replace("\r", "");   
    
    new List<Predictor> predictors;
    add(predictors, new PLin, new PWords, new PIndent);
    
    for (Predictor p : predictors)
      for (String s : preloads)
        p.preload(s);
    
    new Collector globalCollector;
    int skips = 0, totalSkip = 0;
    new StringBuilder compacted;

    for (int splitPoint = 0; splitPoint < input.length(); splitPoint++) {
      String before = input.substring(0, splitPoint);
      String rest = input.substring(splitPoint);
      new Collector collector;
      for (Predictor p : predictors) {
        boolean doDebug = debug.contains(p.getClass().getName().replaceAll("^main\\$", ""));
        int chars = rest.length();
        String prediction = "";
        try {
          prediction = p.predict(before, chars);
          if (doDebug)
            System.out.println("Actual prediction: " + prediction);
        } catch (Throwable e) {
          // silent exception
        }
          
        // convenience result fixing for the predictors
        if (prediction == null) prediction = "";
        if (prediction.length() > chars)
          prediction = prediction.substring(0, chars);
          
        String actual = rest.length() > chars ? rest.substring(0, chars) : rest;
        int improvement = getScore2(prediction, actual);
        collector.add(p, prediction, improvement, splitPoint);
        
        if (doDebug) {
          String expected = actual.substring(0, Math.min(prediction.length()+5, rest.length()));
          System.out.println(splitPoint + "*" + improvement + " " + structure(p) + " -> " + quote(prediction) + " vs " + quote(expected) + " (error " + (actual.length()-improvement) + " of " + rest.length() + ")");
        }
        
        globalCollector.add(p, prediction, improvement, splitPoint);
      }
      
      int skip = 0;
      if (collector.bestScore > 0) {
        System.out.println(splitPoint + " " + collector.bestScore + " " + structure(collector.winner));
        
        skip = commonPrefix(rest, collector.winnerResult).length();
      }
       
      if (skip != 0) {
        System.out.println("Skipping " + skip + ": " + quote(collector.winnerResult.substring(0, skip)));
        splitPoint += skip-1;
        totalSkip += skip;
        ++skips;
        compacted.append('*');
      } else
        compacted.append(input.charAt(splitPoint));
    }
    
    System.out.println("\n" + compacted + "\n\n");
    
    System.out.println("Highest score seen: " + globalCollector.bestScore + " by " + structure(globalCollector.winner) + " at " + globalCollector.splitPoint);
    System.out.println("Total characters skipped: " + totalSkip + "/" + input.length() + " (skips: " + skips + ")");
  }
  
  static class Collector {
    Predictor winner;
    String winnerResult;
    long bestScore = -1;
    int splitPoint;
    
    void add(Predictor p, String result, long score, int splitPoint) {
      if (winner == null || score > bestScore) {
        winner = p;
        winnerResult = result;
        bestScore = score;
        this.splitPoint = splitPoint;
      }
    }
  }
  
  !include #1000388 // "leven" function (Levenshtein distance)
  
  /*static class P0 extends Predictor {
    public String predict(String s, int chars) {
      return "";
    }
  }
  
  static class P1 extends Predictor {
    public String predict(String s, int chars) {
      return s;
    }
  }*/
  
  static class PLin extends Predictor {
    public String predict(String s, int chars) {
      if (s.length() < 2) return "";
      char a = s.charAt(s.length()-2);
      char b = s.charAt(s.length()-1);
      int step = (char) (((int) b) - (int) a);
      new StringBuilder buf;
      for (int i = 0; i < chars; i++) {
        char c = (char) (((int) a) + step*(i+2));
        buf.append(c);
      }
      return buf.toString();
    }
  }
  
  static <C> void add(Collection<C> c, C... objects) {
    for (C x : objects) c.add(x);
  }
  
  static String structure(Object o) {
    String name = o.getClass().getName();
    
    new StringBuilder buf;
    
    if (o instanceof Collection) {
      for (Object x : (Collection) o) {
        if (!buf.isEmpty()) buf.append(", ");
        buf.append(structure(x));
      }
      return "{" + buf + "}";
    }
    
    // Need more cases? This should cover all library classes...
    if (name.startsWith("java.") || name.startsWith("javax."))
      return String.valueOf(o);
      
    String shortName = o.getClass().getName().replaceAll("^main\\$", "");

    // TODO: go to superclasses too
    Field[] fields = o.getClass().getDeclaredFields();
    for (Field field : fields) {
      if ((field.getModifiers() & Modifier.STATIC) != 0)
        continue;
      Object value;
      try {
        value = field.get(o);
      } catch (Exception e) {
        value = "?";
      }
      
      String fieldName = field.getName();
      
      // special case for PWords - show only number of preloaded words
      if (shortName.equals("PWords") && field.getName().equals("preloaded"))
        value = ((Collection) value).size();

      if (!buf.isEmpty()) buf.append(", ");
      buf.append(fieldName + "=" + structure(value));
    }
    String s = shortName;
    if (!buf.isEmpty())
      s += "(" + buf + ")";
    return s;
  }
  
  static int getScore1(String prediction, String rest) {
    int error = leven(prediction, rest);
    return rest.length()-error;
  }
  
  static int getScore2(String prediction, String rest) {
    return commonPrefix(prediction, rest).length();
  }
  
  static class PWords extends Predictor {
    static boolean debug;
    new (Tree)Set<String> preloaded;
    
    public void preload(String s) {
      preloaded.addAll(findWords(s));
    }
    
    public String predict(String s, int chars) {
      Set<String> words = findWords(s);
      words.addAll(preloaded);
      String word = match("\\w+$", s);
      if (word == null) return "";
      if (debug)
        System.out.println("Looking for: " + word);
      for (String w : words)
        if (w.startsWith(word)) {
          String pred = w.substring(word.length());
          if (debug)
            System.out.println("PWords: predicted " + quote(pred) + " for " + quote(word) + " based on word " + quote(w));
          return pred;
        }
      return "";
    }
    
    boolean firstTime = true;
    Set<String> findWords(String s) {
      Set<String> words = new TreeSet<String>(
        Collections.reverseOrder()); // important so partial matches come later
      words.addAll(matchAll("\\w+", s));
      if (debug && firstTime && s.length() >= 100) {
        firstTime = false;
        //System.out.println("Words found: " + structure(words));
      }
      return words;
    }
  }

  static String match(String pattern, String text) {
    List<String> matches = new ArrayList<String>();
    Matcher matcher = Pattern.compile(pattern).matcher(text);
    return matcher.find() ? matcher.group() : null;
  }
  
  static class PIndent extends Predictor {
    public String predict(String s, int chars) {
      int i = s.lastIndexOf('\n');
      int j = i+1;
      while (j < s.length() && (s.charAt(j) == ' ' || s.charAt(j) == '\t'))
        ++j;
      return "\n" + s.substring(i, j);
    }
  }
}