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.SynchroClientExportToFileResult;
  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.model.ProgressionUIModel;
  import fr.ifremer.quadrige3.ui.swing.synchro.SynchroUIContext;
  import fr.ifremer.quadrige3.ui.swing.synchro.SynchroUIHandler;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.nuiton.util.DateUtil;
  
  import java.io.File;
  import java.util.Date;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * <p>ExportAllReferentialToFileAction class.</p>
   *
   * @author benoit.lavenier@e-is.pro
   * @since 1.0
   */
  public class ExportReferentialToFileAction extends AbstractReloadCurrentScreenAction {
  
      private static final Log log = LogFactory.getLog(ExportReferentialToFileAction.class);
  
      private boolean hasReferential = false;
  
      protected File file;
  
      /**
       * <p>Constructor for ExportAllReferentialToFileAction.</p>
       *
       * @param handler a {@link AbstractMainUIHandler} object.
       */
      public ExportReferentialToFileAction(AbstractMainUIHandler handler) {
          super(handler, true);
          setActionDescription(t("quadrige3.action.synchro.exportReferentialToFile.title"));
      }
  
      /**
       * <p>Setter for the field <code>file</code>.</p>
       *
       * @param file a {@link File} object.
       */
      public void setFile(File file) {
          this.file = file;
      }
  
      /** {@inheritDoc} */
      @Override
      public boolean prepareAction() throws Exception {
          file = null;
          boolean doAction = super.prepareAction();
          if (!doAction) {
              return false;
          }
  
          String date = DateUtil.formatDate(new Date(), "yyyy-MM-dd");
  
          // ask user file where to export db
          file = saveFile(
                  getConfig().getSynchroZipFilePrefix() + date,
                  "zip",
                  t("quadrige3.synchro.export.choose.exportReferentialToFile.title"),
                  t("quadrige3.synchro.export.choose.exportReferentialToFile.buttonLabel"),
                  "^.*\\.zip", t("quadrige3.common.file.zip")
          );
          doAction = file != null;
  
         return doAction;
     }
 
 
     private SynchroUIContext getSynchroUIContext() {
         return getContext().getSynchroContext();
     }
 
     private SynchroUIHandler getSynchroHandler() {
         return getContext().getSynchroHandler();
     }
 
     /** {@inheritDoc} */
     @Override
     public void doActionBeforeReload() {
         hasReferential = false;
 
         SynchroClientService synchroService = ClientServiceLocator.instance().getSynchroClientService();
 
         getSynchroUIContext().saveExportContext();
 
         ProgressionUIModel mainProgressionModel = createProgressionUIModel(100);
         getSynchroUIContext().setStatus(SynchroProgressionStatus.RUNNING);
         getSynchroUIContext().saveExportContext();
 
         // build temp database and export local to temp
         getProgressionUIModel().setMessage(t("quadrige3.synchro.progress.export"));
 
         // export directory is set by the synchronization service
         SynchroClientExportToFileResult exportResult =  synchroService.exportAllReferentialToFile(
                 SecurityContextHelper.getQuadrigeUserId(),
                 file,
                 getProgressionUIModel(),
                 100);
 
         // If no data to export, stop here
         hasReferential = exportResult.getReferentialResult() != null && exportResult.getReferentialResult().getTotalTreated() > 0;
         if (!hasReferential) {
             showNoReferentialMessage();
             return;
         }
 
         getSynchroUIContext().setExportFileName(file.getName());
         getSynchroUIContext().saveExportContext();
 
         // delegate progression model from SynchroUIContext
         getProgressionUIModel().setTotal(100);
         setProgressionUIModel(getSynchroUIContext().getProgressionModel());
 
         // restore action progression model
         setProgressionUIModel(mainProgressionModel);
 
         // Skip screen reloading if not necessary
         setSkipScreenReload(!hasReferential);
     }
 
     /** {@inheritDoc} */
     @Override
     public void postSuccessAction() {
 
         super.postSuccessAction();
         if (log.isInfoEnabled()) {
             log.info("Synchronization export success");
         }
 
         getSynchroUIContext().resetExportContext();
         getSynchroUIContext().saveExportContext();
 
         // do not display if no data found
         if (!hasReferential) {
             getContext().getSynchroHandler().report(t("quadrige3.action.synchro.export.noReferential"), false);
         }
         else {
             getContext().getSynchroHandler().report(t("quadrige3.action.synchro.export.success"));
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public void postFailedAction(Throwable error) {
         super.postFailedAction(error);
 
         if (error != null) {
             log.error(t("quadrige3.action.synchro.export.failed.log", error.getMessage()));
         }
         else if(getSynchroUIContext().getProgressionModel() != null
                 && getSynchroUIContext().getProgressionModel().getMessage() != null) {
 
             String serverMessage = getSynchroUIContext().getProgressionModel().getMessage();
             log.error(t("quadrige3.action.synchro.export.failed.server.log", serverMessage));
         }
         else {
             log.error(t("quadrige3.action.synchro.export.failed"));
         }
 
         getSynchroUIContext().resetExportContext();
         getSynchroUIContext().saveExportContext();
 
         getContext().getSynchroHandler().report(t("quadrige3.action.synchro.export.failed"));
     }
 
     /* -- Internal methods -- */
 
     private void showNoReferentialMessage() {
         getContext().getDialogHelper().showMessageDialog(t("quadrige3.action.synchro.export.noReferential"),
                 t("quadrige3.action.synchro.export.result.title"));
     }
 
     /** {@inheritDoc} */
     @Override
     protected void releaseAction() {
         super.releaseAction();
         file = null;
         hasReferential = false;
     }
 }