package fr.ifremer.quadrige3.ui.swing.callback;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 UI Common
    * $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.collect.Maps;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.security.AuthenticationInfo;
  import fr.ifremer.quadrige3.ui.swing.ApplicationUIContext;
  import fr.ifremer.quadrige3.ui.swing.action.AbstractMainUIAction;
  import fr.ifremer.quadrige3.ui.swing.content.AbstractMainUIHandler;
  import fr.ifremer.quadrige3.ui.swing.model.ProgressionUIModel;
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.nuiton.jaxx.application.ApplicationTechnicalException;
  import org.nuiton.jaxx.application.swing.action.ApplicationActionException;
  import org.nuiton.updater.ApplicationInfo;
  import org.nuiton.updater.ApplicationUpdaterCallback;
  
  import java.io.File;
  import java.io.IOException;
  import java.util.Map;
  
  import static org.nuiton.i18n.I18n.n;
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * CallBack to update db.
   *
   * @since 2.6
   */
  public class DatabaseUpdaterCallBack implements ApplicationUpdaterCallback {
  
      /** Logger. */
      private static final Log LOG =
              LogFactory.getLog(DatabaseUpdaterCallBack.class);
  
      /** Constant <code>DB_UPDATE_NAME="db"</code> */
      public static final String DB_UPDATE_NAME = "db";
  
      static {
          n("quadrige3.update.db");
      }
  
      protected final ApplicationUIContext context;
  
      protected final AbstractMainUIHandler handler;
  
      protected final ProgressionUIModel progressionModel;
  
      protected boolean dbInstalled;
  
      protected boolean dbUpdated;
  
      protected final AbstractMainUIAction action;
  
      /**
       * <p>Constructor for DatabaseUpdaterCallBack.</p>
       *
       * @param action a {@link AbstractMainUIAction} object.
       * @param progressionModel a {@link ProgressionUIModel} object.
       */
      public DatabaseUpdaterCallBack(AbstractMainUIAction action, ProgressionUIModel progressionModel) {
          this.action = action;
          this.handler = action.getHandler();
          this.context = action.getContext();
          this.progressionModel = progressionModel;
      }
  
      /**
       * <p>isDbUpdated.</p>
       *
       * @return a boolean.
       */
      public boolean isDbUpdated() {
          return dbUpdated;
      }
 
     /**
      * <p>isDbInstalled.</p>
      *
      * @return a boolean.
      */
     public boolean isDbInstalled() {
         return dbInstalled;
     }
 
     /** {@inheritDoc} */
     @Override
     public Map<String, ApplicationInfo> updateToDo(Map<String, ApplicationInfo> appToUpdate) {
         Map<String, ApplicationInfo> result = Maps.newHashMap();
 
         ApplicationInfo info = appToUpdate.get(DB_UPDATE_NAME);
         if (info == null) {
             dbInstalled = false;
             dbUpdated = false;
         } else {
             result.put(info.name, info);
 
             if (info.needAuthentication) {
 
                 // ask auth
                 AuthenticationInfo authenticationInfo = handler.askAuthenticationInfo(info.url);
                 if (authenticationInfo != null) {
                     info.setAuthentication(authenticationInfo.getLogin(), authenticationInfo.getPassword().toCharArray());
                 }
             }
 
             if (context.isDbExist()) {
 
                 // when db exists always an update
                 dbUpdated = true;
             } else {
 
                 // when no db, then always install
                 dbInstalled = true;
             }
         }
 
         return result;
     }
 
     /** {@inheritDoc} */
     @Override
     public void startUpdate(ApplicationInfo info) {
 
         if (dbInstalled) {
             progressionModel.setMessage(t("quadrige3.applicationUpdater.startUpdate.db.installation", info.newVersion));
         } else if (dbUpdated) {
             progressionModel.setMessage(t("quadrige3.applicationUpdater.startUpdate.db.update", info.newVersion));
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void updateDone(Map<String, ApplicationInfo> appToUpdate,
                            Map<String, Exception> appUpdateError) {
 
         ApplicationInfo info = appToUpdate.get(DB_UPDATE_NAME);
         Exception error = appUpdateError.get(DB_UPDATE_NAME);
         if (error != null) {
 
             // something bad while updating db
             if (LOG.isErrorEnabled()) {
                 LOG.error("Could not update db", error);
             }
             String errorMessage;
             if (info != null && info.needAuthentication) {
                 errorMessage = t("quadrige3.updateDb.error.with.auth");
             } else {
                 errorMessage = t("quadrige3.updateDb.error.with.noauth");
             }
             throw ApplicationActionException.propagateError(
                     action, new ApplicationTechnicalException(errorMessage, error));
         } else if (info != null) {
 
             if (LOG.isInfoEnabled()) {
                 LOG.info(String.format(
                         "A db update was downloaded (oldVersion: %s, newVersion: %s), will process it.",
                         info.oldVersion, info.newVersion));
             }
 
             if (dbInstalled) {
 
                 // first database, just copy it to correct directory
                 prepareFirstDatabase(info);
             }
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void aborted(String propertiesURL, Exception eee) {
         if (LOG.isErrorEnabled()) {
             LOG.error("Could not update from " + propertiesURL, eee);
         }
         throw ApplicationActionException.propagateError(action, eee);
     }
 
     /**
      * <p>getDbDirectory.</p>
      *
      * @param info a {@link ApplicationInfo} object.
      * @return a {@link File} object.
      */
     protected File getDbDirectory(ApplicationInfo info) {
         File[] sources = info.destDir.listFiles();
         Assert.state(
                 sources != null && sources.length == 1,
                 "Downloaded db should contains one directory at " + info.destDir);
         return sources[0];
     }
 
     /**
      * <p>prepareFirstDatabase.</p>
      *
      * @param info a {@link ApplicationInfo} object.
      */
     protected void prepareFirstDatabase(ApplicationInfo info) {
         if (LOG.isInfoEnabled()) {
             LOG.info("First time database was downloaded at version: " + info.newVersion);
         }
         File source = getDbDirectory(info);
         File target = context.getConfiguration().getDbDirectory();
         if (LOG.isInfoEnabled()) {
             LOG.info(String.format("Copy from [%s] to [%s]", source , target));
         }
         try {
             FileUtils.copyDirectory(source, target);
         } catch (IOException e) {
             throw new ApplicationTechnicalException(t("quadrige3.applicationUpdater.prepareFirstDB.copyDirectory.error", source, target), e);
         }
         try {
             FileUtils.deleteDirectory(source.getParentFile());
         } catch (IOException e) {
             throw new ApplicationTechnicalException(t("quadrige3.applicationUpdater.prepareFirstDB.deleteDirectory.error", target), e);
         }
     }
 }