package fr.ifremer.quadrige3.ui.swing.synchro.action;
   
   /*-
    * #%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 fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.dao.technical.Daos;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.core.security.AuthenticationInfo;
  import fr.ifremer.quadrige3.core.security.SecurityContextHelper;
  import fr.ifremer.quadrige3.core.service.ClientServiceLocator;
  import fr.ifremer.quadrige3.synchro.meta.referential.ReferentialSynchroTables;
  import fr.ifremer.quadrige3.synchro.service.client.SynchroClientService;
  import fr.ifremer.quadrige3.synchro.service.client.vo.SynchroClientImportResult;
  import fr.ifremer.quadrige3.synchro.vo.SynchroImportContextVO;
  import fr.ifremer.quadrige3.synchro.vo.SynchroProgressionStatus;
  import fr.ifremer.quadrige3.ui.swing.action.AbstractReloadCurrentScreenAction;
  import fr.ifremer.quadrige3.ui.swing.content.AbstractMainUIHandler;
  import fr.ifremer.quadrige3.ui.swing.synchro.SynchroUIContext;
  import fr.ifremer.quadrige3.ui.swing.synchro.SynchroUIHandler;
  import fr.ifremer.quadrige3.ui.swing.synchro.resolver.SynchroRejectedRowUIResolver;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.nuiton.i18n.I18n;
  import org.nuiton.jaxx.application.ApplicationIOUtil;
  import org.nuiton.updater.ApplicationUpdater;
  import org.nuiton.util.FileUtil;
  
  import java.io.File;
  import java.util.List;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * <p>ImportSynchroApplyAction class.</p>
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class ImportSynchroApplyAction extends AbstractReloadCurrentScreenAction {
  
      private static final Log log = LogFactory.getLog(ImportSynchroApplyAction.class);
  
      private File dbDirToImport;
  
      private boolean silent = false;
      private boolean needAuthentication = false;
      private boolean hasReferential = false;
      private boolean hasData = false;
  
      /**
       * <p>Constructor for ImportSynchroApplyAction.</p>
       *
       * @param handler a {@link AbstractMainUIHandler} object.
       */
      public ImportSynchroApplyAction(AbstractMainUIHandler handler) {
          super(handler, true);
          setActionDescription(t("quadrige3.action.synchro.import.title"));
      }
  
      private SynchroUIContext getSynchroUIContext() {
          return getContext().getSynchroContext();
      }
  
      private SynchroUIHandler getSynchroHandler() {
          return getContext().getSynchroHandler();
      }
  
      /**
       * <p>Setter for the field <code>silent</code>.</p>
       *
       * @param silent a boolean.
       */
      public void setSilent(boolean silent) {
          this.silent = silent;
      }
  
      /**
       * {@inheritDoc}
      */
     @Override
     public boolean prepareAction() throws Exception {
         super.prepareAction();
 
         // get the db directory from context 
         dbDirToImport = getSynchroUIContext().getWorkingDirectory();
 
         // if dbDirToImport is not set, try to get it from file
         if (dbDirToImport == null) {
 
             File userDir = getSynchroUIContext().getImportDirectory();
             if (userDir.isDirectory()) {
 
                 List<File> files = FileUtil.getSubDirectories(userDir);
                 if (CollectionUtils.isEmpty(files)) {
                     return false;
                 }
                 if (files.size() > 1) {
                     // should never append but find the newest one
                     files.sort((f1, f2) -> Long.compare(f2.lastModified(), f1.lastModified()));
                 }
                 dbDirToImport = files.get(0);
             }
         }
 
         if (!dbDirToImport.isDirectory()) {
             throw new QuadrigeTechnicalException(I18n.t("quadrige3.error.directory.not.exists", dbDirToImport.getAbsolutePath()));
         }
 
         // Normalize the DB directory
         dbDirToImport = Daos.checkAndNormalizeDbDirectory(dbDirToImport);
 
         getSynchroHandler().hidePopup();
 
         return true;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void doActionBeforeReload() throws Exception {
         Assert.notNull(dbDirToImport);
 
         createProgressionUIModel(103);
 
         // get actual version
         String actualVersion = ApplicationUpdater.loadVersionFile("db", getConfig().getDbDirectory());
         String newVersion = ApplicationUpdater.loadVersionFile("synchro db", dbDirToImport);
         if (log.isInfoEnabled()) {
             log.info(String.format("A database update was downloaded (oldVersion: %s, newVersion: %s), will launch a referential & data synchronize operation ", actualVersion, newVersion));
         }
 
         SynchroClientService service = ClientServiceLocator.instance().getSynchroClientService();
         SynchroImportContextVO contextVO = getSynchroUIContext().getSynchroImportContext();
         SynchroClientImportResult result = service.importFromTempDb(
                 SecurityContextHelper.getQuadrigeUserId(),
                 dbDirToImport,
                 contextVO,
                 new SynchroRejectedRowUIResolver(getContext().getDialogHelper(), true/*isImport*/),
                 getProgressionUIModel(),
                 100);
 
         // check if updates
         hasReferential = result.getReferentialResult() != null && result.getReferentialResult().getTotalTreated() > 0;
         hasData = result.getDataResult() != null && result.getDataResult().getTotalTreated() > 0;
 
         // Reset all cache (if referential updates)
         if (hasReferential) {
             if (log.isInfoEnabled()) {
                 log.info("Reset all caches.");
             }
             getProgressionUIModel().setMessage(t("quadrige3.synchro.progress.resetCache"));
             getContext().reloadDbCache(getProgressionUIModel());
 
             // Check for user privilege changes
             if (result.getReferentialResult().getNbUpdates(ReferentialSynchroTables.QUSER_PRIVILEGE.name()) > 0) {
                 // re-authenticate the current user in case of its privilege have changed (Mantis #38841)
                 getContext().tryReAuthenticate();
             }
         }
 
         if (!getContext().isAuthenticated()) {
             // If the login has changed to another user, the re-authentication could have failed
             // Do not try to store the import context (mantis #23535) because the user id is not known
             needAuthentication = true;
             if (log.isInfoEnabled()) {
                 log.warn(t("quadrige3.action.synchro.import.success.notAuthenticated"));
             }
             // reset synchronization context
             getSynchroUIContext().resetImportContext();
             getProgressionUIModel().increments(2);
         } else {
             getProgressionUIModel().increments(t("quadrige3.synchro.progress.saveContext"));
 
             // reset synchronization context
             getSynchroUIContext().resetImportContext();
 
             // Update last update date for referential (only if update done)
             if (getSynchroUIContext().isImportReferential()) {
                 getSynchroUIContext().setImportReferentialUpdateDate(result.getReferentialSynchronizationDate());
             }
 
             // Update last update date for data (only if update done and if there are no rejects left)
             if (getSynchroUIContext().isImportData()) {
                 getSynchroUIContext().setImportDataUpdateDate(result.getDataSynchronizationDate());
             }
             // save context with data date range
             getSynchroUIContext().saveImportContext(true, true);
         }
 
         getProgressionUIModel().increments(t("quadrige3.synchro.progress.cleanTemporaryFiles"));
 
         // clean local directories and send acknowledge to server
         clean();
 
         // Skip screen reloading if no updates, or if already ask (e.g. by the parent action)
         setSkipScreenReload(silent || isSkipScreenReload() || (!hasData && !hasReferential));
     }
 
     private void clean() throws Exception {
 
         // delete imported database on exit
         ApplicationIOUtil.forceDeleteOnExit(dbDirToImport, t("quadrige3.error.delete.directory", dbDirToImport.getAbsolutePath()));
 
         // send acknowledge
         ImportSynchroAckAction ackAction
                 = getContext().getActionFactory().createNonBlockingUIAction(
                 getSynchroHandler(),
                 ImportSynchroAckAction.class);
         ackAction.executeAndWait();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void postSuccessAction() {
         super.postSuccessAction();
 
         // Force re-authentication
         if (!needAuthentication) {
             AuthenticationInfo authenticationInfo = getContext().getAuthenticationInfo();
             if (authenticationInfo != null) {
                 boolean authenticated = SecurityContextHelper.authenticate(authenticationInfo.getLogin(), authenticationInfo.getPassword());
                 if (!authenticated) {
                     log.error("Cannot reauthenticate !");
                 }
             }
         }
 
 
         getHandler().reloadDbManagerText();
 
         // Show correct message (Mantis #49003)
         String message = hasData
                 ? t("quadrige3.action.synchro.import.success.data")
                 : hasReferential
                 ? t("quadrige3.action.synchro.import.success.referential")
                 : t("quadrige3.synchro.report.idle");
         if (needAuthentication)
             message += " " + t("quadrige3.action.synchro.import.success.notAuthenticated");
 
         getSynchroHandler().report(message, !silent);
 
         if (log.isInfoEnabled()) {
             log.info("Synchronization import success");
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void postFailedAction(Throwable error) {
         if (!silent) {
             super.postFailedAction(error);
         }
 
         getSynchroHandler().report(t("quadrige3.synchro.report.failed"), !silent);
         getSynchroUIContext().setStatus(SynchroProgressionStatus.FAILED);
 
         log.error("Synchronization import failed");
     }
 
     @Override
     protected void releaseAction() {
         super.releaseAction();
 
         silent = false;
         needAuthentication = false;
         hasReferential = false;
         hasData = false;
     }
 }