package org.apache.jcs.auxiliary.lateral;
   
   /*
    * 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.
   */
  
  import java.io.IOException;
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.jcs.auxiliary.AbstractAuxiliaryCache;
  import org.apache.jcs.auxiliary.AuxiliaryCache;
  import org.apache.jcs.auxiliary.AuxiliaryCacheAttributes;
  import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheAttributes;
  import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheListener;
  import org.apache.jcs.engine.CacheStatus;
  import org.apache.jcs.engine.behavior.ICacheElement;
  import org.apache.jcs.engine.stats.StatElement;
  import org.apache.jcs.engine.stats.Stats;
  import org.apache.jcs.engine.stats.behavior.IStatElement;
  import org.apache.jcs.engine.stats.behavior.IStats;
  
  /**
   * Used to provide access to multiple services under nowait protection. Composite factory should
   * construct LateralCacheNoWaitFacade to give to the composite cache out of caches it constructs
   * from the varies manager to lateral services. Perhaps the lateralcache factory should be able to
   * do this.
   */
  public class LateralCacheNoWaitFacade<K extends Serializable, V extends Serializable>
      extends AbstractAuxiliaryCache<K, V>
  {
      /** Don't change */
      private static final long serialVersionUID = -9047687810358008955L;
  
      /** The logger */
      private final static Log log = LogFactory.getLog( LateralCacheNoWaitFacade.class );
  
      /** The queuing facade to the client. */
      public LateralCacheNoWait<K, V>[] noWaits;
  
      /** The region name */
      private final String cacheName;
  
      /** A cache listener */
      private ILateralCacheListener<K, V> listener;
  
      /** User configurable attributes. */
      private final ILateralCacheAttributes lateralCacheAttributes;
  
      /** Disposed state of this facade */
      private boolean disposed = false;
  
      /**
       * Constructs with the given lateral cache, and fires events to any listeners.
       * <p>
       * @param noWaits
       * @param cattr
       */
      public LateralCacheNoWaitFacade(ILateralCacheListener<K, V> listener, LateralCacheNoWait<K, V>[] noWaits, ILateralCacheAttributes cattr )
      {
          if ( log.isDebugEnabled() )
          {
              log.debug( "CONSTRUCTING NO WAIT FACADE" );
          }
          this.listener = listener;
          this.noWaits = noWaits;
          this.cacheName = cattr.getCacheName();
          this.lateralCacheAttributes = cattr;
      }
  
      /**
       * Tells you if the no wait is in the list or not.
       * <p>
       * @param noWait
       * @return true if the noWait is in the list.
       */
     public boolean containsNoWait( LateralCacheNoWait<K, V> noWait )
     {
         for ( int i = 0; i < noWaits.length; i++ )
         {
             // we know noWait isn't null
             if ( noWait.equals( noWaits[i] ) )
             {
                 return true;
             }
         }
         return false;
     }
 
     /**
      * Adds a no wait to the list if it isn't already in the list.
      * <p>
      * @param noWait
      * @return true if it wasn't already contained
      */
     public synchronized boolean addNoWait( LateralCacheNoWait<K, V> noWait )
     {
         if ( noWait == null )
         {
             return false;
         }
 
         if ( containsNoWait( noWait ) )
         {
             if ( log.isDebugEnabled() )
             {
                 log.debug( "No Wait already contained, [" + noWait + "]" );
             }
             return false;
         }
 
         @SuppressWarnings("unchecked") // No generic arrays in java
         LateralCacheNoWait<K, V>[] newArray = new LateralCacheNoWait[noWaits.length + 1];
 
         System.arraycopy( noWaits, 0, newArray, 0, noWaits.length );
 
         // set the last position to the new noWait
         newArray[noWaits.length] = noWait;
 
         noWaits = newArray;
 
         return true;
     }
 
     /**
      * Removes a no wait from the list if it is already there.
      * <p>
      * @param noWait
      * @return true if it was already in the array
      */
     public synchronized boolean removeNoWait( LateralCacheNoWait<K, V> noWait )
     {
         if ( noWait == null )
         {
             return false;
         }
 
         int position = -1;
         for ( int i = 0; i < noWaits.length; i++ )
         {
             // we know noWait isn't null
             if ( noWait.equals( noWaits[i] ) )
             {
                 position = i;
                 break;
             }
         }
 
         if ( position == -1 )
         {
             return false;
         }
 
         @SuppressWarnings("unchecked") // No generic arrays in java
         LateralCacheNoWait<K, V>[] newArray = new LateralCacheNoWait[noWaits.length - 1];
 
         System.arraycopy( noWaits, 0, newArray, 0, position );
         if ( noWaits.length != position )
         {
             System.arraycopy( noWaits, position + 1, newArray, position, noWaits.length - position - 1 );
         }
         noWaits = newArray;
 
         return true;
     }
 
     /**
      * @param ce
      * @throws IOException
      */
     public void update( ICacheElement<K, V> ce )
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "updating through lateral cache facade, noWaits.length = " + noWaits.length );
         }
         try
         {
             for ( int i = 0; i < noWaits.length; i++ )
             {
                 noWaits[i].update( ce );
             }
         }
         catch ( Exception ex )
         {
             log.error( ex );
         }
     }
 
     /**
      * Synchronously reads from the lateral cache.
      * <p>
      * @param key
      * @return ICacheElement
      */
     public ICacheElement<K, V> get( K key )
     {
         for ( int i = 0; i < noWaits.length; i++ )
         {
             try
             {
                 ICacheElement<K, V> obj = noWaits[i].get( key );
 
                 if ( obj != null )
                 {
                     // TODO: return after first success
                     // could do this simultaneously
                     // serious blocking risk here
                     return obj;
                 }
             }
             catch ( Exception ex )
             {
                 log.error( "Failed to get", ex );
             }
         }
         return null;
     }
 
     /**
      * Gets multiple items from the cache based on the given set of keys.
      * <p>
      * @param keys
      * @return a map of K key to ICacheElement<K, V> element, or an empty map if there is no
      *         data in cache for any of these keys
      */
     public Map<K, ICacheElement<K, V>> getMultiple(Set<K> keys)
     {
         Map<K, ICacheElement<K, V>> elements = new HashMap<K, ICacheElement<K, V>>();
 
         if ( keys != null && !keys.isEmpty() )
         {
             for (K key : keys)
             {
                 ICacheElement<K, V> element = get( key );
 
                 if ( element != null )
                 {
                     elements.put( key, element );
                 }
             }
         }
 
         return elements;
     }
 
     /**
      * Synchronously reads from the lateral cache. Get a response from each! This will be slow.
      * Merge them.
      * <p>
      * @param pattern
      * @return ICacheElement
      */
     public Map<K, ICacheElement<K, V>> getMatching(String pattern)
     {
         Map<K, ICacheElement<K, V>> elements = new HashMap<K, ICacheElement<K, V>>();
         for ( int i = 0; i < noWaits.length; i++ )
         {
             try
             {
                 elements.putAll( noWaits[i].getMatching( pattern ) );
             }
             catch ( Exception ex )
             {
                 log.error( "Failed to get", ex );
             }
         }
         return elements;
     }
 
     /**
      * Gets the set of keys of objects currently in the group.
      * <p>
      * @param group
      * @return a Set of group keys.
      */
     public Set<K> getGroupKeys( String group )
     {
         HashSet<K> allKeys = new HashSet<K>();
         for ( int i = 0; i < noWaits.length; i++ )
         {
             AuxiliaryCache<K, V> aux = noWaits[i];
             if ( aux != null )
             {
                 try
                 {
                     Set<K> groupKeys = aux.getGroupKeys( group );
                     if(groupKeys != null)
                     {
                     	allKeys.addAll( groupKeys );
                     }
                 }
                 catch ( IOException e )
                 {
                     // ignore
                 }
             }
         }
         return allKeys;
     }
 
     /**
      * Gets the set of group names in the cache
      * <p>
      * @return a Set of group names.
      */
     public Set<String> getGroupNames()
     {
         HashSet<String> allKeys = new HashSet<String>();
         for ( int i = 0; i < noWaits.length; i++ )
         {
             AuxiliaryCache<K, V> aux = noWaits[i];
             if ( aux != null )
             {
                 try
                 {
                     Set<String> groupNames = aux.getGroupNames();
                     if(groupNames != null)
                     {
                     	allKeys.addAll( groupNames );
                     }
                 }
                 catch ( IOException e )
                 {
                     // ignore
                 }
             }
         }
         return allKeys;
     }
 
     /**
      * Adds a remove request to the lateral cache.
      * <p>
      * @param key
      * @return always false.
      */
     public boolean remove( K key )
     {
         try
         {
             for ( int i = 0; i < noWaits.length; i++ )
             {
                 noWaits[i].remove( key );
             }
         }
         catch ( Exception ex )
         {
             log.error( ex );
         }
         return false;
     }
 
     /**
      * Adds a removeAll request to the lateral cache.
      */
     public void removeAll()
     {
         try
         {
             for ( int i = 0; i < noWaits.length; i++ )
             {
                 noWaits[i].removeAll();
             }
         }
         catch ( Exception ex )
         {
             log.error( ex );
         }
     }
 
     /** Adds a dispose request to the lateral cache. */
     public void dispose()
     {
         try
         {
             if ( listener != null )
             {
                 listener.dispose();
                 listener = null;
             }
 
             for ( int i = 0; i < noWaits.length; i++ )
             {
                 noWaits[i].dispose();
             }
         }
         catch ( Exception ex )
         {
             log.error( ex );
         }
         finally
         {
             disposed = true;
         }
     }
 
     /**
      * No lateral invocation.
      * @return The size value
      */
     public int getSize()
     {
         return 0;
         //cache.getSize();
     }
 
     /**
      * Gets the cacheType attribute of the LateralCacheNoWaitFacade object.
      * <p>
      * @return The cacheType value
      */
     public CacheType getCacheType()
     {
         return CacheType.LATERAL_CACHE;
     }
 
     /**
      * Gets the cacheName attribute of the LateralCacheNoWaitFacade object.
      * <p>
      * @return The cacheName value
      */
     public String getCacheName()
     {
         return "";
         //cache.getCacheName();
     }
 
     /**
      * Gets the status attribute of the LateralCacheNoWaitFacade object
      * @return The status value
      */
     public CacheStatus getStatus()
     {
         if (disposed)
         {
             return CacheStatus.DISPOSED;
         }
 
         if ((noWaits.length == 0) || (listener != null))
         {
             return CacheStatus.ALIVE;
         }
 
         CacheStatus[] statii = new CacheStatus[noWaits.length];
         for (int i = 0; i < noWaits.length; i++)
         {
             statii[i] = noWaits[i].getStatus();
         }
         // It's alive if ANY of its nowaits is alive
         for (int i = 0; i < noWaits.length; i++)
         {
             if (statii[i] == CacheStatus.ALIVE)
             {
                 return CacheStatus.ALIVE;
             }
         }
         // It's alive if ANY of its nowaits is in error, but
         // none are alive, then it's in error
         for (int i = 0; i < noWaits.length; i++)
         {
             if (statii[i] == CacheStatus.ERROR)
             {
                 return CacheStatus.ERROR;
             }
         }
 
         // Otherwise, it's been disposed, since it's the only status left
         return CacheStatus.DISPOSED;
     }
 
     /**
      * @return Returns the AuxiliaryCacheAttributes.
      */
     public AuxiliaryCacheAttributes getAuxiliaryCacheAttributes()
     {
         return this.lateralCacheAttributes;
     }
 
     /**
      * @return "LateralCacheNoWaitFacade: " + cacheName;
      */
     @Override
     public String toString()
     {
         return "LateralCacheNoWaitFacade: " + cacheName;
     }
 
     /**
      * this won't be called since we don't do ICache logging here.
      * <p>
      * @return String
      */
     @Override
     public String getEventLoggingExtraInfo()
     {
         return "Lateral Cache No Wait";
     }
 
     /**
      * getStats
      * @return String
      */
     public String getStats()
     {
         return getStatistics().toString();
     }
 
     /**
      * @return IStats
      */
     public IStats getStatistics()
     {
         IStats stats = new Stats();
         stats.setTypeName( "Lateral Cache No Wait Facade" );
 
         ArrayList<IStatElement> elems = new ArrayList<IStatElement>();
 
         IStatElement se = null;
 
         if ( noWaits != null )
         {
             se = new StatElement();
             se.setName( "Number of No Waits" );
             se.setData( "" + noWaits.length );
             elems.add( se );
 
             for ( int i = 0; i < noWaits.length; i++ )
             {
                 if ( noWaits[i] != null )
                 {
                     // get the stats from the super too
                     // get as array, convert to list, add list to our outer list
                     IStats sStats = noWaits[i].getStatistics();
                     IStatElement[] sSEs = sStats.getStatElements();
                     List<IStatElement> sL = Arrays.asList( sSEs );
                     elems.addAll( sL );
                 }
             }
 
         }
 
         // get an array and put them in the Stats object
         IStatElement[] ses = elems.toArray( new StatElement[0] );
         stats.setStatElements( ses );
 
         return stats;
     }
 }