/*
    * 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.commons.performance.pool;
  
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Iterator;
  import java.util.logging.Logger;
  import java.util.logging.Level;
  import java.util.concurrent.atomic.AtomicInteger;
  
  import org.apache.commons.pool.PoolableObjectFactory;
  import org.apache.commons.pool.KeyedPoolableObjectFactory;
  
  /**
   * Object factory with configurable latencies for object lifecycle methods.
   *
   */
  public class WaiterFactory implements PoolableObjectFactory,
  KeyedPoolableObjectFactory {
      
      // TODO: implement protected getters so these can be stochastic
      private long activateLatency = 0;
      private long destroyLatency = 0;
      private long makeLatency = 0;
      private long passivateLatency = 0;
      private long validateLatency = 0;
      private long waiterLatency = 0;
      
      /** Count of (makes - destroys) since last reset */
      private long activeCount = 0;
      
      /** Count of (makes - destroys) per key since last reset */
      private Map<Object, AtomicInteger> activeCounts = 
          new HashMap<Object, AtomicInteger>();
      
      /** Maximum of (makes - destroys) - if exceeded IllegalStateException */
      private long maxActive = Long.MAX_VALUE;
      
      /** Maximum of (makes - destroys) per key */
      private long maxActivePerKey = Long.MAX_VALUE;
      
      protected static final Logger logger = 
          Logger.getLogger(WaiterFactory.class.getName());
  
      public WaiterFactory(long activateLatency, long destroyLatency,
              long makeLatency, long passivateLatency, long validateLatency,
              long waiterLatency,long maxActive, long maxActivePerKey) {
          this.activateLatency = activateLatency;
          this.destroyLatency = destroyLatency;
          this.makeLatency = makeLatency;
          this.passivateLatency = passivateLatency;
          this.validateLatency = validateLatency;
          this.waiterLatency = waiterLatency;
          this.maxActive = maxActive;
          this.maxActivePerKey = maxActivePerKey;
      }
      
      public WaiterFactory(long activateLatency, long destroyLatency,
              long makeLatency, long passivateLatency, long validateLatency,
              long waiterLatency) {
          this(activateLatency, destroyLatency, makeLatency, passivateLatency,
                  validateLatency, waiterLatency, Long.MAX_VALUE, Long.MAX_VALUE);
      }
      
      public WaiterFactory(long activateLatency, long destroyLatency,
              long makeLatency, long passivateLatency, long validateLatency,
              long waiterLatency,long maxActive) {
          this(activateLatency, destroyLatency, makeLatency, passivateLatency,
                  validateLatency, waiterLatency, maxActive, Long.MAX_VALUE);
      }
  
      public void activateObject(Object arg0) throws Exception {
          if (logger.isLoggable(Level.FINEST)) {
              logger.finest("activate");
          }
          doWait(activateLatency);
      }
  
      public void destroyObject(Object arg0) throws Exception {
          if (logger.isLoggable(Level.FINE)) {
              logger.fine("destroy");
          }
          doWait(destroyLatency);
         ((Waiter) arg0).setValid(false);
         // Decrement *after* destroy 
         synchronized (this) {
             activeCount--;
         }
     }
 
     public Object makeObject() throws Exception {
         // Increment and test *before* make
         synchronized (this) {
             if (activeCount >= maxActive) {
                 throw new IllegalStateException("Too many active instances: " +
                 activeCount + " in circulation with maxActive = " + maxActive);
             } else {
                 activeCount++;
             }
         }
         if (logger.isLoggable(Level.FINE)) {
             logger.fine("makeObject");
         }
         doWait(makeLatency);
         return new Waiter(false, true, waiterLatency);
     }
 
     public void passivateObject(Object arg0) throws Exception {
         if (logger.isLoggable(Level.FINEST)) {
             logger.finest("passivate");
         }
         ((Waiter) arg0).setActive(false);
         doWait(passivateLatency);
     }
 
     public boolean validateObject(Object arg0) {
         if (logger.isLoggable(Level.FINE)) {
             logger.fine("validate");
         }
         doWait(validateLatency);
         return ((Waiter) arg0).isValid();
     }
     
     protected void doWait(long latency) {
         try {
             Thread.sleep(latency);
         } catch (InterruptedException ex) {
             // ignore
         }
     }
     
     public synchronized void reset() {
         activeCount = 0;
         if (activeCounts.isEmpty()) {
             return;
         }
         Iterator it = activeCounts.keySet().iterator();
         while (it.hasNext()) {
             ((AtomicInteger) activeCounts.get(it.next())).getAndSet(0);
         }
     }
 
     /**
      * @return the maxActive
      */
     public synchronized long getMaxActive() {
         return maxActive;
     }
 
     /**
      * @param maxActive the maxActive to set
      */
     public synchronized void setMaxActive(long maxActive) {
         this.maxActive = maxActive;
     }
 
     // KeyedPoolableObjectFactory methods
     
     public void activateObject(Object key, Object obj) throws Exception {
         activateObject(obj);
     }
 
     public void destroyObject(Object key, Object obj) throws Exception {
         destroyObject(obj);
         ((AtomicInteger) activeCounts.get(key)).getAndDecrement(); 
     }
 
     public Object makeObject(Object key) throws Exception {
         synchronized (this) {
             AtomicInteger count = (AtomicInteger) activeCounts.get(key);
             if (count == null) {
                 count = new AtomicInteger(1);
                 activeCounts.put(key, count);
             } else {
                 if (count.get() >= maxActivePerKey) {
                     throw new IllegalStateException("Too many active " +
                     "instances for key = " + key + ": " + count.get() + 
                     " in circulation " + "with maxActivePerKey = " + 
                     maxActivePerKey);
                 } else {
                     count.incrementAndGet();
                 }
             }
         }
         return makeObject();
     }
 
     public void passivateObject(Object key, Object obj) throws Exception {
         passivateObject(obj);
     }
 
     public boolean validateObject(Object key, Object obj) {
         return validateObject(obj);
     }
 
 }