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.Lists;
  import com.google.common.collect.Maps;
  import fr.ifremer.quadrige3.ui.swing.ApplicationUIContext;
  import fr.ifremer.quadrige3.ui.swing.action.AbstractAction;
  import fr.ifremer.quadrige3.ui.swing.model.ProgressionUIModel;
  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.util.List;
  import java.util.Map;
  
  import static org.nuiton.i18n.I18n.n;
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * CallBack to update config.
   *
   * @author Ludovic Pecquot
   * @since 1.2.2
   */
  public class DataUpdaterCallBack implements ApplicationUpdaterCallback {
  
      /**
       * Logger.
       */
      private static final Log LOG = LogFactory.getLog(DataUpdaterCallBack.class);
  
      public enum UpdateType {
  
          CONFIG(n("quadrige3.update.config"));
  
          private final String i18nKey;
  
          UpdateType(String i18nKey) {
              this.i18nKey = i18nKey;
          }
  
          public String getLabel() {
              return t(i18nKey);
          }
      }
  
      protected final ApplicationUIContext context;
  
      protected List<UpdateType> types;
  
      protected final ProgressionUIModel progressionModel;
  
      protected boolean dataUpdated;
  
      protected final AbstractAction<?, ?, ?> action;
  
      /**
       * <p>Constructor for DataUpdaterCallBack.</p>
       *
       * @param action a {@link AbstractAction} object.
       * @param progressionModel a {@link ProgressionUIModel} object.
       */
      public DataUpdaterCallBack(AbstractAction<?, ?, ?> action, ProgressionUIModel progressionModel) {
          this.action = action;
          this.context = action.getContext();
          this.progressionModel = progressionModel;
      }
  
      /**
       * <p>Setter for the field <code>types</code>.</p>
       *
       * @param types a {@link DataUpdaterCallBack.UpdateType} object.
       */
     public void setTypes(UpdateType... types) {
         this.types = Lists.newArrayList(types);
     }
 
     /**
      * <p>isDataUpdated.</p>
      *
      * @return a boolean.
      */
     public boolean isDataUpdated() {
         return dataUpdated;
     }
 
     /** {@inheritDoc} */
     @Override
     public Map<String, ApplicationInfo> updateToDo(Map<String, ApplicationInfo> appToUpdate) {
         Map<String, ApplicationInfo> result = Maps.newHashMap();
 
         for (UpdateType type : types) {
             ApplicationInfo info = getInfo(type, appToUpdate);
             if (info != null) {
                 result.put(info.name, info);
             }
         }
         return result;
     }
 
     /** {@inheritDoc} */
     @Override
     public void startUpdate(ApplicationInfo info) {
         if (UpdateType.CONFIG.name().toLowerCase().equals(info.name)) {
             progressionModel.setMessage(t("quadrige3.applicationUpdater.startUpdate.config", info.newVersion));
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void updateDone(Map<String, ApplicationInfo> appToUpdate, Map<String, Exception> appUpdateError) {
 
         if (updateDoneConfig(appToUpdate, appUpdateError)) {
             dataUpdated = true;
         }
     }
 
     /** {@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>updateDoneConfig.</p>
      *
      * @param appToUpdate a {@link Map} object.
      * @param appUpdateError a {@link Map} object.
      * @return a boolean.
      */
     protected boolean updateDoneConfig(Map<String, ApplicationInfo> appToUpdate,
         Map<String, Exception> appUpdateError) {
         boolean doRestart = false;
         Exception error = getError(UpdateType.CONFIG, appUpdateError);
         if (error != null) {
 
             // something bad while updating config
             throw ApplicationActionException.propagateError(
                 action, new ApplicationTechnicalException(t("quadrige3.applicationUpdater.config.error"), error));
         }
         ApplicationInfo info = getInfo(UpdateType.CONFIG, appToUpdate);
         if (info != null) {
 
             if (LOG.isInfoEnabled()) {
                 LOG.info(String.format(
                     "A config update was downloaded (oldVersion: %s, newVersion: %s), will process it and application will restart",
                     info.oldVersion, info.newVersion));
             }
             doRestart = true;
 
             // Don't update config now, but let the updater do the job to prevent properties loose (Mantis #46826)
             // Get the new config file
 //            try {
 //
 //                // Load file
 //                Properties p = new Properties();
 //                File f = new File(info.destDir, "config/" + context.getConfiguration().getApplicationConfig().getConfigFileName());
 //                p.load(Files.newReader(f, Charsets.UTF_8));
 //
 //                // Updates or create missing properties and save all
 //                context.getConfiguration().overridesOptions(p);
 //                context.getConfiguration().save();
 //
 //                // Create local version.appup
 //                ApplicationUpdater.createVersionFile(context.getConfiguration().getConfigDirectory(), info.newVersion);
 //
 //            } catch (IOException ex) {
 //                throw ApplicationActionException.propagateError(
 //                    action, new ApplicationTechnicalException(t("quadrige3.applicationUpdater.config.io.error"), ex));
 //            }
         }
         return doRestart;
     }
 
     /**
      * <p>getInfo.</p>
      *
      * @param type a {@link DataUpdaterCallBack.UpdateType} object.
      * @param appToUpdate a {@link Map} object.
      * @return a {@link ApplicationInfo} object.
      */
     protected ApplicationInfo getInfo(UpdateType type, Map<String, ApplicationInfo> appToUpdate) {
         return appToUpdate.get(type.name().toLowerCase());
     }
 
     /**
      * <p>getError.</p>
      *
      * @param type a {@link DataUpdaterCallBack.UpdateType} object.
      * @param appUpdateError a {@link Map} object.
      * @return a {@link Exception} object.
      */
     protected Exception getError(UpdateType type, Map<String, Exception> appUpdateError) {
         return appUpdateError.get(type.name().toLowerCase());
     }
 }