package fr.ifremer.quadrige3.ui.updater;
   
   /*-
    * #%L
    * Quadrige3 Core :: UI Updater
    * %%
    * Copyright (C) 2017 - 2018 Ifremer
    * %%
    * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import javax.swing.JOptionPane;
  import java.io.*;
  import java.net.URL;
  import java.net.URLConnection;
  import java.nio.charset.Charset;
  import java.nio.charset.StandardCharsets;
  import java.nio.file.*;
  import java.nio.file.attribute.BasicFileAttributes;
  import java.nio.file.attribute.PosixFilePermission;
  import java.text.DateFormat;
  import java.text.MessageFormat;
  import java.util.*;
  import java.util.ResourceBundle.Control;
  import java.util.stream.Collectors;
  
  import static java.nio.file.FileVisitResult.CONTINUE;
  import static java.nio.file.FileVisitResult.SKIP_SUBTREE;
  import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
  
  /**
   * Common Updater class
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class Updater {
  
      private static final String NEW_DIR = "NEW";
      private static final String OLD_DIR = "OLD";
      private static final String JRE_DIR = "jre";
      private static final String LAUNCHER_DIR = "launcher";
      private static final String UPDATE_RUNTIME_FILENAME = "update_runtime";
      private static final String UPDATE_RUNTIME_WINDOWS_CMD = "cmd /c start \"" + UPDATE_RUNTIME_FILENAME + "\" \"%s\"";
      private static final String UPDATE_RUNTIME_UNIX_CMD = "./%s";
      private static final String EXTERNAL_BACKUP_CMD = "external_backup";
      private static final String BIN_WINDOWS_EXT = ".exe";
      private static final String BATCH_WINDOWS_EXT = ".bat";
      private static final String BATCH_UNIX_EXT = ".sh";
  
      private static final String LAUNCHER_PROPERTIES = "launcher.properties";
      private static final String PROPERTY_NAME = "NAME";
  
      private static final String APP_DIR = "application";
      private static final String CONFIG_DIR = "config";
      private static final String CONFIG_EXT = ".config";
      private static final String I18N_DIR = "i18n";
      private static final String HELP_DIR = "help";
      private static final String PLUGINS_DIR = "plugins";
      private static final String DB_CACHE_DIR = "data/dbcache";
      private static final String VERSION_FILE = "version.appup";
  
      private static final int NORMAL_EXIT_CODE = 0;
      private static final int ERROR_EXIT_CODE = 1;
      private static final int STOP_EXIT_CODE = 90;
  
      private Path basePath;
      private Properties launcherProperties;
  
      private static ResourceBundle bundle;
  
      /**
       * <p>main.</p>
       *
       * @param args an array of {@link String} objects.
       */
      public static void main(String[] args) {
  
          // Get the resource bundle
          bundle = ResourceBundle.getBundle("i18n/updater", new UTF8Control());
  
          // Instantiate the launcher
          Updater updater = new Updater();
          int exitCode = updater.execute();
  
          // exit 
          System.exit(exitCode);
  
     }
 
     /**
      * <p>execute.</p>
      *
      * @return a int.
      */
     private int execute() {
         try {
 
             // Get the current directory where executable has been launched
             basePath = Paths.get(System.getProperty("user.dir"));
 
             // Read launcher properties
             launcherProperties = readLauncherProperties();
 
             // Launch runtime update
             launchRuntimeUpdate();
 
             // Launch update
             launchUpdate();
 
         } catch (IOException ex) {
             JOptionPane.showMessageDialog(null, ex.toString(), getTitle(), JOptionPane.ERROR_MESSAGE);
             ex.printStackTrace(System.err);
             return STOP_EXIT_CODE;
         } catch (Exception ex) {
             ex.printStackTrace(System.err);
             return ERROR_EXIT_CODE;
         }
         return NORMAL_EXIT_CODE;
     }
 
     private void launchUpdate() throws IOException {
 
         System.out.println(getString("updater.started", DateFormat.getInstance().format(new Date())));
 
         // Update main modules
         boolean appUpdated = updateModule(basePath, APP_DIR);
         updateModule(basePath, I18N_DIR);
         updateModule(basePath, HELP_DIR);
 
         // Update config
         updateConfig(basePath);
 
         // Update plugins
         updatePlugins();
 
         // Update other necessary files
         updateOtherFiles();
 
         // Cleaning process
         cleanObsoleteFiles();
         cleanPath(basePath.resolve(NEW_DIR));
         cleanPath(basePath.resolve(PLUGINS_DIR).resolve(NEW_DIR));
         // Clean OLD directory (Mantis #48682)
         cleanPath(basePath.resolve(OLD_DIR));
 
         if (appUpdated) {
             // clean db cache
             cleanPath(basePath.resolve(DB_CACHE_DIR));
         }
 
         System.out.println(getString("updater.ended", DateFormat.getInstance().format(new Date())));
 
     }
 
     private boolean updateModule(Path basePath, String moduleName) throws IOException {
 
         // Update a single module. moduleName corresponds to the name of the directory inside the basePath
         Path modulePath = basePath.resolve(moduleName);
         Path moduleNewPath = basePath.resolve(NEW_DIR).resolve(moduleName);
 
         if (Files.isDirectory(moduleNewPath)) {
 
             // Delete existing module (Mantis #48682)
             cleanPath(modulePath);
 
             // Installing new module
             String newVersion = getVersion(moduleNewPath);
             System.out.println(getString("updater.install", moduleName, newVersion));
             moveDirectory(moduleNewPath, modulePath);
 
             return true;
         }
 
         return false;
     }
 
     private void updatePlugins() throws IOException {
 
         // Update the plugins
         Path pluginsPath = basePath.resolve(PLUGINS_DIR);
         Path pluginsNewPath = pluginsPath.resolve(NEW_DIR);
 
         if (Files.isDirectory(pluginsNewPath)) {
 
             DirectoryStream<Path> stream = Files.newDirectoryStream(pluginsNewPath, entry -> Files.isDirectory(entry));
 
             List<String> pluginNames = new ArrayList<>();
             for (Path path : stream) {
                 pluginNames.add(path.getFileName().toString());
             }
 
             // Update each plugin as a module
             for (String pluginName : pluginNames) {
                 updateModule(pluginsPath, pluginName);
             }
         }
 
     }
 
     private void updateConfig(Path basePath) throws IOException {
 
         String configFileName = getName().toLowerCase() + CONFIG_EXT;
         Path configPath = basePath.resolve(CONFIG_DIR);
         Path configFilePath = configPath.resolve(configFileName);
         Path configNewPath = basePath.resolve(NEW_DIR).resolve(CONFIG_DIR);
         Path configNewFilePath = configNewPath.resolve(configFileName);
 
         if (Files.isRegularFile(configNewFilePath)) {
 
             String newVersion = getVersion(configNewPath);
             System.out.println(getString("updater.install", CONFIG_DIR, newVersion));
 
             if (Files.isRegularFile(configFilePath)) {
 
                 // Process config update
                 Properties actualProperties = new Properties();
                 Properties newProperties = new Properties();
                 try (Reader actualPropertiesReader = Files.newBufferedReader(configFilePath, StandardCharsets.UTF_8);
                      Reader newPropertiesReader = Files.newBufferedReader(configNewFilePath, StandardCharsets.UTF_8)) {
 
                     // Load all existing properties
                     actualProperties.load(actualPropertiesReader);
 
                     // Load all new properties
                     newProperties.load(newPropertiesReader);
                 }
 
                 // Add or replace new property
                 newProperties.forEach((key, newValue) -> actualProperties.setProperty((String) key, (String) newValue));
 
                 try (Writer actualPropertiesWriter = Files.newBufferedWriter(configFilePath, StandardCharsets.UTF_8)) {
 
                     // Then save
                     actualProperties.store(actualPropertiesWriter, null);
                 }
 
             } else {
 
                 // Copy it if no config file at all
                 Files.createDirectories(configFilePath.getParent());
                 Files.copy(configNewFilePath, configFilePath);
             }
 
             // Also copy version file
             Files.copy(configNewFilePath.resolveSibling(VERSION_FILE), configFilePath.resolveSibling(VERSION_FILE), REPLACE_EXISTING);
         }
     }
 
     private Properties readLauncherProperties() throws Exception {
 
         Path localLauncherFile = basePath.resolve(LAUNCHER_PROPERTIES);
         Path applicationLauncherFile = basePath.resolve(APP_DIR).resolve(LAUNCHER_PROPERTIES);
 
         if (!Files.exists(localLauncherFile) && !Files.exists(applicationLauncherFile)) {
             throw new IOException(getString("updater.fileNotExists", LAUNCHER_PROPERTIES));
         }
 
         Properties p1 = new Properties();
         if (Files.isReadable(applicationLauncherFile)) {
             try (Reader reader = new FileReader(applicationLauncherFile.toFile())) {
                 p1.load(reader);
             }
         }
 
         Properties p = new Properties(p1);
         if (Files.isReadable(localLauncherFile)) {
             try (Reader reader = new FileReader(localLauncherFile.toFile())) {
                 p.load(reader);
             }
         }
 
         // Assert properties exists
         assertPropertyExists(p, PROPERTY_NAME);
 
         return p;
     }
 
     @SuppressWarnings("SameParameterValue")
     private void assertPropertyExists(Properties properties, String propertyName) {
         String property = properties.getProperty(propertyName);
         if (property == null || property.trim().length() == 0)
             throw new NullPointerException(getString("updater.propertyNotFound", propertyName, LAUNCHER_PROPERTIES));
     }
 
     private String getName() {
         return launcherProperties.getProperty(PROPERTY_NAME);
     }
 
     private String getTitle() {
         return getString("updater.title", getName());
     }
 
     private String getVersion(Path path) throws IOException {
 
         // Return the version of a module from version.appup file
         Path versionFile = path.resolve(VERSION_FILE);
         if (!Files.exists(versionFile)) {
             return "0";
         }
         List<String> lines = Files.readAllLines(versionFile, StandardCharsets.UTF_8);
         if (lines.isEmpty()) {
             return "0";
         }
         return lines.get(0);
     }
 
     private void updateOtherFiles() throws IOException {
 
         // External backup script
         Path extBackupPath = basePath.resolve(APP_DIR).resolve(EXTERNAL_BACKUP_CMD + (isWindowsOS() ? BATCH_WINDOWS_EXT : BATCH_UNIX_EXT));
         if (Files.exists(extBackupPath)) {
             Files.move(extBackupPath, extBackupPath.getParent().getParent().resolve(extBackupPath.getFileName()), REPLACE_EXISTING);
             // Set Unix permissions
             if (!isWindowsOS()) {
                 Set<PosixFilePermission> perms = new HashSet<>();
                 //add owners permission
                 perms.add(PosixFilePermission.OWNER_READ);
                 perms.add(PosixFilePermission.OWNER_WRITE);
                 perms.add(PosixFilePermission.OWNER_EXECUTE);
                 //add group permissions
                 perms.add(PosixFilePermission.GROUP_READ);
                 perms.add(PosixFilePermission.GROUP_WRITE);
                 perms.add(PosixFilePermission.GROUP_EXECUTE);
                 //add others permissions
                 perms.add(PosixFilePermission.OTHERS_READ);
                 perms.add(PosixFilePermission.OTHERS_EXECUTE);
                 Files.setPosixFilePermissions(basePath.resolve(EXTERNAL_BACKUP_CMD + BATCH_UNIX_EXT), perms);
             }
         }
 
     }
 
     private void copyDirectory(Path sourcePath, Path targetPath) throws IOException {
 
         Files.walkFileTree(sourcePath, new TreeCopier(sourcePath, targetPath));
     }
 
     private void moveDirectory(Path sourcePath, Path targetPath) throws IOException {
 
         // Use Copy + Delete instead of a move directory (Mantis #42313)
         copyDirectory(sourcePath, targetPath);
         cleanPath(sourcePath);
     }
 
     private void cleanPath(Path path) throws IOException {
 
         cleanPath(path, null);
     }
 
     private void cleanPath(Path path, String glob) throws IOException {
 
         if (Files.isDirectory(path)) {
             Files.walkFileTree(path, new RecursiveDeleteFileVisitor(glob));
         }
     }
 
     private void cleanObsoleteFiles() throws IOException {
 
         if (isWindowsOS()) {
 
             // Delete obsolete batch files
             Files.deleteIfExists(basePath.resolve(getName() + BATCH_WINDOWS_EXT));
             Files.deleteIfExists(basePath.resolve(APP_DIR).resolve("launch" + BATCH_WINDOWS_EXT));
 
             // Delete non Windows files
             cleanPath(basePath, "*" + BATCH_UNIX_EXT);
         } else {
 
             // Delete obsolete script files
             Files.deleteIfExists(basePath.resolve(APP_DIR).resolve("launch" + BATCH_UNIX_EXT));
 
             // Delete Windows files
             cleanPath(basePath, "*" + BATCH_WINDOWS_EXT);
             cleanPath(basePath, "*" + BIN_WINDOWS_EXT);
         }
 
         // Delete embedded files
         Files.deleteIfExists(basePath.resolve(APP_DIR).resolve(getName() + BIN_WINDOWS_EXT));
         Files.deleteIfExists(basePath.resolve(APP_DIR).resolve(getName() + BATCH_UNIX_EXT));
         cleanPath(basePath.resolve(APP_DIR).resolve("launcher"));
 
     }
 
     private void launchRuntimeUpdate() throws IOException {
 
         if (checkRuntimeUpdate()) {
 
             // Launch update runtime script
             Runtime.getRuntime().exec(String.format(
                     isWindowsOS() ? UPDATE_RUNTIME_WINDOWS_CMD : UPDATE_RUNTIME_UNIX_CMD,
                     getRuntimeUpdater().toFile().getAbsolutePath()));
             System.exit(STOP_EXIT_CODE);
         }
     }
 
     private boolean checkRuntimeUpdate() throws IOException {
 
         // First, delete previous update_runtime.bat
         Files.deleteIfExists(getRuntimeUpdater());
 
         if (Files.isDirectory(basePath.resolve(NEW_DIR).resolve(JRE_DIR))
                 || Files.isDirectory(basePath.resolve(NEW_DIR).resolve(LAUNCHER_DIR))) {
 
             // A new jre or/and a new launcher is available, so generate the script
             generateRuntimeUpdater();
             System.out.println(getString("updater.runtimeUpdate", getRuntimeUpdaterFilename()));
             return true;
         }
         return false;
     }
 
     private Path getRuntimeUpdater() {
 
         // Get the script file (platform dependent)
         return basePath.resolve(getRuntimeUpdaterFilename());
     }
 
     private String getRuntimeUpdaterFilename() {
 
         return UPDATE_RUNTIME_FILENAME + (isWindowsOS() ? BATCH_WINDOWS_EXT : BATCH_UNIX_EXT);
     }
 
     private boolean isWindowsOS() {
 
         return System.getProperty("os.name").startsWith("Windows");
     }
 
     private void generateRuntimeUpdater() throws IOException {
 
         // Read resource file
         InputStream inputStream = getClass().getClassLoader().getResourceAsStream(getRuntimeUpdaterFilename());
 
         // Replace NAME pattern
         List<String> scriptContent = new BufferedReader(new InputStreamReader(Objects.requireNonNull(inputStream))).lines()
                 .map(line -> line.replaceAll("@NAME@", getName())).collect(Collectors.toList());
 
         // Generate the script
         Files.write(getRuntimeUpdater(), scriptContent, Charset.defaultCharset(), StandardOpenOption.CREATE_NEW);
     }
 
     static class TreeCopier implements FileVisitor<Path> {
         private final Path source;
         private final Path target;
 
         TreeCopier(Path source, Path target) {
             this.source = source;
             this.target = target;
         }
 
         @Override
         public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
             // before visiting entries in a directory we create the target directory
             Path newDir = target.resolve(source.relativize(dir));
             try {
                 Files.createDirectories(newDir);
             } catch (IOException x) {
                 System.err.format("Unable to create: %s: %s%n", newDir, x);
                 return SKIP_SUBTREE;
             }
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
 
             try {
                 Files.copy(file, target.resolve(source.relativize(file)), REPLACE_EXISTING);
             } catch (IOException e) {
                 System.err.format("Unable to copy: %s: %s%n", file, e);
             }
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult visitFileFailed(Path file, IOException exc) {
             if (exc instanceof FileSystemLoopException) {
                 System.err.println("cycle detected: " + file);
             } else {
                 System.err.format("Unable to copy: %s: %s%n", file, exc);
             }
             return CONTINUE;
         }
     }
 
     private class RecursiveDeleteFileVisitor extends SimpleFileVisitor<Path> {
 
         PathMatcher matcher;
 
         RecursiveDeleteFileVisitor(String glob) {
             super();
 
             // Create a matcher according the glob parameter
             matcher = glob == null ? null : basePath.getFileSystem().getPathMatcher("glob:" + glob);
         }
 
         @Override
         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
 
             // If the file name matches the glob or if no matcher, delete the file
             if (matcher == null || matcher.matches(file.getFileName())) {
                 Files.deleteIfExists(file);
                 //file.toFile().deleteOnExit(); if needed when IOException is raised
             }
             return CONTINUE;
         }
 
         @Override
         public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
 
             // if no matcher, delete the directory
             if (matcher == null) {
                 try {
                     Files.deleteIfExists(dir);
                 } catch (DirectoryNotEmptyException e) {
                     // try a second time after a while
                     try {
                         Thread.sleep(500);
                     } catch (InterruptedException ignored) {
                     }
                     Files.deleteIfExists(dir); // will re throw a DirectoryNotEmptyException if really is
                 }
             }
 
             return CONTINUE;
         }
 
     }
 
     private static String getString(String resourceName, Object... params) {
         return MessageFormat.format(bundle.getString(resourceName), params);
     }
 
     private static class UTF8Control extends Control {
 
         @Override
         public ResourceBundle newBundle(String baseName, Locale locale, String format, ClassLoader loader, boolean reload) throws IOException {
             // The below is a copy of the default implementation.
             String bundleName = toBundleName(baseName, locale);
             String resourceName = toResourceName(bundleName, "properties");
             ResourceBundle bundle = null;
             InputStream stream = null;
             if (reload) {
                 URL url = loader.getResource(resourceName);
                 if (url != null) {
                     URLConnection connection = url.openConnection();
                     if (connection != null) {
                         connection.setUseCaches(false);
                         stream = connection.getInputStream();
                     }
                 }
             } else {
                 stream = loader.getResourceAsStream(resourceName);
             }
             if (stream != null) {
                 try {
                     // Only this line is changed to make it to read properties files as UTF-8.
                     bundle = new PropertyResourceBundle(new InputStreamReader(stream, StandardCharsets.UTF_8));
                 } finally {
                     stream.close();
                 }
             }
             return bundle;
         }
 
     }
 }