package fr.ifremer.quadrige3.core.service.persistence;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Client Core
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 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 fr.ifremer.quadrige3.core.ProgressionCoreModel;
  import fr.ifremer.quadrige3.core.config.QuadrigeConfiguration;
  import fr.ifremer.quadrige3.core.config.QuadrigeCoreConfiguration;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.dao.technical.Daos;
  import fr.ifremer.quadrige3.core.dao.technical.Files;
  import fr.ifremer.quadrige3.core.dao.technical.ZipUtils;
  import fr.ifremer.quadrige3.core.exception.QuadrigeBusinessException;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.core.service.ClientServiceLocator;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.nuiton.jaxx.application.ApplicationIOUtil;
  import org.nuiton.jaxx.application.ApplicationTechnicalException;
  
  import javax.sql.DataSource;
  import java.io.File;
  import java.io.IOException;
  import java.nio.file.FileVisitResult;
  import java.nio.file.Path;
  import java.nio.file.Paths;
  import java.nio.file.SimpleFileVisitor;
  import java.nio.file.attribute.BasicFileAttributes;
  import java.time.LocalDate;
  import java.time.format.DateTimeFormatter;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.stream.Collectors;
  import java.util.zip.ZipEntry;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * <p>PersistenceServiceHelper class.</p>
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class PersistenceServiceHelper {
  
      private static final Log LOG = LogFactory.getLog(PersistenceServiceHelper.class);
  
      private static final DateTimeFormatter BACKUP_DATE_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
  
      private static final String BACKUP_DIRECTORY_FORMAT = "%s-%s-%s";
  
      /**
       * backup the database using hsqldb backup feature
       * backup also:
       * - version.appup of the db
       * - import & export properties for all users
       * - attachment files
       * - additional db related directories like measurementGridPresets and extractionConfig (used by Dali)
       *
       * @param file             the target file
       * @param progressionModel the progression model
       */
      public static void backupDatabase(Path file, ProgressionCoreModel progressionModel) {
          Assert.notNull(file);
          DataSource dataSource = ClientServiceLocator.instance().getService("dataSource", DataSource.class);
          Assert.notNull(dataSource);
          QuadrigeCoreConfiguration config = QuadrigeCoreConfiguration.getInstance();
          Assert.notNull(config);
  
          // create zip structure
          String tempDirName = String.format(
                  BACKUP_DIRECTORY_FORMAT,
                  config.getApplicationName(),
                  config.getVersion(),
                  BACKUP_DATE_FORMAT.format(LocalDate.now()));
  
          File structureDirectory = new File(config.newTempFile("backupDb"), tempDirName);
  
          try {
             ApplicationIOUtil.forceMkdir(structureDirectory,
                     t("quadrige3.error.create.directory", structureDirectory));
 
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Backup directory: " + structureDirectory);
             }
 
             // backup database in a temp dir
             String dbPath = structureDirectory.getAbsolutePath();
             dbPath = StringUtils.appendIfMissing(dbPath, File.separator) + Daos.DB_DIRECTORY + File.separator;
             String sql = "BACKUP DATABASE TO '" + dbPath + "' BLOCKING AS FILES";
             try {
                 Daos.sqlUpdate(dataSource, sql);
             } catch (Exception e) {
                 throw new ApplicationTechnicalException(t("quadrige3.service.persistence.copyDirectory.db.error"), e);
             }
 
             // backup version.appup
             try {
                 progressionModel.setTotal(0);
                 Files.copyFile(
                         config.getDbDirectory().toPath().resolve(Daos.DB_VERSION_FILE),
                         Paths.get(dbPath).resolve(Daos.DB_VERSION_FILE),
                         progressionModel
                 );
             } catch (IOException e) {
                 throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.copyFile.error", Daos.DB_VERSION_FILE), e);
             }
 
             // backup attachments
             backupDirectory(config.getDbAttachmentDirectory().toPath(), structureDirectory.toPath(), progressionModel);
             // backup photos
             backupDirectory(config.getDbPhotoDirectory().toPath(), structureDirectory.toPath(), progressionModel);
 
             // other directories
             config.getDbOtherDirectories().forEach(directory -> backupDirectory(directory.toPath(), structureDirectory.toPath(), progressionModel));
 
             // backup synchro files for all users
             if (config.getSynchronizationDirectory() != null && config.getSynchronizationDirectory().isDirectory()) {
                 String synchroDirectoryName = config.getSynchronizationDirectory().getName();
                 final String[] currentFile = new String[1];
                 try {
                     progressionModel.setTotal(0);
                     java.nio.file.Files.walkFileTree(config.getSynchronizationDirectory().toPath(), new SimpleFileVisitor<Path>() {
                         @Override
                         public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                             if (file.getFileName().toString().equalsIgnoreCase(Daos.IMPORT_PROPERTIES_FILE)
                                     || file.getFileName().toString().equalsIgnoreCase(Daos.EXPORT_PROPERTIES_FILE)) {
                                 currentFile[0] = file.toAbsolutePath().toString();
                                 Path target = structureDirectory.toPath().resolve(synchroDirectoryName).resolve(config.getSynchronizationDirectory().toPath().relativize(file));
                                 Files.copyFile(file, target, progressionModel);
                             }
                             return FileVisitResult.CONTINUE;
                         }
                     });
                 } catch (IOException e) {
                     throw new ApplicationTechnicalException(t("quadrige3.service.persistence.copyFile.error", currentFile[0]), e);
                 }
             }
 
             // create zip
             try {
                 progressionModel.setTotal(0);
                 ZipUtils.compressFilesInPath(structureDirectory.toPath(), file, progressionModel, false, true);
             } catch (IOException e) {
                 throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.backupDb.zip.error", file), e);
             }
 
         } finally {
 
             // delete temp files
             ApplicationIOUtil.forceDeleteOnExit(
                     structureDirectory,
                     t("quadrige3.service.persistence.backupDb.deleteTempDir.error", structureDirectory));
         }
 
     }
 
     private static void backupDirectory(Path sourceDirectory, Path targetDirectory, ProgressionCoreModel progressionModel) {
         if (sourceDirectory != null && java.nio.file.Files.isDirectory(sourceDirectory)) {
             try {
                 if (progressionModel != null)
                     progressionModel.setTotal(0);
                 Files.copyDirectory(
                         sourceDirectory,
                         targetDirectory.resolve(sourceDirectory.getFileName().toString()),
                         progressionModel);
             } catch (IOException e) {
                 throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.copyDirectory.error", sourceDirectory), e);
             }
         }
     }
 
     public static void restoreDatabase(Path zipFile, ProgressionCoreModel progressionModel) {
 
         QuadrigeConfiguration config = QuadrigeConfiguration.getInstance();
         Assert.notNull(config);
 
         // need a file to restore
         Assert.notNull(zipFile);
 
         // get the root directory of archive
         String rootDirName = getRootDirectoryOfArchive(zipFile);
 
         Path target = config.getDataDirectory().toPath();
 
         if (LOG.isInfoEnabled()) {
             LOG.info("Import db to " + target);
         }
 
         try {
             progressionModel.setTotal(0);
             ZipUtils.uncompressFileToPath(zipFile, target, rootDirName, progressionModel, false);
         } catch (IOException e) {
             throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.restoreDb.extractFailed", zipFile), e);
         }
 
         // Migrate imported DB (Mantis #40873)
         migrateDbName();
     }
 
     /**
      * Rename old db name to new name (Mantis #40873)
      */
     public static void migrateDbName() {
 
         QuadrigeConfiguration config = QuadrigeConfiguration.getInstance();
         Assert.notNull(config);
 
         Path dbDir = Paths.get(config.getDbDirectory().getAbsolutePath());
         if (java.nio.file.Files.isDirectory(dbDir)) {
             try {
 
                 // find old db name
                 for (Path oldDbFile : java.nio.file.Files.list(dbDir).filter(path -> path.getFileName().toString().startsWith("quadrige2")).collect(Collectors.toList())) {
                     String fileName = oldDbFile.getFileName().toString();
                     int extensionIndex = fileName.lastIndexOf(".");
                     String extension = extensionIndex != -1 ? fileName.substring(extensionIndex) : "";
                     // Rename file
                     java.nio.file.Files.move(oldDbFile, oldDbFile.resolveSibling(config.getDbName() + extension));
                 }
             } catch (IOException e) {
                 throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.migrateDbName.error"), e);
             }
         }
 
     }
 
     public static String getRootDirectoryOfArchive(Path file) {
 
         QuadrigeConfiguration config = QuadrigeConfiguration.getInstance();
         Assert.notNull(config);
         Assert.notNull(file);
 
         if (!java.nio.file.Files.exists(file)) {
             throw new QuadrigeBusinessException(t("quadrige3.service.persistence.restoreDb.fileNotExist", file));
         }
 
         String rootDirectory = null;
         boolean dbDirectoryFound = false;
         boolean dbScriptFileFound = false;
 
         try {
             for (ZipEntry zipEntry : ZipUtils.getEntries(file)) {
                 if (zipEntry.isDirectory()) {
                     // search for root directory
                     if (rootDirectory == null) {
                         rootDirectory = zipEntry.getName().substring(0, zipEntry.getName().indexOf("/"));
                     } else if (!zipEntry.getName().startsWith(rootDirectory)) {
                         throw new QuadrigeBusinessException(t("quadrige3.service.persistence.restoreDb.tooManyChildren"));
                     }
                     // search for db directory
                     if (String.format("%s/%s/", rootDirectory, Daos.DB_DIRECTORY).equalsIgnoreCase(zipEntry.getName())) {
                         dbDirectoryFound = true;
                     }
                 } else {
                     // search for db script file
                     if (String.format("%s/%s/%s.%s", rootDirectory, Daos.DB_DIRECTORY, config.getDbName(), "script").equalsIgnoreCase(zipEntry.getName())) {
                         dbScriptFileFound = true;
                     }
                 }
             }
         } catch (IOException e) {
             throw new QuadrigeTechnicalException(t("quadrige3.service.persistence.restoreDb.readFailed", file), e);
         }
 
         if (!dbDirectoryFound)
             throw new QuadrigeBusinessException(t("quadrige3.service.persistence.restoreDb.itemNotFound", file, Daos.DB_DIRECTORY));
         if (!dbScriptFileFound)
             throw new QuadrigeBusinessException(t("quadrige3.service.persistence.restoreDb.itemNotFound", file, String.format("%s.%s", config.getDbName(), "script")));
 
         return rootDirectory;
     }
 
     /**
      * Delete database and related directories
      *
      * @param progressionModel the progression model
      */
     public static void deleteDatabaseDirectory(ProgressionCoreModel progressionModel) {
 
         QuadrigeCoreConfiguration config = QuadrigeCoreConfiguration.getInstance();
         Assert.notNull(config);
 
         List<Runnable> runnables = new ArrayList<>();
         runnables.add(() -> {
             // delete db directory
             File dbDirectory = config.getDbDirectory();
             if (dbDirectory.isDirectory()) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Delete previous database directory: " + dbDirectory);
                 }
                 Files.cleanDirectory(dbDirectory.toPath(), "Could not delete old db directory", progressionModel);
             }
         });
 
         runnables.add(() -> {
             // delete db cache directory
             File cacheDirectory = config.getCacheDirectory();
             if (cacheDirectory.isDirectory()) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Delete previous database cache directory: " + cacheDirectory);
                 }
                 Files.cleanDirectory(cacheDirectory.toPath(), "Could not delete old db cache directory", progressionModel);
             }
         });
 
         runnables.add(() -> {
             // delete synchro directory
             File synchroDirectory = config.getSynchronizationDirectory();
             if (synchroDirectory.isDirectory()) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Delete previous database data synchro directory: " + synchroDirectory);
                 }
                 // Use a clean directory (see Mantis#0029005)
                 Files.cleanDirectory(synchroDirectory.toPath(), "Could not delete old synchro directory", progressionModel);
             }
         });
 
         runnables.add(() -> {
             // delete measurement files directory
             File measFileDirectory = config.getDbAttachmentDirectory();
             if (measFileDirectory.isDirectory()) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Delete previous database measurement files directory: " + measFileDirectory);
                 }
                 // Use a clean directory (see Mantis#0029005)
                 Files.cleanDirectory(measFileDirectory.toPath(), "Could not delete old measurement files directory", progressionModel);
             }
         });
 
         runnables.add(() -> {
             // delete measurement files directory
             File photoDirectory = config.getDbPhotoDirectory();
             if (photoDirectory.isDirectory()) {
                 if (LOG.isInfoEnabled()) {
                     LOG.info("Delete previous database photos directory: " + photoDirectory);
                 }
                 // Use a clean directory (see Mantis#0029005)
                 Files.cleanDirectory(photoDirectory.toPath(), "Could not delete old photos directory", progressionModel);
             }
         });
 
         runnables.add(() -> {
             // delete other db directories
             config.getDbOtherDirectories().forEach(otherDirectory -> {
                 if (otherDirectory.isDirectory()) {
                     if (LOG.isInfoEnabled()) {
                         LOG.info("Delete previous database additional directory: " + otherDirectory);
                     }
                     Files.cleanDirectory(otherDirectory.toPath(), "Could not delete old additional directory: " + otherDirectory.getName(), progressionModel);
                 }
             });
         });
 
         runnables.forEach(Runnable::run);
 
     }
 
 }