package fr.ifremer.quadrige3.synchro.server.service.technical;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Synchro server
    * $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.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.core.config.QuadrigeConfiguration;
  import fr.ifremer.quadrige3.core.dao.technical.Daos;
  import fr.ifremer.quadrige3.core.dao.technical.ZipUtils;
  import fr.ifremer.quadrige3.synchro.server.config.SynchroServerConfiguration;
  import fr.ifremer.quadrige3.synchro.service.doc.DocSynchroService;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.io.FilenameUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.hibernate.cfg.Environment;
  import org.nuiton.i18n.I18n;
  import org.nuiton.version.Version;
  import org.springframework.beans.factory.InitializingBean;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  
  import java.io.File;
  import java.io.IOException;
  import java.sql.SQLException;
  import java.util.Properties;
  
  import static org.nuiton.i18n.I18n.t;
  
  @Service("databaseSchemaService")
  public class DatabaseSchemaServiceImpl extends fr.ifremer.quadrige3.core.service.DatabaseSchemaServiceImpl implements DatabaseSchemaService, InitializingBean {
  
      private static final Log log = LogFactory.getLog(DatabaseSchemaServiceImpl.class);
  
      private File emptyDbFileCache;
  
      private File tableRelationFileCache;
  
      @Autowired
      protected SynchroServerConfiguration synchroServerConfig;
  
      @Autowired
      protected DocSynchroService docSynchroService;
  
      @Autowired
      public DatabaseSchemaServiceImpl(QuadrigeConfiguration config) {
          this.config = config;
          this.emptyDbFileCache = null;
      }
  
      @Override
      public void afterPropertiesSet() {
          // Fill the cache at startup
          initDbFileCache();
      }
  
      @Override
      public void createEmptyDb(File dbDirectory) {
          // Empty DB not exists: ask for creation
          if (emptyDbFileCache == null || !emptyDbFileCache.exists()) {
              // File could have been deleted manually : so recreate it !
              emptyDbFileCache = null;
              initDbFileCache();
  
              // If file still not exists: stop here
              if (emptyDbFileCache == null || !emptyDbFileCache.exists()) {
                  throw new QuadrigeTechnicalException(t("quadrige3.synchro.server.import.newDatabase.noEmptyZipFile.error", emptyDbFileCache.getPath()));
              }
          }
  
          try {
              ZipUtils.uncompressFileToPath(emptyDbFileCache.toPath(), dbDirectory.toPath(), false);
          } catch (IOException e) {
              // Log but continue (empty db will be recreated
              log.error(t("quadrige3.synchro.server.import.newDatabase.unzipDirectory.error", config.getVersion().toString()), e);
          }
      }
  
     @Override
     public File getEmptyDbFile() {
         return emptyDbFileCache;
     }
 
     @Override
     public File getTableRelationFileCache() {
         return tableRelationFileCache;
     }
 /* -- internal methods -- */
 
     /**
      * Create a cached empty DB (as a zip file)
      */
     private void initDbFileCache() {
 
         if (emptyDbFileCache == null) {
             emptyDbFileCache = createEmptyDbZipFile();
             tableRelationFileCache = new File(emptyDbFileCache.getParentFile(), FilenameUtils.removeExtension(emptyDbFileCache.getName()) + ".json");
         }
         if (emptyDbFileCache.exists()) {
             if (log.isInfoEnabled()) {
                 log.info(I18n.t("quadrige3.synchro.server.init.emptyDb.skip", emptyDbFileCache.getPath()));
             }
             return;
         }
 
         log.info(I18n.t("quadrige3.synchro.server.init.emptyDb.task", emptyDbFileCache.getPath()));
 
         // Create the DB into a temp directory
         File emptyDbDirectory = new File(config.getTempDirectory(), String.valueOf(System.currentTimeMillis()));
         generateAndUpdateNewTemporaryDb(emptyDbDirectory);
 
         // Create a zip
         try {
             if (emptyDbFileCache.exists()) {
                 FileUtils.forceDelete(emptyDbFileCache);
             }
 
             ZipUtils.compressFilesInPath(
                     emptyDbDirectory.toPath(),
                     emptyDbFileCache.toPath(),
                     true // Delete the temp directory after compression
             );
         } catch (IOException e) {
             // Log but continue : do care (another thread is maybe writing the file)
             log.error(t("quadrige3.synchro.server.init.emptyDb.zipDirectory.error", config.getVersion().toString()), e);
             throw new QuadrigeTechnicalException(t("quadrige3.synchro.server.init.emptyDb.zipDirectory.error", config.getVersion().toString()), e);
         }
     }
 
     private File createEmptyDbZipFile() {
 
         // Compute DB Zip file
         Version quadrigeVersion = databaseSchemaDao.getSchemaVersionIfUpdate();
         File synchroDirectory = config.getSynchronizationDirectory();
 
         return new File(synchroDirectory, "db-" + quadrigeVersion.toString() + ".zip");
     }
 
     private void generateAndUpdateNewTemporaryDb(File emptyDbDirectory) {
 
         Properties connectionProperties = synchroServerConfig.getClientConnectionProperties();
         connectionProperties.setProperty(Environment.URL, Daos.getJdbcUrl(emptyDbDirectory, config.getDbName()));
 
         // empty db not exists (or error occur during unzip), so create a new one
         try {
             try {
 
                 databaseSchemaDao.generateNewDb(emptyDbDirectory, false, null, connectionProperties, true/*temporary DB*/);
 
                 // Update the schema (will insert values into SYSTEM_VERSION)
                 databaseSchemaDao.updateSchema(connectionProperties);
 
                 // Read all metadata and create table relations file
                 docSynchroService.createTableRelationsFile(connectionProperties, tableRelationFileCache);
 
             } catch (Throwable e) {
                 throw new QuadrigeTechnicalException(t("quadrige3.synchro.server.init.emptyDb.updateSchema.error"), e);
             }
         } finally {
             closeSilently(connectionProperties);
         }
     }
 
     private void closeSilently(Properties connectionProperties) {
         try {
             Daos.shutdownDatabase(connectionProperties);
         } catch (SQLException e) {
             // Silent !
         }
     }
 }