/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  package org.apache.myfaces.orchestra.conversation.versioning;
  
  import java.util.Map;
  import java.util.Stack;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.myfaces.orchestra.conversation.Conversation;
  import org.apache.myfaces.orchestra.conversation.ConversationContext;
  import org.apache.myfaces.orchestra.conversation.ConversationDataHolder;
  import org.apache.myfaces.orchestra.conversation.ConversationFactory;
  import org.apache.myfaces.orchestra.conversation.SerializingConversationDataHolder;
  import org.apache.myfaces.orchestra.conversation.versioning.spring.SpringVersioningScope;
  
  /**
   * A special kind of conversation which provides snapshot- and rollback functionality.
   * Both commands can be triggered from within a version scoped managed-bean.
   * <p/>
   * A typical usecase may be a multi-edit page whith different levels of edit-/cancel actions
   * on a hierarchical tree of objects. (e.g. Company -> persons -> addresses)
   * <p/>
   * Triggering a snapshot will "copy" the whole conversational data, means all the beans which
   * are currently located in this conversation.
   * The "copy" process currently only supports serializing {@link SerializingConversationDataHolder},
   * cloning maybe added in future versions. Triggering snapshots should be done with care, since
   * it adds some overhead to memory and is therefore no that well scaleable.
   */
  public class VersioningConversation extends Conversation
  {
      private final Log log = LogFactory.getLog(VersioningConversation.class);
  
      // The placeholders for user references to a snapshot
      private Stack<SavePoint> savePoints = new Stack<SavePoint>();
  
      // The real saved conversational data - beans
      private Stack<ConversationDataHolder> conversationVersions = new Stack<ConversationDataHolder>();
  
      // choosen strategy to store the data
      private String versioningStrategy;
  
      public VersioningConversation(ConversationContext conversationContext,
              String name, ConversationFactory factory, String strategy)
      {
          super(conversationContext, name, factory);
          versioningStrategy = strategy;
      }
  
      /**
       * Creates a snapshot of the actual conversational data. Should be held
       * inside the managed-bean for later rollback reference.
       * <p/>
       * Does NOT add any overhead directly to the managed-bean. It represents
       * just a placeholder.
       *
       * @return SavePoint a placeholder for a current snaphsot
       */
      public SavePoint createSavePoint()
      {
          SavePoint savePoint = new SavePoint();
          createConversationDataSnapshot(savePoint);
          return savePoint;
      }
  
      /**
       * Creates a snapshot of the actual conversational data.
       * <p/>
       *
       * @param savePointName The name of the snapshot; Should be "remembered"
       *                      for later rollback references.
       */
      public void createSavePoint(String savePointName)
      {
          SavePoint savePoint = new SavePoint(savePointName);
          createConversationDataSnapshot(savePoint);
      }
  
      /**
       * Reverts to the given snapshot (SavePoint).
       * Seeks the snapshot, gets the corresponding data, restores it and frees it out of the memory.
       */
     public void revertToSavePoint(SavePoint savePoint)
     {
         int savePointIndex = savePoints.indexOf(savePoint);
         removeConversationDataSnapshot(savePointIndex);
     }
 
     /**
      * Reverts to a snapshot via the given SavePoint name.
      */
     public void revertToSavePoint(String savePointName)
     {
         int savePointIndex = findSavePointIndex(savePointName);
         removeConversationDataSnapshot(savePointIndex);
     }
 
     /**
      * Reverts to the last snapshot.
      */
     public void revertToLastSavePoint()
     {
         if(!savePoints.isEmpty())
         {
             SavePoint lastSavePoint = savePoints.pop();
             ConversationDataHolder conversationDataHolder = conversationVersions.pop();
             Map restoredBeans = conversationDataHolder.getConversationBeans();
             setBeans(restoredBeans);
         }
         else
         {
             log.error("No savepoints stored before. Unable to revert to last save point!");
         }
     }
 
     /**
      * Frees all SavePoints and versioned conversational data
      */
     public void clearAllSavePoints()
     {
         savePoints.removeAllElements();
         conversationVersions.removeAllElements();
     }
 
     private void createConversationDataSnapshot(SavePoint savePoint)
     {
         ConversationDataHolder conversationDataHolder = createConversationDataHolder();
         conversationVersions.push(conversationDataHolder);
         savePoints.push(savePoint);
     }
 
     /**
      * Restores a previous snapshot and sets it as the actual versioned conversational data.
      * Frees the actual SavePoint and the corresponding data at the given index.
      */
     private void removeConversationDataSnapshot(int savePointIndex)
     {
         if(savePointIndex != -1)
         {
             savePoints.remove(savePointIndex);
             ConversationDataHolder conversationDataHolder = conversationVersions.get(savePointIndex);
             Map restoredBeans = conversationDataHolder.getConversationBeans();
             setBeans(restoredBeans);
             conversationVersions.remove(savePointIndex);
         }
         else
         {
             log.error("No savepoint to revert found!");
         }
     }
 
     /**
      * Chooses the DataHolder regarding the strategy and stores the conversational data "somewhere"
      */
     private ConversationDataHolder createConversationDataHolder()
     {
         if(versioningStrategy.equals(SpringVersioningScope.VERSIONING_STRATEGY_SERIALIZATION))
         {
             return new SerializingConversationDataHolder(getBeans());
         }
         else
         {
             throw new UnsupportedOperationException("Cloning not implemented yet!");
         }
     }
 
     private int findSavePointIndex(String savePointName)
     {
         for(int i = 0; i < savePoints.size(); i++)
         {
             SavePoint savePoint = savePoints.elementAt(i);
             String name = savePoint.getSavePointName();
             if(name.equals(savePointName))
             {
                 return i;
             }
         }
         return -1;
     }
 
 }