import java.util.*;
import java.io.*;
import java.util.regex.*;
import java.net.*;

public class main {
  static String[] standardFunctions = {
    "#2000323/saveTextFile",
    "#2000322/loadTextFile",
    "#2000324/loadMainJava",
    "#2000325/saveMainJava",
    "#2000326/toLines",
    "#2000329/fromLines",
    "#2000330/loadSnippet",
    "#2000330/parseSnippetID",
    "#2000331/makeJavaStringLiteral",
    "#2000367/popupError",
    "#2000368/exitOnFrameClose",
    "#2000378/commonPrefix",
    "#2000379/commonSuffix",
    "#2000442/quote",
    "#2000471/unquote",
    "#2000444/cncToLines",
    "#2000460/bytesToHex",
    "#2000466/loadBinaryPage",
    "#2000464/saveBinaryFile"
  };
  
  public static void main(String[] args) throws IOException {
    String s = loadMainJava();
    List<String> defd = findFunctions(s);
    for (int i = 0; i < 2; i++)
      for (String x : standardFunctions) {
        String[] f = x.split("/");
        if (hasInvocation(s, f[1]) && !defd.contains(f[1])) {
          System.out.println("Adding function: " + f[1] + " (" + f[0] + ")");
          s = addFunction(s, f[0]);
          
          defd = findFunctions(s);
          //defd.add(f[1]);
        }
      }
    saveMainJava(s);
  }
  
  static boolean hasInvocation(String src, String f) {
    return src.indexOf(f) >= 0; // generous matching :)
  }
  
  static List<String> findFunctions(String src) {
    int[] main = findMain(src);
    src = src.substring(main[0], main[1]);
    /*int idx = src.indexOf("main {"); // yes it's a hack...
    if (idx >= 0) src = src.substring(idx);*/
    
    //System.out.println("Scanning for functions");
    List<String> functions = new ArrayList<String>();
    for (String line : toLines(src)) {
      Matcher matcher = Pattern.compile("static.*\\s+(\\w+)\\(").matcher(line);
      if (matcher.find()) {
        String f = matcher.group(1);
        functions.add(f);
        //System.out.println("Function found: " + f);
      }
    }
    return functions;
  }
  
  public static String addFunction(String s, String fID) throws IOException {
    int[] main = findMain(s);
    int i = s.lastIndexOf('}', main[1]);
    String function = loadSnippet(fID);
    return s.substring(0, i) + "\n" + function +"\n" + s.substring(i);
  }
  
  static findMain(String s) {
    List<String> tok = JavaTok.split(s);
    for (int i = 1; i+2 < tok.size(); i += 2)
      if (tok.get(i).equals("class") && tok.get(i+2).equals("main")) {
        int j = i;
        while (j < tok.size() && !tok.get(j).equals("{"))
          j += 2;
        int k = findEndOfBlock(tok, j);
        return new int[] {cncLength(tok, i), cncLength(tok, k)};
      }
      
    //throw new RuntimeException("main class not found");
    return new int[] {0, s.length()};
  }
  
  static int cncLength(List<String> cnc, int idx) {
    int l = 0;
    for (int i = 0; i < idx; i++)
      l += cnc.get(i).length();
    return l;
  }
  
  static int findEndOfBlock(List<String> cnc, int i) {
    int j = i+2, level = 1;
    while (j < cnc.size()) {
      if (cnc.get(j).equals("{")) ++level;
      else if (cnc.get(j).equals("}")) --level;
      if (level == 0)
        return j+1;
      ++j;
    }
    return cnc.size();
  }
  
  public static List<String> toLines(String s) {
    List<String> lines = new ArrayList<String>();
    int start = 0;
    while (true) {
      int i = toLines_nextLineBreak(s, start);
      if (i < 0) {
        if (s.length() > start) lines.add(s.substring(start));
        break;
      }

      lines.add(s.substring(start, i));
      if (s.charAt(i) == '\r' && i+1 < s.length() && s.charAt(i+1) == '\n')
        i += 2;
      else
        ++i;

      start = i;
    }
    return lines;
  }

  private static int toLines_nextLineBreak(String s, int start) {
    for (int i = start; i < s.length(); i++) {
      char c = s.charAt(i);
      if (c == '\r' || c == '\n')
        return i;
    }
    return -1;
  }
  
  static String loadMainJava() throws IOException {
    return loadTextFile("input/main.java", "");
  }
  
  static void saveMainJava(String s) throws IOException {
    saveTextFile("output/main.java", s);
  }
  
  static String charsetForTextFiles = "UTF-8";
  
  public static String loadTextFile(String fileName, String defaultContents) throws IOException {
    if (!new File(fileName).exists())
      return defaultContents;

    FileInputStream fileInputStream = new FileInputStream(fileName);
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, charsetForTextFiles);
    return loadTextFile(inputStreamReader);
  }

  public static String loadTextFile(Reader reader) throws IOException {
    StringBuilder builder = new StringBuilder();
    try {
      BufferedReader bufferedReader = new BufferedReader(reader);
      String line;
      while ((line = bufferedReader.readLine()) != null)
        builder.append(line).append('\n');
    } finally {
      reader.close();
    }
    return builder.length() == 0 ? "" : builder.substring(0, builder.length()-1);
  }
  
  /** writes safely (to temp file, then rename) */
  public static void saveTextFile(String fileName, String contents) throws IOException {
    File file = new File(fileName);
    File parentFile = file.getParentFile();
    if (parentFile != null)
      parentFile.mkdirs();
    String tempFileName = fileName + "_temp";
    FileOutputStream fileOutputStream = new FileOutputStream(tempFileName);
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, charsetForTextFiles);
    PrintWriter printWriter = new PrintWriter(outputStreamWriter);
    printWriter.print(contents);
    printWriter.close();
    if (file.exists() && !file.delete())
      throw new IOException("Can't delete " + fileName);

    if (!new File(tempFileName).renameTo(file))
      throw new IOException("Can't rename " + tempFileName + " to " + fileName);
  }  
  
  public static String loadSnippet(String snippetID) throws IOException {
    return loadSnippet(snippetID, preferCached);
  }
  
 public static String loadSnippet(String snippetID, boolean preferCached) throws IOException {
    return loadSnippet(parseSnippetID(snippetID), preferCached);
  }

  public static long parseSnippetID(String snippetID) {
    return Long.parseLong(shortenSnippetID(snippetID));
  }

  private static String shortenSnippetID(String snippetID) {
    if (snippetID.startsWith("#"))
      snippetID = snippetID.substring(1);
    String httpBlaBla = "http://tinybrain.de/";
    if (snippetID.startsWith(httpBlaBla))
      snippetID = snippetID.substring(httpBlaBla.length());
    return snippetID;
  }

  public static boolean isSnippetID(String snippetID) {
    snippetID = shortenSnippetID(snippetID);
    return isInteger(snippetID) && Long.parseLong(snippetID) != 0;
  }

  public static boolean isInteger(String s) {
    return Pattern.matches("\\-?\\d+", s);
  }
  
  static boolean preferCached = false;
  
  public static String loadSnippet(long snippetID) throws IOException {
    return loadSnippet(snippetID, preferCached);
  }

  public static String loadSnippet(long snippetID, boolean preferCached) throws IOException {
    if (preferCached) {
      initSnippetCache();
      String text = DiskSnippetCache_get(snippetID);
      if (text != null)
        return text;
    }

    String text;
    try {
      URL url = new URL("http://tinybrain.de:8080/getraw.php?id=" + snippetID);
      text = loadPage(url);
    } catch (FileNotFoundException e) {
      throw new IOException("Snippet #" + snippetID + " not found or not public");
    }

    try {
      initSnippetCache();
      DiskSnippetCache_put(snippetID, text);
    } catch (IOException e) {
      System.err.println("Minor warning: Couldn't save snippet to cache ("  + DiskSnippetCache_getDir() + ")");
    }

    return text;
  }

  private static String loadPage(URL url) throws IOException {
    System.out.println("Loading: " + url.toExternalForm());
    URLConnection con = url.openConnection();
    return loadPage(con, url);
  }

  public static String loadPage(URLConnection con, URL url) throws IOException {
    String contentType = con.getContentType();
    if (contentType == null)
      throw new IOException("Page could not be read: " + url);
    //Log.info("Content-Type: " + contentType);
    String charset = guessCharset(contentType);
    Reader r = new InputStreamReader(con.getInputStream(), charset);
    StringBuilder buf = new StringBuilder();
    while (true) {
      int ch = r.read();
      if (ch < 0)
        break;
      //Log.info("Chars read: " + buf.length());
      buf.append((char) ch);
    }
    return buf.toString();
  }

  public static String guessCharset(String contentType) {
    Pattern p = Pattern.compile("text/html;\\s+charset=([^\\s]+)\\s*");
    Matcher m = p.matcher(contentType);
    /* If Content-Type doesn't match this pre-conception, choose default and hope for the best. */
    return m.matches() ? m.group(1) : "ISO-8859-1";
  }
  
  static File DiskSnippetCache_dir;

  public static void initDiskSnippetCache(File dir) {
    DiskSnippetCache_dir = dir;
    dir.mkdirs();
  }

  public static synchronized String DiskSnippetCache_get(long snippetID) throws IOException {
    return loadTextFile(DiskSnippetCache_getFile(snippetID).getPath(), null);
  }

  private static File DiskSnippetCache_getFile(long snippetID) {
    return new File(DiskSnippetCache_dir, "" + snippetID);
  }

  public static synchronized void DiskSnippetCache_put(long snippetID, String snippet) throws IOException {
    saveTextFile(DiskSnippetCache_getFile(snippetID).getPath(), snippet);
  }

  public static File DiskSnippetCache_getDir() {
    return DiskSnippetCache_dir;
  }

  public static void initSnippetCache() {
    if (DiskSnippetCache_dir == null)
      initDiskSnippetCache(new File(System.getProperty("user.home"), ".tinybrain/snippet-cache"));
  }
}