package org.webslinger.lang;

 import java.util.Map;

 import java.lang.ref.Reference;

 import java.lang.ref.ReferenceQueue;

 import java.lang.ref.SoftReference;

 import java.lang.ref.WeakReference;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.HashSet;

 import java.util.Map;

 import java.util.Set;

 import java.util.SortedMap;

 import java.util.TreeMap;

 import java.util.concurrent.ConcurrentHashMap;

 import java.util.concurrent.ConcurrentMap;

 public abstract class AbstractCache<K, V> {

     private static Map<String, ValueType> overrideValueType = new HashMap<String, ValueType>();

     private static Map<String, StorageType> overrideStorageType = new HashMap<String, StorageType>();

     static {

         overrideValueType.put("org.webslinger.commons.vfs.cow.COWFileSystem, cowStatsPerFS", ValueType.SOFT);

         overrideValueType.put("org.webslinger.commons.vfs.cow.COWState, entries", ValueType.HARD);

         overrideValueType.put("org.webslinger.container.WebslingerContainer, fileInfoCache", ValueType.SOFT);

         overrideValueType.put("org.webslinger.container.WebslingerContainer, lookForFilterCache", ValueType.SOFT);

         overrideValueType.put("org.webslinger.container.WebslingerContainer, fullPathCache", ValueType.SOFT);

         overrideValueType.put("org.webslinger.WebslingerServletContext, filters", ValueType.SOFT);

         overrideValueType.put("org.webslinger.WebslingerServletContext, servletListenerCache", ValueType.SOFT);

         overrideValueType.put("org.webslinger.WebslingerServletContext, ChainCache", ValueType.SOFT);

         overrideValueType.put("org.webslinger.container.FileInfo, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.bsf.janino.JaninoCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.bsf.groovy.GroovyCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.template.velocity.VelocityCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.bsf.rhino.RhinoCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.bsf.beanshell.BeanShellCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.bsf.jython.JythonCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.quercus.bsf.QuercusCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.quercus.template.QuercusTemplateCompiler, cache", ValueType.HARD);

         overrideValueType.put("org.webslinger.ext.template.freemarker.FreemarkerCompiler, cache", ValueType.HARD);

     }

     protected abstract static class ValueDelegate<K, V> {

         protected abstract Object createHolder(K key, V value, StorageDelegate<K, V> storage);

         protected abstract V extractHolder(Object holder);

     }

     protected abstract static class RefDelegate<K, V> extends ValueDelegate<K, V> {

         protected V extractHolder(Object ref) {

             return ((Ref<K, V>) ref).get();

         }

     }

     public static final class SoftDelegate<K, V> extends RefDelegate<K, V> {

         protected Object createHolder(K key, V value, StorageDelegate<K, V> storage) {

             return new Soft<K, V>(key, value, storage);

         }

     }

     public static final class WeakDelegate<K, V> extends RefDelegate<K, V> {

         protected Object createHolder(K key, V value, StorageDelegate<K, V> storage) {

             return new Weak<K, V>(key, value, storage);

         }

     }

     public static final class HardDelegate<K, V> extends ValueDelegate<K, V> {

         protected V createHolder(K key, V value, StorageDelegate<K, V> storage) {

             return value;

         }

         protected V extractHolder(Object value) {

             return (V) value;

         }

     }

     public enum ValueType {

         SOFT {

             protected <K, V> ValueDelegate<K, V> createDelegate() {

                 return new WeakDelegate<K, V>();

             }

         },

         WEAK {

             protected <K, V> ValueDelegate<K, V> createDelegate() {

                 return new SoftDelegate<K, V>();

             }

         },

         HARD {

             protected <K, V> ValueDelegate<K, V> createDelegate() {

                 return new HardDelegate<K, V>();

             }

         };

         protected abstract <K, V> ValueDelegate<K, V> createDelegate();

     }

     protected interface StorageDelegate<K, V> {

         void clear();

         boolean isEmpty();

         Set<K> keySet();

         void remove(ValueDelegate<K, V> valueDelegate, K key, V value);

         void remove(K key, Object holder);

         void remove(K key);

         Iterable<Map.Entry<K, V>> tail(K key);

         V get(AbstractCache<K, V> ac, ValueDelegate<K, V> valueDelegate, Object id, K key, boolean create) throws Exception;

     }

     protected static final class ConcurrentDelegate<K, V, M extends ConcurrentMap<K, Object>> implements StorageDelegate<K, V> {

         protected M map;

         protected ConcurrentDelegate(M map) {

             this.map = map;

         }

         public void clear() {

             map.clear();

         }

         public boolean isEmpty() {

             return map.isEmpty();

         }

         public Set<K> keySet() {

             return map.keySet();

         }

         public void remove(K key) {

             map.remove(key);

         }

         public void remove(ValueDelegate<K, V> valueDelegate, K key, V value) {

             Object holder = map.get(key);

             if (holder == null) return;

             V oldValue = valueDelegate.extractHolder(holder);

             if (oldValue == null || ObjectUtil.equalsHelper(value, oldValue)) {

                 map.remove(key, holder);

             }

         }

         public void remove(K key, Object holder) {

             map.remove(key, holder);

         }

         public Iterable<Map.Entry<K, V>> tail(K key) {

             if (map instanceof SortedMap) return Collections.unmodifiableSortedMap((SortedMap<K, V>) map).entrySet();

             throw new UnsupportedOperationException();

         }

         public V get(AbstractCache<K, V> ac, ValueDelegate<K, V> valueDelegate, Object id, K key, boolean create) throws Exception {

             Object holder = map.get(key);

             while (true) {

                 if (holder != null) {

                     V result = valueDelegate.extractHolder(holder);

                     if (result != null) return result;

                     map.remove(key, holder);

                 }

                 V result;

                 if (create) {

                     result = ac.createValue(id, key);

                 } else {

                     result = ac.findIfExists(id, key);

                     if (result == null) return null;

                 }

                 holder = valueDelegate.createHolder(key, result, this);

                 if ((holder = map.putIfAbsent(key, holder)) == null) return result;

             }

         }

     }

     protected static final class StandardDelegate<K, V, M extends Map<K, Object>> implements StorageDelegate<K, V> {

         protected M map;

         protected StandardDelegate(M map) {

             this.map = map;

         }

         public synchronized void clear() {

             map.clear();

         }

         public synchronized boolean isEmpty() {

             return map.isEmpty();

         }

         public synchronized Set<K> keySet() {

             return map.keySet();

         }

         public synchronized void remove(K key) {

             map.remove(key);

         }

         public synchronized void remove(ValueDelegate<K, V> valueDelegate, K key, V value) {

             Object holder = map.get(key);

             if (holder == null) return;

             if (ObjectUtil.equalsHelper(value, valueDelegate.extractHolder(holder))) {

                 map.remove(key);

             }

         }

         public synchronized void remove(K key, Object holder) {

             if (ObjectUtil.equalsHelper(holder, map.get(key))) {

                 map.remove(key);

             }

         }

         public Iterable<Map.Entry<K, V>> tail(K key) {

             if (map instanceof SortedMap) return Collections.unmodifiableSortedMap((SortedMap<K, V>) map).entrySet();

             throw new UnsupportedOperationException();

         }

         public synchronized V get(AbstractCache<K, V> ac, ValueDelegate<K, V> valueDelegate, Object id, K key, boolean create) throws Exception {

             Object holder = map.get(key);

             if (holder != null) {

                 V result = valueDelegate.extractHolder(holder);

                 if (result != null) return result;

             }

             V result;

             if (create) {

                 result = ac.createValue(id, key);

             } else {

                 result = ac.findIfExists(id, key);

                 if (result == null) return null;

             }

             holder = valueDelegate.createHolder(key, result, this);

             map.put(key, holder);

             return result;

         }

     }

     public enum StorageType {

         CONCURRENT {

             protected <K, V> StorageDelegate<K, V> createDelegate(boolean sorted) {

                 if (!sorted) return new ConcurrentDelegate<K, V, ConcurrentHashMap<K, Object>>(new ConcurrentHashMap<K, Object>());

                 return new ConcurrentDelegate<K, V, ConcurrentMap<K, Object>>((ConcurrentMap<K, Object>) ConcurrentUtil.<K, Object>createSortedMap());

             }

         },

         STANDARD {

             protected <K, V> StorageDelegate<K, V> createDelegate(boolean sorted) {

                 if (!sorted) return new StandardDelegate<K, V, HashMap<K, Object>>(new HashMap<K, Object>());

                 return new StandardDelegate<K, V, TreeMap<K, Object>>(new TreeMap<K, Object>());

             }

         };

         protected abstract <K, V> StorageDelegate<K, V> createDelegate(boolean sorted);

     }

     private static final ReferenceQueue queue = new ReferenceQueue();

     private static final Thread CleanerThread = new Thread() {

         public void run() {

             while (true) {

                 try {

                     Ref<?, ?> ref = (Ref<?, ?>) queue.remove();

                     ref.purge();

                 } catch (InterruptedException e) {

                     break;

                 }

             }

         }

     };

     static {

         CleanerThread.setDaemon(true);

         CleanerThread.setName("AbstractCache.RefPoller");

         CleanerThread.start();

     }

     protected final Class<?> owner;

     protected final String field;

     protected final String label;

     protected final ValueDelegate<K, V> valueDelegate;

     protected final StorageDelegate<K, V> storageDelegate;

     private static <K, V> ValueDelegate<K, V> getDelegate(Class<?> owner, String field, String label, ValueType valueType) {

         String key = owner.getName() + ", " + field;

         if (valueType == null) {

             valueType = ValueType.SOFT;

         } else if (overrideValueType.containsKey(key)) {

             valueType = overrideValueType.get(key);

         }

         return valueType.createDelegate();

     }

     private static <K, V> StorageDelegate<K, V> getDelegate(Class<?> owner, String field, String label, boolean sorted, StorageType storageType) {

         String key = owner.getName() + ", " + field;

         if (storageType == null) {

             storageType = StorageType.STANDARD;

         } else if (overrideStorageType.containsKey(key)) {

             storageType = overrideStorageType.get(key);

         }

         return storageType.createDelegate(sorted);

     }

     protected AbstractCache(Class<?> owner, String field, String label, ValueType valueType, StorageType storageType, boolean sorted) {

         this.owner = owner;

         this.field = field;

         this.label = label;

         this.valueDelegate = getDelegate(owner, field, label, valueType);

         this.storageDelegate = getDelegate(owner, field, label, sorted, storageType);

     }

     protected AbstractCache(Class<?> owner, String field, String label, ValueType valueType) {

         this(owner, field, label, valueType, null, false);

     }

     protected AbstractCache(Class<?> owner, String field, String label, StorageType storageType, boolean sorted) {

         this(owner, field, label, null, storageType, sorted);

     }

     protected AbstractCache(Class<?> owner, String field, String label) {

         this(owner, field, label, null, null, false);

     }

     public void clear() {

         storageDelegate.clear();

     }

     public boolean isEmpty() {

         return storageDelegate.isEmpty();

     }

     public Set<K> keys() {

         return storageDelegate.keySet();

     }

     public void remove(K key) {

         storageDelegate.remove(key);

     }

     public Iterable<Map.Entry<K, V>> tail(K key) {

         return storageDelegate.tail(key);

     }

     protected void remove(K key, V value) {

         storageDelegate.remove(valueDelegate, key, value);

     }

     protected V get(Object id, K key) throws Exception {

         return get(id, key, true);

     }

     protected V get(Object id, K key, boolean create) throws Exception {

         return storageDelegate.get(this, valueDelegate, id, key, create);

     }

     protected V findIfExists(Object id, K key) throws Exception {

         return null;

     }

     protected abstract V createValue(Object id, K key) throws Exception;

     protected interface Ref<K, V> {

         V get();

         void purge();

     }

     protected static class Soft<K, V> extends SoftReference<V> implements Ref<K, V> {

         protected final K key;

         protected final StorageDelegate<K, V> storage;

         protected Soft(K key, V value, StorageDelegate<K, V> storage) {

             super(value, queue);

             this.key = key;

             this.storage = storage;

         }

         public void purge() {

             storage.remove(key, this);

         }

     }

     protected static class Weak<K, V> extends WeakReference<V> implements Ref<K, V> {

         protected final K key;

         protected final StorageDelegate<K, V> storage;

         protected Weak(K key, V value, StorageDelegate<K, V> storage) {

             super(value, queue);

             this.key = key;

             this.storage = storage;

         }

         public void purge() {

             storage.remove(key, this);

         }

     }

 }