/**
 * Apache License
 * Version 2.0, January 2004
 * http://www.apache.org/licenses/
 *
 * TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 *
 * 1. Definitions.
 *
 * "License" shall mean the terms and conditions for use, reproduction,
 * and distribution as defined by Sections 1 through 9 of this document.
 *
 * "Licensor" shall mean the copyright owner or entity authorized by
 * the copyright owner that is granting the License.
 *
 * "Legal Entity" shall mean the union of the acting entity and all
 * other entities that control, are controlled by, or are under common
 * control with that entity. For the purposes of this definition,
 * "control" means (i) the power, direct or indirect, to cause the
 * direction or management of such entity, whether by contract or
 * otherwise, or (ii) ownership of fifty percent (50%) or more of the
 * outstanding shares, or (iii) beneficial ownership of such entity.
 *
 * "You" (or "Your") shall mean an individual or Legal Entity
 * exercising permissions granted by this License.
 *
 * "Source" form shall mean the preferred form for making modifications,
 * including but not limited to software source code, documentation
 * source, and configuration files.
 *
 * "Object" form shall mean any form resulting from mechanical
 * transformation or translation of a Source form, including but
 * not limited to compiled object code, generated documentation,
 * and conversions to other media types.
 *
 * "Work" shall mean the work of authorship, whether in Source or
 * Object form, made available under the License, as indicated by a
 * copyright notice that is included in or attached to the work
 * (an example is provided in the Appendix below).
 *
 * "Derivative Works" shall mean any work, whether in Source or Object
 * form, that is based on (or derived from) the Work and for which the
 * editorial revisions, annotations, elaborations, or other modifications
 * represent, as a whole, an original work of authorship. For the purposes
 * of this License, Derivative Works shall not include works that remain
 * separable from, or merely link (or bind by name) to the interfaces of,
 * the Work and Derivative Works thereof.
 *
 * "Contribution" shall mean any work of authorship, including
 * the original version of the Work and any modifications or additions
 * to that Work or Derivative Works thereof, that is intentionally
 * submitted to Licensor for inclusion in the Work by the copyright owner
 * or by an individual or Legal Entity authorized to submit on behalf of
 * the copyright owner. For the purposes of this definition, "submitted"
 * means any form of electronic, verbal, or written communication sent
 * to the Licensor or its representatives, including but not limited to
 * communication on electronic mailing lists, source code control systems,
 * and issue tracking systems that are managed by, or on behalf of, the
 * Licensor for the purpose of discussing and improving the Work, but
 * excluding communication that is conspicuously marked or otherwise
 * designated in writing by the copyright owner as "Not a Contribution."
 *
 * "Contributor" shall mean Licensor and any individual or Legal Entity
 * on behalf of whom a Contribution has been received by Licensor and
 * subsequently incorporated within the Work.
 *
 * 2. Grant of Copyright License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * copyright license to reproduce, prepare Derivative Works of,
 * publicly display, publicly perform, sublicense, and distribute the
 * Work and such Derivative Works in Source or Object form.
 *
 * 3. Grant of Patent License. Subject to the terms and conditions of
 * this License, each Contributor hereby grants to You a perpetual,
 * worldwide, non-exclusive, no-charge, royalty-free, irrevocable
 * (except as stated in this section) patent license to make, have made,
 * use, offer to sell, sell, import, and otherwise transfer the Work,
 * where such license applies only to those patent claims licensable
 * by such Contributor that are necessarily infringed by their
 * Contribution(s) alone or by combination of their Contribution(s)
 * with the Work to which such Contribution(s) was submitted. If You
 * institute patent litigation against any entity (including a
 * cross-claim or counterclaim in a lawsuit) alleging that the Work
 * or a Contribution incorporated within the Work constitutes direct
 * or contributory patent infringement, then any patent licenses
 * granted to You under this License for that Work shall terminate
 * as of the date such litigation is filed.
 *
 * 4. Redistribution. You may reproduce and distribute copies of the
 * Work or Derivative Works thereof in any medium, with or without
 * modifications, and in Source or Object form, provided that You
 * meet the following conditions:
 *
 * (a) You must give any other recipients of the Work or
 * Derivative Works a copy of this License; and
 *
 * (b) You must cause any modified files to carry prominent notices
 * stating that You changed the files; and
 *
 * (c) You must retain, in the Source form of any Derivative Works
 * that You distribute, all copyright, patent, trademark, and
 * attribution notices from the Source form of the Work,
 * excluding those notices that do not pertain to any part of
 * the Derivative Works; and
 *
 * (d) If the Work includes a "NOTICE" text file as part of its
 * distribution, then any Derivative Works that You distribute must
 * include a readable copy of the attribution notices contained
 * within such NOTICE file, excluding those notices that do not
 * pertain to any part of the Derivative Works, in at least one
 * of the following places: within a NOTICE text file distributed
 * as part of the Derivative Works; within the Source form or
 * documentation, if provided along with the Derivative Works; or,
 * within a display generated by the Derivative Works, if and
 * wherever such third-party notices normally appear. The contents
 * of the NOTICE file are for informational purposes only and
 * do not modify the License. You may add Your own attribution
 * notices within Derivative Works that You distribute, alongside
 * or as an addendum to the NOTICE text from the Work, provided
 * that such additional attribution notices cannot be construed
 * as modifying the License.
 *
 * You may add Your own copyright statement to Your modifications and
 * may provide additional or different license terms and conditions
 * for use, reproduction, or distribution of Your modifications, or
 * for any such Derivative Works as a whole, provided Your use,
 * reproduction, and distribution of the Work otherwise complies with
 * the conditions stated in this License.
 *
 * 5. Submission of Contributions. Unless You explicitly state otherwise,
 * any Contribution intentionally submitted for inclusion in the Work
 * by You to the Licensor shall be under the terms and conditions of
 * this License, without any additional terms or conditions.
 * Notwithstanding the above, nothing herein shall supersede or modify
 * the terms of any separate license agreement you may have executed
 * with Licensor regarding such Contributions.
 *
 * 6. Trademarks. This License does not grant permission to use the trade
 * names, trademarks, service marks, or product names of the Licensor,
 * except as required for reasonable and customary use in describing the
 * origin of the Work and reproducing the content of the NOTICE file.
 *
 * 7. Disclaimer of Warranty. Unless required by applicable law or
 * agreed to in writing, Licensor provides the Work (and each
 * Contributor provides its Contributions) on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied, including, without limitation, any warranties or conditions
 * of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
 * PARTICULAR PURPOSE. You are solely responsible for determining the
 * appropriateness of using or redistributing the Work and assume any
 * risks associated with Your exercise of permissions under this License.
 *
 * 8. Limitation of Liability. In no event and under no legal theory,
 * whether in tort (including negligence), contract, or otherwise,
 * unless required by applicable law (such as deliberate and grossly
 * negligent acts) or agreed to in writing, shall any Contributor be
 * liable to You for damages, including any direct, indirect, special,
 * incidental, or consequential damages of any character arising as a
 * result of this License or out of the use or inability to use the
 * Work (including but not limited to damages for loss of goodwill,
 * work stoppage, computer failure or malfunction, or any and all
 * other commercial damages or losses), even if such Contributor
 * has been advised of the possibility of such damages.
 *
 * 9. Accepting Warranty or Additional Liability. While redistributing
 * the Work or Derivative Works thereof, You may choose to offer,
 * and charge a fee for, acceptance of support, warranty, indemnity,
 * or other liability obligations and/or rights consistent with this
 * License. However, in accepting such obligations, You may act only
 * on Your own behalf and on Your sole responsibility, not on behalf
 * of any other Contributor, and only if You agree to indemnify,
 * defend, and hold each Contributor harmless for any liability
 * incurred by, or claims asserted against, such Contributor by reason
 * of your accepting any such warranty or additional liability.
 *
 * END OF TERMS AND CONDITIONS
 *
 * APPENDIX: How to apply the Apache License to your work.
 *
 * To apply the Apache License to your work, attach the following
 * boilerplate notice, with the fields enclosed by brackets "{}"
 * replaced with your own identifying information. (Don't include
 * the brackets!)  The text should be enclosed in the appropriate
 * comment syntax for the file format. We also recommend that a
 * file or class name and description of purpose be included on the
 * same "printed page" as the copyright notice for easier
 * identification within third-party archives.
 *
 * Copyright 2014 Edgar Espina
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jooby.run;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;
import java.nio.file.WatchEvent.Kind;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.LongStream;

import org.jboss.modules.Module;
import org.jboss.modules.ModuleClassLoader;
import org.jboss.modules.ModuleIdentifier;
import org.jboss.modules.ModuleLoader;
import org.jboss.modules.log.ModuleLogger;

public class Main {

  static final String JOOBY_REF = "org.jooby.internal.run__.JoobyRef";

  private static boolean DEBUG;

  private static boolean TRACE;

  static {
    logLevel();
  }

  private AppModuleLoader loader;
  private ExecutorService executor;
  private Watcher scanner;
  private PathMatcher includes;
  private PathMatcher excludes;
  private volatile Object app;
  private AtomicReference<String> hash = new AtomicReference<>("");
  private ModuleIdentifier mId;
  private String mainClass;
  private volatile Module module;
  private List<String> args;
  private AtomicBoolean starting = new AtomicBoolean(false);
  private AtomicInteger counter = new AtomicInteger(0);

  private Path[] watchDirs;

  public Main(final String mId, final String mainClass, final List<File> watchDirs,
      final File... cp) throws Exception {
    this.mainClass = mainClass;
    loader = AppModuleLoader.build(mId, cp);
    this.mId = ModuleIdentifier.create(mId);
    this.watchDirs = toPath(watchDirs);
    this.executor = Executors.newSingleThreadExecutor(task -> new Thread(task, "Hotswap"));
    this.scanner = new Watcher(this::onChange, this.watchDirs);
    includes("**/*.class" + File.pathSeparator + "**/*.conf" + File.pathSeparator
        + "**/*.properties" + packageJson(cp));
    excludes("");
  }

  private String packageJson(File[] cp) {
    if (Files.exists(Paths.get("package.json"))) {
      return Arrays.asList(cp).stream()
          .filter(f -> f.getAbsolutePath().contains("jooby-frontend"))
          .findFirst()
          .map(f -> File.pathSeparator + "package.json")
          .orElse("");
    }
    return "";
  }

  private Path[] toPath(final List<File> watchDir) throws IOException {
    Set<File> files = new LinkedHashSet<>();
    files.add(new File(System.getProperty("user.dir")));
    if (watchDir != null) {
      files.addAll(watchDir);
    }
    List<Path> paths = new ArrayList<>();
    for (File file : files) {
      if (file.exists()) {
        paths.add(file.getCanonicalFile().toPath());
      }
    }
    return paths.toArray(new Path[paths.size()]);
  }

  public static void main(final String[] args) throws Exception {
    List<File> cp = new ArrayList<>();
    List<File> watch = new ArrayList<>();
    String includes = null;
    String excludes = null;

    for (int i = 2; i < args.length; i++) {
      String[] option = args[i].split("=");
      if (option.length < 2) {
        throw new IllegalArgumentException("Unknown option: " + args[i]);
      }
      String name = option[0].toLowerCase();
      switch (name) {
        case "includes":
          includes = option[1];
          break;
        case "excludes":
          excludes = option[1];
          break;
        case "props":
          setSystemProperties(new File(option[1]));
          break;
        case "deps":
          String[] deps = option[1].split(File.pathSeparator);
          for (String dep : deps) {
            cp.add(new File(dep));
          }
          break;
        case "watchdirs":
          String[] dirs = option[1].split(File.pathSeparator);
          for (String dir : dirs) {
            watch.add(new File(dir));
          }
          break;
        default:
          throw new IllegalArgumentException("Unknown option: " + args[i]);
      }
    }
    // set log level, once we call setSystemProps
    logLevel();

    if (cp.isEmpty()) {
      cp.add(new File(System.getProperty("user.dir")));
    }

    Main launcher = new Main(args[0], args[1], watch, cp.toArray(new File[cp.size()]));
    if (includes != null) {
      launcher.includes(includes);
    }
    if (excludes != null) {
      launcher.excludes(excludes);
    }
    launcher.run();
  }

  private static void setSystemProperties(final File sysprops) throws IOException {
    try (InputStream in = new FileInputStream(sysprops)) {
      Properties properties = new Properties();
      properties.load(in);
      for (Entry<Object, Object> prop : properties.entrySet()) {
        String name = prop.getKey().toString();
        String value = prop.getValue().toString();
        String existing = System.getProperty(name);
        if (!value.equals(existing)) {
          // set property
          System.setProperty(name, value);
        }
      }
    }
  }

  public void run(final String... args) {
    run(false, args);
  }

  public void run(final boolean block, final String... args) {
    info("Hotswap available on: %s", Arrays.toString(watchDirs));
    info("  includes: %s", includes);
    info("  excludes: %s", excludes);

    this.scanner.start();
    this.args = new ArrayList<>(Arrays.asList(args));
    this.args.add("server.join=false");
    this.args.add("jooby.internal.onStart=" + JOOBY_REF);
    this.startApp(this.args);

    if (block) {
      Object lock = new Object();
      synchronized (lock) {
        // until Ctrl+C
        try {
          lock.wait();
        } catch (InterruptedException ex) {
          Thread.currentThread().interrupt();
        }
      }
    }
  }

  @SuppressWarnings("rawtypes")
  private void startApp(final List<String> args) {
    if (starting.get()) {
      return;
    }
    if (app != null) {
      stopApp(app);
    }
    // liveReload hack while restarting
    System.setProperty("joobyRun.counter", String.valueOf(counter.getAndIncrement()));
    starting.set(true);
    debug("scheduling: %s", mainClass);
    executor.submit(() -> {
      String runclass = this.mainClass;
      String alias = runclass;
      ClassLoader ctxLoader = Thread.currentThread().getContextClassLoader();
      try {
        module = loader.loadModule(mId);
        ModuleClassLoader mcloader = module.getClassLoader();

        Thread.currentThread().setContextClassLoader(mcloader);

        debug("starting: %s", runclass);
        Class appref = mcloader.loadClass(JOOBY_REF);
        debug("loaded: %s", appref);
        Class appclass = mcloader.loadClass(runclass);
        debug("loaded: %s", appclass);
        Method main = appclass.getDeclaredMethod("main", String[].class);
        debug("loaded: %s", main);
        Object params = args.toArray(new String[args.size()]);
        debug("calling: %s", main);
        main.invoke(null, params);
        debug("called: %s", main);
        Field reffld = appref.getDeclaredField("ref");
        AtomicReference ref = (AtomicReference) reffld.get(null);
        this.app = ref.get();
        if (this.app != null) {
          Method started = app.getClass().getMethod("isStarted");
          Boolean success = (Boolean) started.invoke(this.app);
          if (success) {
            debug("started: %s", alias);
          } else {
            debug("not started: %s", alias);
            System.exit(1);
          }
        }
      } catch (Throwable ex) {
        Throwable cause = ex;
        if (ex instanceof InvocationTargetException) {
          cause = ((InvocationTargetException) ex).getTargetException();
        }
        error("%s.start() resulted in error", alias, cause);
      } finally {
        starting.set(false);
        Thread.currentThread().setContextClassLoader(ctxLoader);
      }
    });
  }

  private void stopApp(final Object app) {
    try {
      debug("stopping: %s", mainClass);
      app.getClass().getMethod("stop").invoke(app);
    } catch (Throwable ex) {
      error("%s.stop() resulted in error", mainClass, ex);
    } finally {
      try {
        debug("unloading: %s", mainClass);
        loader.unload(module);
      } catch (Throwable ex) {
        // sshhhh
      }
    }

  }

  public Main includes(final String includes) {
    this.includes = pathMatcher(includes);
    return this;
  }

  public Main excludes(final String excludes) {
    this.excludes = pathMatcher(excludes);
    return this;
  }

  private void onChange(final Kind<?> kind, final Path path) {
    try {
      debug("OnChange: %s(%s)", path, kind);
      Path candidate = relativePath(path);
      if (candidate == null || !includes.matches(candidate) || excludes.matches(candidate)) {
        debug("Ignoring change: %s", path);
        return;
      }
      // weak hash check: avoid change on conf/* that are propagated to target/classs by maven.
      File f = candidate.toFile();
      // len and lastModified reports 0 on external paths, we hack and use now as millis
      long l = LongStream.of(f.length(), f.lastModified(), System.currentTimeMillis())
          .filter(it -> it > 0)
          .findFirst()
          .getAsLong();
      String h = f.getName() + ":" + l;
      debug("hash %s > new hash %s", hash.get(), h);
      if (!hash.getAndSet(h).equals(h)) {
        debug("File change detected: %s", path);
        // reload
        startApp(args);
      } else {
        debug("Ignoring change: %s", path);
      }
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }

  private Path relativePath(final Path path) {
    for (Path root : watchDirs) {
      if (path.startsWith(root)) {
        return root.relativize(path);
      }
    }
    return null;
  }

  private static PathMatcher pathMatcher(final String expressions) {
    List<PathMatcher> matchers = new ArrayList<>();
    for (String expression : expressions.split(File.pathSeparator)) {
      matchers.add(FileSystems.getDefault().getPathMatcher("glob:" + expression.trim()));
    }
    return new PathMatcher() {

      @Override
      public boolean matches(final Path path) {
        for (PathMatcher matcher : matchers) {
          if (matcher.matches(path)) {
            return true;
          }
        }
        return false;
      }

      @Override
      public String toString() {
        return "[" + expressions + "]";
      }
    };
  }

  private static void logLevel() {
    DEBUG = "debug".equalsIgnoreCase(System.getProperty("logLevel", ""));

    TRACE = "trace".equalsIgnoreCase(System.getProperty("logLevel", ""));

    if (TRACE) {
      DEBUG = true;
      Module.setModuleLogger(new ModuleLogger() {

        @Override
        public void trace(final Throwable t, final String format, final Object arg1,
            final Object arg2, final Object arg3) {
          Main.trace(format, arg1, arg2, arg3, t);
        }

        @Override
        public void trace(final Throwable t, final String format, final Object arg1,
            final Object arg2) {
          Main.trace(format, arg1, arg2, t);
        }

        @Override
        public void trace(final String format, final Object arg1, final Object arg2,
            final Object arg3) {
          Main.trace(format, arg1, arg2, arg3);
        }

        @Override
        public void trace(final Throwable t, final String format, final Object... args) {
          Object[] values = new Object[args.length + 1];
          System.arraycopy(args, 0, values, 0, args.length);
          values[values.length - 1] = t;
          Main.trace(format, values);
        }

        @Override
        public void trace(final Throwable t, final String format, final Object arg1) {
          Main.trace(format, arg1, t);
        }

        @Override
        public void trace(final String format, final Object arg1, final Object arg2) {
          Main.trace(format, arg1, arg2);

        }

        @Override
        public void trace(final Throwable t, final String message) {
          Main.trace(message, t);
        }

        @Override
        public void trace(final String format, final Object... args) {
          Main.trace(format, args);
        }

        @Override
        public void trace(final String format, final Object arg1) {
          Main.trace(format, arg1);
        }

        @Override
        public void trace(final String message) {
          Main.trace(message);
        }

        @Override
        public void providerUnloadable(final String name, final ClassLoader loader) {
        }

        @Override
        public void moduleDefined(final ModuleIdentifier identifier,
            final ModuleLoader moduleLoader) {
        }

        @Override
        public void greeting() {
        }

        @Override
        public void classDefined(final String name, final Module module) {
        }

        @Override
        public void classDefineFailed(final Throwable throwable, final String className,
            final Module module) {
        }
      });
    }

    // set logback
    String logback = Optional.ofNullable(System.getProperty("logback.configurationFile"))
        .orElseGet(() -> Arrays
            .asList(Paths.get("conf", "logback-test.xml"), Paths.get("conf", "logback.dev.xml"),
                Paths.get("conf", "logback.xml"))
            .stream()
            .filter(p -> p.toFile().exists())
            .map(Path::toString)
            .findFirst()
            .orElse(Paths.get("conf", "logback.xml").toString()));
    debug("logback: %s", logback);
    System.setProperty("logback.configurationFile", logback);
  }

  public static void info(final String message, final Object... args) {
    System.out.println(format("info", message, args));
  }

  public static void error(final String message, final Object... args) {
    System.err.println(format("error", message, args));
  }

  public static void debug(final String message, final Object... args) {
    if (DEBUG) {
      System.out.println(format("debug", message, args));
    }
  }

  public static void trace(final String message, final Object... args) {
    if (TRACE) {
      System.out.println(format("trace", message, args));
    }
  }

  private static String format(final String level, final String message, final Object... args) {
    Object[] values = args;
    Throwable x = null;
    if (args.length > 0) {
      if (args[args.length - 1] instanceof Throwable) {
        x = (Throwable) args[args.length - 1];
        values = new Object[args.length - 1];
        System.arraycopy(args, 0, values, 0, values.length);
      }
    }
    String msg = String.format(message, values);
    StringBuilder buff = new StringBuilder();
    buff.append(">>> jooby:run[")
        .append(level)
        .append("|")
        .append(Thread.currentThread().getName())
        .append("]: ")
        .append(msg);
    if (x != null) {
      buff.append("\n");
      StringWriter writer = new StringWriter();
      x.printStackTrace(new PrintWriter(writer));
      buff.append(writer);
    }
    return buff.toString();
  }
}
