/**
    * This file Copyright (c) 2013 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.module.exchangesimple.monitor;
  
  import info.magnolia.cms.i18n.MessagesManager;
  
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Date;
  import java.util.Map;
  import java.util.concurrent.atomic.AtomicInteger;
  import java.util.concurrent.atomic.AtomicLong;
  
  import org.apache.commons.collections.Buffer;
  import org.apache.commons.collections.BufferUtils;
  import org.apache.commons.collections.buffer.CircularFifoBuffer;
  import org.apache.commons.collections.map.LRUMap;
  
  /**
   * Implementation of activation storage that holds all informations in memory.
   */
  public class MemoryActivationStorage implements ActivationStorage {
  
      private static final String DATE_FORMAT = MessagesManager.getMessages("info.magnolia.module.exchangesimple.messages").get("activationMonitor.dateformat");
  
      private static SimpleDateFormat date = new SimpleDateFormat(DATE_FORMAT);
  
      private AtomicInteger activations;
      private AtomicInteger deactivations;
      private AtomicInteger activationErrors;
      private AtomicInteger commitedTransactions;
      private AtomicInteger rollbackedTransactions;
      private AtomicLong sizeOfActivatedContent;
      private AtomicLong activationTime;
      private Date lastRestart;
      private Buffer activationLog;
      private Buffer activationErrorLog;
      private Map<String, Integer> activationsPerWorkspace;
      private Map<String, Buffer> activationsMadeByUser;
      private Map<String, ResponseTimeEntry> subscriberResponseTimes;
  
      @SuppressWarnings("unchecked")
      public MemoryActivationStorage() {
          activations = new AtomicInteger();
          deactivations = new AtomicInteger();
          activationErrors = new AtomicInteger();
          commitedTransactions = new AtomicInteger();
          rollbackedTransactions = new AtomicInteger();
          sizeOfActivatedContent = new AtomicLong();
          activationTime = new AtomicLong();
          lastRestart = Calendar.getInstance().getTime();
          activationLog = BufferUtils.synchronizedBuffer(new CircularFifoBuffer(500));
          activationErrorLog = BufferUtils.synchronizedBuffer(new CircularFifoBuffer(500));
          activationsPerWorkspace = Collections.synchronizedMap(new LRUMap(500));
          activationsMadeByUser = Collections.synchronizedMap(new LRUMap(500));
          subscriberResponseTimes = Collections.synchronizedMap(new LRUMap(500));
      }
  
      @SuppressWarnings("unchecked")
      @Override
      public void logActivation(String path, String user, String workspaceName, String subscriber, boolean deactivation, boolean success) {
          if (deactivation) {
              deactivations.incrementAndGet();
          } else {
              activations.incrementAndGet();
          }
 
         ActivationLogEntry entry = new ActivationLogEntry(deactivation, success, path, subscriber, user, workspaceName, getCurrentDate());
 
         this.activationLog.add(entry);
 
         if (!this.activationsPerWorkspace.containsKey(workspaceName)) {
             this.activationsPerWorkspace.put(workspaceName, 1);
         } else {
             AtomicInteger count = new AtomicInteger(this.activationsPerWorkspace.get(workspaceName));
             this.activationsPerWorkspace.put(workspaceName, count.incrementAndGet());
         }
 
         if (!this.activationsMadeByUser.containsKey(user)) {
             Buffer buffer = BufferUtils.synchronizedBuffer(new CircularFifoBuffer(100));
             buffer.add(entry);
             this.activationsMadeByUser.put(user, buffer);
         } else {
             Buffer buffer = this.activationsMadeByUser.get(user);
             buffer.add(entry);
         }
     }
 
     private static String getCurrentDate() {
         final Date d = Calendar.getInstance().getTime();
         return date.format(d);
     }
 
     @Override
     public int getActivations() {
         return this.activations.get();
     }
 
     @Override
     public int getDeactivations() {
         return this.deactivations.get();
     }
 
     @Override
     public int getActivationErrors() {
         return this.activationErrors.get();
     }
 
     @Override
     public int getCommitedTransactions() {
         return this.commitedTransactions.get();
     }
 
     @Override
     public int getRollbackedTransactions() {
         return this.rollbackedTransactions.get();
     }
 
     @Override
     public long getSizeOfActivatedContent() {
         return this.sizeOfActivatedContent.get();
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public Collection<ActivationLogEntry> getActivationLog() {
         return this.activationLog;
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public Collection<ActivationLogEntry> getActivationsMadeByUser(String user) {
         return this.activationsMadeByUser.get(user);
     }
 
     @Override
     public Map<String, Integer> getActivationsPerWorkspace() {
         return this.activationsPerWorkspace;
     }
 
     @Override
     public void setSubscriberResponseTime(String subscriber, long time) {
         if (!this.subscriberResponseTimes.containsKey(subscriber)) {
             final ResponseTimeEntry newSubscriber = new ResponseTimeEntry();
             newSubscriber.setMax(time);
             newSubscriber.setMin(time);
             newSubscriber.setAvg(time);
             subscriberResponseTimes.put(subscriber, newSubscriber);
         } else {
             final ResponseTimeEntry current = this.subscriberResponseTimes.get(subscriber);
             current.setAvg((current.getAvg() + time) / 2);
             if (current.getMax() < time) {
                 current.setMax(time);
             }
             if (current.getMin() > time) {
                 current.setMin(time);
             }
         }
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public void logError(String path, String user, String workspaceName, String subscriber, Throwable t, boolean deactivation) {
         this.activationErrors.incrementAndGet();
 
         ActivationLogEntry entry = new ActivationLogEntry(deactivation, false, path, subscriber, user, workspaceName, getCurrentDate(), t);
         this.activationErrorLog.add(entry);
     }
 
     @Override
     public Map<String, ResponseTimeEntry> getSubscriberResponseTimes() {
         return this.subscriberResponseTimes;
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public Collection<ActivationLogEntry> getActivationErrorLog() {
         return this.activationErrorLog;
     }
 
     @Override
     public void addSizeOfActivatedContent(long size) {
         this.sizeOfActivatedContent.addAndGet(size);
     }
 
     @Override
     public void addActivationTime(long time) {
         this.activationTime.addAndGet(time);
     }
 
     @Override
     public long getActivationTime() {
         return this.activationTime.get();
     }
 
     @Override
     public Date getLastRestartDate() {
         return this.lastRestart;
     }
 
     @Override
     public void addCommitedTransaction() {
         this.commitedTransactions.incrementAndGet();
     }
 
     @Override
     public void addRollbackedTransaction() {
         this.rollbackedTransactions.incrementAndGet();
     }
 
 }