/**
    * This file Copyright (c) 2013-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.ui.mediaeditor.data;
  
  
  import info.magnolia.i18nsystem.SimpleTranslator;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.LinkedList;
  import java.util.Optional;
  
  import org.apache.commons.io.IOUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * Media State implementation that uses temporary files for maintaining a history of state
   * changes of media opened in media editor.
   *
   * State tracking is done in both direction - state changes can undone and redone.
   * Original state is stored in memory and the value can be rolled back to it.
   */
  public class MediaStateImpl implements MediaState {
      private static final Logger log = LoggerFactory.getLogger(MediaStateImpl.class);
  
      private static final int DEFAULT_DEPTH = 5;
  
      private static final String TEMP_FILE_PREFIX = "MEDIA_EDITOR_";
  
      private TempFileStack doneActions = new TempFileStack(DEFAULT_DEPTH);
  
      private TempFileStack unDoneActions = new TempFileStack(DEFAULT_DEPTH);
  
      private boolean currentActionInitialized;
  
      private Listener listener;
  
      private final SimpleTranslator i18n;
  
      private boolean inTransaction = false;
      private boolean valueChangePending;
      private byte[] valueBeforeTransaction;
      private byte[] value;
  
      public MediaStateImpl(byte[] value, SimpleTranslator i18n) {
          this.i18n = i18n;
          startTransaction();
          performMediaModification("");
          setState(value);
          valueBeforeTransaction = value;
      }
  
      public void startTransaction() {
          inTransaction = true;
          valueBeforeTransaction = getState();
      }
  
      @Override
      public void setListener(Listener listener) {
          this.listener = listener;
      }
  
      @Override
      public void clearState() {
          unDoneActions.clear();
         doneActions.clear();
     }
 
     @Override
     public void performMediaModification(String actionName) {
         if (!currentActionInitialized && doneActions.size() > 1) {
             doneActions.pop();
         }
         Record record = new Record();
         record.actionName = actionName;
         try {
             record.file = File.createTempFile(TEMP_FILE_PREFIX + actionName, null, null);
             record.file.deleteOnExit();
             doneActions.push(record);
             currentActionInitialized = false;
         } catch (IOException e) {
             logErrorAndNotify(i18n.translate("ui-mediaeditor.editHistoryTrackingProperty.tmpFileCreationFailure.message"), e);
         }
     }
 
     @Override
     public void undoLastState() {
         if (doneActions.size() > 1) {
             Record lastDone = doneActions.peek();
             unDoneActions.push(lastDone);
             doneActions.remove(lastDone);
             Optional.ofNullable(doneActions.peek()).ifPresent(this::updateValue);
         }
     }
 
     @Override
     public boolean canUndoLastState() {
         return doneActions.size() > 1;
     }
 
     @Override
     public boolean canRedoLastState() {
         return !unDoneActions.isEmpty();
     }
 
     @Override
     public void redoLastState() {
         if (!unDoneActions.isEmpty()) {
             final Record toBeRedone = unDoneActions.peek();
             updateValue(toBeRedone);
             doneActions.push(toBeRedone);
             unDoneActions.remove(toBeRedone);
         }
     }
 
     @Override
     public void revertState() {
         rollback();
         clearState();
     }
 
     public void rollback() {
         try {
             value = valueBeforeTransaction;
         } finally {
             valueChangePending = false;
             endTransaction();
         }
     }
 
     @Override
     public byte[] getState() {
         return value;
     }
 
     @Override
     public void commitState() {
         endTransaction();
         clearState();
     }
 
     @Override
     public void setState(byte[] bytes) {
         if (!unDoneActions.isEmpty() &&
             !unDoneActions.peek().actionName.equals(doneActions.peek().actionName)) {
             unDoneActions.clear();
         }
         currentActionInitialized = true;
         FileOutputStream fos = null;
         try {
             fos = new FileOutputStream(doneActions.peek().file);
             IOUtils.write(bytes, fos);
             this.value = bytes;
         } catch (IOException e) {
             logErrorAndNotify(i18n.translate("ui-mediaeditor.editHistoryTrackingProperty.ioException.message"), e);
         } finally {
             IOUtils.closeQuietly(fos);
         }
     }
 
     protected void endTransaction() {
         inTransaction = false;
         valueBeforeTransaction = null;
     }
 
     private void logErrorAndNotify(String message, Exception e) {
         log.error(message, e);
         if (listener != null) {
             listener.errorOccurred(message, e);
         }
     }
 
     private void updateValue(Record newLastDone) {
         FileInputStream fis = null;
         try {
             fis = new FileInputStream(newLastDone.file);
             value = IOUtils.toByteArray(fis);
         } catch (IOException e) {
             logErrorAndNotify(i18n.translate("ui-mediaeditor.editHistoryTrackingProperty.ioException.message"), e);
         } finally {
             IOUtils.closeQuietly(fis);
         }
     }
 
     /**
      * Helper class to store the action data in a file and
      * an action name which can be used in UI.
      */
     private static class Record {
 
         public File file;
 
         public String actionName;
     }
 
     /**
      * Simple and limited implementation of a stack of file records.
      *
      */
     private static class TempFileStack extends LinkedList<Record> {
 
         private int capacity;
 
         public TempFileStack(int capacity) {
             this.capacity = capacity;
         }
 
         @Override
         public void push(Record record) {
             while (size() > capacity) {
                 removeLast();
             }
             super.push(record);
         }
 
         @Override
         public Record pop() {
             Record result = super.pop();
             if (result != null) {
                 result.file.delete();
             }
             return result;
         }
 
         @Override
         public void clear() {
             while (!isEmpty()) {
                 pop();
             }
         }
 
         public void setCapacity(int capacity) {
             this.capacity = capacity;
         }
     }
 }