package fr.ifremer.quadrige2.core.service.persistence;
   
   /*-
    * #%L
    * Quadrige2 Core :: Quadrige2 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 com.google.common.base.Preconditions;
  import fr.ifremer.quadrige2.core.exception.Quadrige2BusinessException;
  import fr.ifremer.quadrige2.core.exception.Quadrige2TechnicalException;
  import fr.ifremer.quadrige2.core.config.Quadrige2Configuration;
  import fr.ifremer.quadrige2.core.config.Quadrige2CoreConfiguration;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.commons.vfs2.AllFileSelector;
  import org.apache.commons.vfs2.FileName;
  import org.apache.commons.vfs2.FileObject;
  import org.apache.commons.vfs2.FileType;
  import org.joda.time.DateTime;
  import org.joda.time.format.DateTimeFormat;
  import org.joda.time.format.DateTimeFormatter;
  import org.nuiton.jaxx.application.ApplicationIOUtil;
  
  import java.io.File;
  
  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);
  
      public enum ImportStructureType {
  
          NORMAL, // normal structure with a db directory + optional meas_file directory
          INLINE // has only one root directory, with database files (.script, .properties) inside
      }
  
      /** Constant <code>EXPORT_DATE_FORMAT</code> */
      public static final DateTimeFormatter EXPORT_DATE_FORMAT = DateTimeFormat.forPattern("yyyy-MM-dd");
  
      public static final String EXPORT_DIRECTORY_FORMAT = "%s-%s-%s";
  
      /**
       * Export db as a zip archive (including the attachments and protocols).
       *
       * @param file archive file where to store
       * @since 1.0.2
       */
      public static void exportDb(File file) {
  
          // let the hsqldb database to close properly
          try {
              Thread.sleep(2000);
          } catch (InterruptedException e) {
              throw new Quadrige2TechnicalException(e);
          }
  
          Quadrige2CoreConfiguration config = Quadrige2CoreConfiguration.getInstance();
          Preconditions.checkNotNull(config);
  
          // need a file to export
          Preconditions.checkNotNull(file);
  
          // create zip structure
          String directoryName = String.format(
                  EXPORT_DIRECTORY_FORMAT,
                  config.getApplicationName(),
                  config.getVersion(),
                  EXPORT_DATE_FORMAT.print(new DateTime()));
  
          File structureDirectory = new File(config.newTempFile("exportdb"),
              directoryName);
  
          try {
              ApplicationIOUtil.forceMkdir(structureDirectory,
                  t("quadrige2.error.create.directory", structureDirectory));
 
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Export directory: " + structureDirectory);
             }
 
             ApplicationIOUtil.copyDirectory(config.getDbDirectory(),
                 new File(structureDirectory, "db"),
                 t("quadrige2.service.persistence.copyDirectory.db.error"));
 
             ApplicationIOUtil.copyDirectory(config.getDbAttachmentDirectory(),
                 new File(structureDirectory, "meas_files"),
                 t("quadrige2.service.persistence.copyDirectory.attachment.error"));
 
             // create zip
             ApplicationIOUtil.zip(structureDirectory, file,
                 t("quadrige2.service.persistence.exportDb.zip.error", file));
 
         } finally {
 
             // delete temp files
             ApplicationIOUtil.forceDeleteOnExit(
                 structureDirectory,
                 t("quadrige2.service.persistence.exportDb.deleteTempDir.error", structureDirectory));
         }
 
     }
 
     /**
      * Import a db from a zip archive (including the attachments and protocols).
      *
      * @param importStructureType type of structure of import
      * @param file archive file where to store
      * @since 1.0.2
      */
     public static void importDb(ImportStructureType importStructureType, File file) {
 
         // can not do this operation on a opened db
 //        Preconditions.checkState(!isDbLoaded());
         
         Quadrige2Configuration config = Quadrige2Configuration.getInstance();
         Preconditions.checkNotNull(config);
 
         // need a file to export
         Preconditions.checkNotNull(file);
 
         File target = config.getDataDirectory();
 
         if (LOG.isInfoEnabled()) {
             LOG.info("Import db to " + target);
         }
         FileObject fileObject = ApplicationIOUtil.resolveFile(
             "zip:" + file.getAbsolutePath(),
             t("quadrige2.service.persistence.getArchive.error", file));
 
         FileObject[] children = ApplicationIOUtil.getChildren(
             fileObject,
             t("quadrige2.service.persistence.openArchive.error", file));
 
         fileObject = children[0];
 
         switch (importStructureType) {
 
             case NORMAL:
                 // nothing special to do
                 break;
 
             case INLINE:
                 target = new File(target, "db");
                 ApplicationIOUtil.forceMkdir(
                     target,
                     t("quadrige2.service.persistence.createDbDirectory.error", file));
 
                 break;
             
             default:
             	break;
         }
 
         ApplicationIOUtil.explode(fileObject,
             target,
             new AllFileSelector(),
             t("quadrige2.service.persistence.extractArchive.error", file));
 
     }
 
     /**
      * <p>checkImportStructure.</p>
      *
      * @param file a {@link File} object.
      * @return a {@link ImportStructureType} object.
      */
     public static ImportStructureType checkImportStructure(File file) {
         if (!file.exists()) {
             throw new Quadrige2BusinessException(t("quadrige2.service.persistence.checkImportStructure.fileNotExist", file));
         }
 
         // check zip structure
         FileObject fileObject = ApplicationIOUtil.resolveFile(
                 "zip:" + file.getAbsolutePath(), t("quadrige2.service.persistence.getArchive.error", file));
 
         // Make sure only one root directory
         FileObject[] children = ApplicationIOUtil.getChildren(fileObject, t("quadrige2.service.persistence.openArchive.error", file));
         if (children.length != 1) {
             throw new Quadrige2BusinessException(t("quadrige2.service.persistence.checkImportStructure.tooManyChildren", file));
         }
         fileObject = children[0];
 
         ImportStructureType result;
         children = ApplicationIOUtil.getChildren(fileObject, t("quadrige2.service.persistence.openArchive.error", file));
 
         // try to detect a db directory
         boolean dbDirectoyDetected = false;
         for (FileObject child : children) {
             FileName name = child.getName();
             if ("db".equals(name.getBaseName())) {
                 dbDirectoyDetected = true;
                 break;
             }
         }
 
         if (dbDirectoyDetected) {
 
             // NORMAL type (two directories)
             result = ImportStructureType.NORMAL;
 
             checkArchiveDb(file, fileObject, "db", true);
             checkArchiveDb(file, fileObject, "meas_files", false);
         } else {
 
             // INLINE type
             result = ImportStructureType.INLINE;
 
             // Make sure the .script file exists
             boolean hasScriptFile = false;
             for (FileObject child : children) {
                 FileType type = ApplicationIOUtil.getType(child, "Could not get type of " + child);
                 if (FileType.FILE.equals(type)
                         && "script".equalsIgnoreCase(child.getName().getExtension())) {
                     hasScriptFile = true;
                     break;
                 }
             }
             if (!hasScriptFile) {
                 throw new Quadrige2BusinessException(t("quadrige2.service.persistence.checkImportStructure.inlineNoScriptFile"));
             }
         }
 
         if (LOG.isDebugEnabled()) {
             LOG.debug("Database import type: " + result);
         }
 
         return result;
     }
 
     /**
      * <p>checkArchiveDb.</p>
      *
      * @param file a {@link File} object.
      * @param fileObject a {@link FileObject} object.
      * @param dir a {@link String} object.
      * @param required a boolean.
      */
     protected static void checkArchiveDb(File file,
         FileObject fileObject,
         String dir,
         boolean required) {
         FileObject directory = ApplicationIOUtil.getChild(fileObject, dir, t("quadrige2.service.persistence.getChild.error", dir));
         if (directory == null) {
 
             String message = t("quadrige2.service.persistence.checkArchiveDb.error", file, dir);
             if (required) {
                 throw new Quadrige2BusinessException(message);
             }
 
             if (LOG.isWarnEnabled()) {
                 LOG.warn(message);
             }
         }
     }
 
 }