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.security.SecurityContextHelper;
  import fr.ifremer.quadrige3.core.service.ClientServiceLocator;
  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.Screen;
  import fr.ifremer.quadrige3.ui.swing.action.AbstractChangeScreenAction;
  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.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * <p>ImportSynchroDirectAction class.</p>
   *
   * @author Ludovic Pecquot <ludovic.pecquot@e-is.pro>
   */
  public class ImportSynchroDirectAction extends AbstractChangeScreenAction {
  
      private static final Log log = LogFactory.getLog(ImportSynchroDirectAction.class);
  
      private boolean silent = false;
      private boolean needAuthentication = false;
  
      /**
       * <p>Constructor for ImportSynchroDirectAction.</p>
       *
       * @param handler a {@link AbstractMainUIHandler} object.
       */
      public ImportSynchroDirectAction(AbstractMainUIHandler handler) {
          super(handler, true, Screen.HOME);
          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();
  
          getSynchroHandler().hidePopup();
  
          return true;
      }
  
      /** {@inheritDoc} */
      @Override
      public void doAction() throws Exception {
  
          createProgressionUIModel(103);
  
          SynchroClientService service = ClientServiceLocator.instance().getSynchroClientService();
         SynchroImportContextVO contextVO = getSynchroUIContext().getSynchroImportContext();
         SynchroClientImportResult result = service.importFromServerDatabase(
                 SecurityContextHelper.getQuadrigeUserId(),
                 contextVO,
                 new SynchroRejectedRowUIResolver(getContext().getDialogHelper(), true /*isImport*/),
                 getProgressionUIModel(),
                 100);
 
         // reset cache
         {
             if (log.isInfoEnabled()) {
                 log.info("Reset all caches.");
             }
             getProgressionUIModel().setMessage(t("quadrige3.synchro.progress.resetCache"));
             getContext().reloadDbCache(getProgressionUIModel());
         }
 
         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(1);
         } 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()) {
                 // Not need to remove a delta (already done in the server when exported data)
                 getSynchroUIContext().setImportDataUpdateDate(result.getDataSynchronizationDate());
             }
             // save context with data date range
             getSynchroUIContext().saveImportContext(true, true);
         }
 
         getProgressionUIModel().increments(1);
 
         // if silent, stay on the current screen
         if (!silent) {
             super.doAction();
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void postSuccessAction() {
         super.postSuccessAction();
 
         getHandler().reloadDbManagerText();
 
         getSynchroHandler().report(needAuthentication
                 ? t("quadrige3.action.synchro.import.success.notAuthenticated")
                 : t("quadrige3.action.synchro.import.success"), !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;
     }
 }