import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
  Changes to v3:
  Includes "Lua print to Java print"
 */

public class javax4 {
  static boolean verbose = false;
  static boolean v2mode = false;

  private static String isCompilable = "http://tinybrain.de/"
    + /*"564"*/"1000251"; // silenced version (but I think we're silencing now anyway)
  private static String isCompilableHash = "8fe3851d7a686b60546a2429a2bde0d9";

  private static String mainAdder = "http://tinybrain.de/1000252";
  private static String mainAdderHash = "ce1e89785facd87ea64a6d9ad16a7aec";

  public static void main(String[] args) throws IOException {
    File ioBaseDir = new File(".");
    String src = ".";
    for (int i = 0; i < args.length; i++) {
      String arg = args[i];
      if (arg.equals("-v"))
        verbose = true;
      else if (arg.equals("-v2"))
        v2mode = true;
      else
        src = arg;
    }

    javax4(src, ioBaseDir);
  }

  public static void javax4(String src, File ioDir) throws IOException {
    File srcDir;
    if (isSnippetID(src))
      srcDir = loadSnippetAsMainJava(src);
    else
      srcDir = new File(src);
    Input X = programToInput(srcDir);

    if (!v2mode) {
      boolean compilable = isCompilable(X);
      if (verbose) System.out.println("Compilable: " + compilable);
      if (!compilable) {
        X = expandProgram(X);
        File file = new File(X.dir, "main.java");
        String program = loadTextFile(file.getPath(), null);
        if (verbose) System.out.println("New program:\n" + program);
        if (program == null)
          throw new RuntimeException("Expansion failed (tried: " + file.getPath() + ")");
      }
    }

    Input Y = luaPrintToJavaPrint(X);
    javax2(Y.dir, ioDir, false);
  }

  private static Input luaPrintToJavaPrint(Input x) throws IOException {
    File newDir = TempDirMaker.make();
    String code = loadTextFile(new File(x.dir, "main.java").getPath(), null);
    code = luaPrintToJavaPrint(code);
    if (verbose)
      System.out.println(code);
    saveTextFile(new File(newDir, "main.java").getPath(), code);
    return new Input(newDir);
  }

  public static String luaPrintToJavaPrint(String code) {
    return ("\n" + code).replaceAll(
      "(\n\\s*)print (\".*\")",
      "$1System.out.println($2);").substring(1);
  }

  public static File loadSnippetAsMainJava(String snippetID) throws IOException {
    File srcDir = TempDirMaker.make();
    saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippet(snippetID, false));
    return srcDir;
  }

  public static File loadSnippetAsMainJavaVerified(String snippetID, String hash) throws IOException {
    File srcDir = TempDirMaker.make();
    saveTextFile(new File(srcDir, "main.java").getPath(), loadSnippetVerified(snippetID, hash));
    return srcDir;
  }

  private static Input expandProgram(Input x) throws IOException {
    return runJavaX2_on_snippet(mainAdder, mainAdderHash, x, true);
  }

  private static boolean isCompilable(Input x) throws IOException {
    Input output = runJavaX2_on_snippet(isCompilable, isCompilableHash, x, true);
    return output.hasFile("is-compilable");
  }

  private static Input runJavaX2_on_snippet(String snippetID, String hash, Input x, boolean silent) throws IOException {
    File srcDir = loadSnippetAsMainJavaVerified(snippetID, hash);
    return runJavaX(new Input(srcDir), x, silent);
  }

  private static Input runJavaX(Input originalSrcDir, Input originalInput, boolean silent) throws IOException {
    File ioBaseDir = TempDirMaker.make();
    File srcDir = new File(ioBaseDir, "src");
    File inputDir = new File(ioBaseDir, "input");
    Input input = new Input(inputDir);
    File outputDir = new File(ioBaseDir, "output");
    Input output = new Input(outputDir);
    copyInput(originalSrcDir, new Input(srcDir));
    copyInput(originalInput, input);
    javax2(srcDir, ioBaseDir, silent);
    return output;
  }

  private static void copyInput(Input src, Input dst) throws IOException {
    copyDirectory(src.dir, dst.dir);
  }

  private static Input programToInput(File srcDir) {
    return new Input(srcDir);
  }

  static class Input {
    File dir;

    public Input(File dir) {
      this.dir = dir;
    }

    public boolean hasFile(String name) {
      return new File(dir, name).exists();
    }
  }

  public static void copyDirectory(File src, File dst) throws IOException {
    if (verbose) System.out.println("Copying " + src.getAbsolutePath() + " to " + dst.getAbsolutePath());
    dst.mkdirs();
    File[] files = src.listFiles();
    if (files == null) return;
    for (File file : files) {
      File dst1 = new File(dst, file.getName());
      if (file.isDirectory())
        copyDirectory(file, dst1);
      else {
        if (verbose) System.out.println("Copying " + file.getAbsolutePath() + " to " + dst1.getAbsolutePath());
        copy(file, dst1);
      }
    }
  }

  /** Quickly copy a file without a progress bar or any other fancy GUI... :) */
  public static void copy(File src, File dest) throws IOException {
    FileInputStream inputStream = new FileInputStream(src);
    FileOutputStream outputStream = new FileOutputStream(dest);
    try {
      copy(inputStream, outputStream);
      inputStream.close();
    } finally {
      outputStream.close();
    }
  }

  public static void copy(InputStream in, OutputStream out) throws IOException {
    byte[] buf = new byte[65536];
    while (true) {
      int n = in.read(buf);
      if (n <= 0) return;
      out.write(buf, 0, n);
    }
  }

  /** 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 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);
  }

  static class DiskSnippetCache {
    final File dir;

    public DiskSnippetCache(File dir) {
      this.dir = dir;
      dir.mkdirs();
    }

    public synchronized String get(long snippetID) throws IOException {
      return loadTextFile(getFile(snippetID).getPath(), null);
    }

    private File getFile(long snippetID) {
      return new File(dir, "" + snippetID);
    }

    public synchronized void put(long snippetID, String snippet) throws IOException {
      saveTextFile(getFile(snippetID).getPath(), snippet);
    }

    public File getDir() {
      return dir;
    }
  }

  public static DiskSnippetCache getSnippetCache() {
    return new DiskSnippetCache(new File(System.getProperty("user.home"), ".tinybrain/snippet-cache"));
  }

  public static String loadSnippetVerified(String snippetID, String hash) throws IOException {
    String text = loadSnippet(snippetID, !hash.isEmpty());
    String realHash = getHash(text.getBytes("UTF-8"));
    if (!realHash.equals(hash)) {
      String msg;
      if (hash.isEmpty())
        msg = "Here's your hash for " + snippetID + ", please put in your program: " + realHash;
      else
        msg = "Hash mismatch for " + snippetID + ": " + realHash + " (new) vs " + hash + " - has tinybrain.de been hacked??";
      throw new RuntimeException(msg);
    }
    return text;
  }

  public static String getHash(byte[] data) {
    return bytesToHex(getFullFingerprint(data));
  }

  public static byte[] getFullFingerprint(byte[] data) {
    try {
      return MessageDigest.getInstance("MD5").digest(data);
    } catch (NoSuchAlgorithmException e) {
      throw new RuntimeException(e);
    }
  }

  public static String bytesToHex(byte[] bytes) {
    return bytesToHex(bytes, 0, bytes.length);
  }

  public static String bytesToHex(byte[] bytes, int ofs, int len) {
    StringBuilder stringBuilder = new StringBuilder(len*2);
    for (int i = 0; i < len; i++) {
      String s = "0" + Integer.toHexString(bytes[ofs+i]);
      stringBuilder.append(s.substring(s.length()-2, s.length()));
    }
    return stringBuilder.toString();
  }

  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) {
      String text = getSnippetCache().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 {
      getSnippetCache().put(snippetID, text);
    } catch (IOException e) {
      System.err.println("Minor warning: Couldn't save snippet to cache ("  + getSnippetCache().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";
  }

  public static void javax2(File srcDir, File ioBaseDir, boolean silent) throws IOException {
    List<File> sources = new ArrayList<File>();
    if (verbose) System.out.println("Scanning for sources in " + srcDir.getPath());
    scanForSources(srcDir, sources, true);
    if (sources.isEmpty()) {
      System.out.println("No sources found");
      return;
    }
    File optionsFile = File.createTempFile("javax", "");
    File classesDir = TempDirMaker.make();
    if (verbose) System.out.println("Compiling " + sources.size() + " source(s) to " + classesDir.getPath());
    String options = "-d " + bashQuote(classesDir.getPath());
    writeOptions(sources, optionsFile, options);
    classesDir.mkdirs();
    invokeJavac(optionsFile);
    if (verbose) System.out.println("Running program (class main.java)\n");
    runProgram(classesDir, ioBaseDir, silent);
  }

  private static void runProgram(File classesDir, File ioBaseDir, boolean silent) throws IOException {
    boolean echoOK = false;
    String bashCmd = "(cd " + bashQuote(ioBaseDir.getAbsolutePath()) + " && (java -cp "
      + bashQuote(classesDir.getAbsolutePath()) + " main" + (echoOK ? "; echo ok" : "") + "))";
    if (verbose) System.out.println(bashCmd);
    String output = backtick(bashCmd);
    if (!silent)
      System.out.println(output);
  }

  private static void invokeJavac(File optionsFile) throws IOException {
    String javacOutput = backtick("javac " + bashQuote("@" + optionsFile.getPath()));
    if (verbose) System.out.println(javacOutput);
  }

  private static void writeOptions(List<File> sources, File sourcesFile, String moreOptions) throws IOException {
    FileWriter writer = new FileWriter(sourcesFile);
    for (File source : sources)
      writer.write(bashQuote(source.getPath()) + " ");
    writer.write(moreOptions);
    writer.close();
  }

  private static void scanForSources(File source, List<File> sources, boolean topLevel) {
    if (source.isFile() && source.getName().endsWith(".java"))
      sources.add(source);
    else if (source.isDirectory() && !isSkippedDirectoryName(source.getName(), topLevel)) {
      File[] files = source.listFiles();
      for (File file : files)
        scanForSources(file, sources, false);
    }
  }

  private static boolean isSkippedDirectoryName(String name, boolean topLevel) {
    if (topLevel) return false; // input or output ok as highest directory (intentionally specified by user, not just found by a directory scan in which case we probably don't want it. it's more like heuristics actually.)
    return name.equalsIgnoreCase("input") || name.equalsIgnoreCase("output");
  }

  public static String backtick(String cmd) throws IOException {
    File outFile = File.createTempFile("_backtick", "");
    File scriptFile = File.createTempFile("_backtick", "");

    String command = cmd + ">" + bashQuote(outFile.getPath()) + " 2>&1";
    //Log.info("[Backtick] " + command);
    try {
      saveTextFile(scriptFile.getPath(), command);
      String[] command2 = {"/bin/bash", scriptFile.getPath() };
      Process process = Runtime.getRuntime().exec(command2);
      try {
        process.waitFor();
      } catch (InterruptedException e) {
        throw new RuntimeException(e);
      }
      int value = process.exitValue();
      //Log.info("exit value: " + value);
      return loadTextFile(outFile.getPath(), "");
    } finally {
      scriptFile.delete();
    }
  }

  /** possibly improvable */
  public static String bashQuote(String text) {
    if (text == null) return null;
    return "\"" + text
      .replace("\\", "\\\\")
      .replace("\"", "\\\"")
      .replace("\n", "\\n")
      .replace("\r", "\\r") + "\"";
  }

  public final static String charsetForTextFiles = "UTF8";

  public static class TempDirMaker {
    static long lastValue;

    public static File make() {
      File dir = new File(System.getProperty("user.home"), ".javax/" + newValue());
      dir.mkdirs();
      return dir;
    }

    private static long newValue() {
      long value;
      do
        value = System.currentTimeMillis();
      while (value == lastValue);
      lastValue = value;
      return value;
    }
  }
}