import javax.imageio.*;

import java.awt.image.*;

import java.awt.*;

import java.security.NoSuchAlgorithmException;

import java.security.MessageDigest;

import java.lang.reflect.*;

import java.net.*;

import java.io.*;

import javax.swing.*;

import java.util.regex.*;

import java.util.List;

import java.util.zip.*;

import java.util.*;

public class main {

  public static void main(String[] args) throws Exception {

    String s = loadMainJava();

    // process include statements

    Matcher m = Pattern.compile("\n\\s*!include (#\\d+)").matcher(s);

    StringBuffer buf = new StringBuffer();

    while (m.find()) {

      String includedSrc = loadSnippet(m.group(1));

      m.appendReplacement(buf, m.quoteReplacement("\n" + includedSrc));

    }

    m.appendTail(buf);

    s = buf.toString();

    saveMainJava(s);

  }

 static String mainJava;

  static String loadMainJava() throws IOException {

    if (mainJava != null) return mainJava;

    return loadTextFile("input/main.java", "");

  }

  static void saveMainJava(String s) throws IOException {

    if (mainJava != null)

      mainJava = s;

    else

      saveTextFile("output/main.java", s);

  }

  static boolean preferCached = false;

  public static String loadSnippet(String snippetID) throws IOException {

    return loadSnippet(parseSnippetID(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);

  }

  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;

  }

  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"));

  }

  /** 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, "UTF-8");

    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 loadTextFile(String fileName, String defaultContents) throws IOException {

    if (!new File(fileName).exists())

      return defaultContents;

    FileInputStream fileInputStream = new FileInputStream(fileName);

    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");

    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);

  }

  public static String loadPage(String url) throws IOException {

    if (url.indexOf("://") < 0)

      url = "http://" + url;

    return loadPage(new URL(url));

  }

  public 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 = loadPage_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();

  }

  static String loadPage_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";

  }

}