/*
    * Copyright 2002-2004 The Apache Software Foundation
    *
    * Licensed 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.clazz.reflect.extended;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.util.AbstractMap;
  import java.util.AbstractSet;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.Map;
  import java.util.Set;
  
  import org.apache.commons.clazz.ClazzAccessException;
  
  
  /**
   * This is an implementation of the <code>Map</code> interface
   * that is based on a Mapped property.  Whenever possible, it
   * uses concrete methods on the owner of the property to manipulate the map.
   * <p>
   * Consider the following example:
   * <pre>
   *      Map map = (Map)clazz.getProperty("fooMap").get(instance);
   *      Object value = map.get("bar");
   * </pre>
   * 
   * If <code>instance</code> has a <code>getFoo(String key)</code> method,
   * this code will implicitly invoke it like this: <code>getFoo("bar")</code>.
   * otherwise it will obtain the whole map and extract the 
   * requested value.
   * 
   * @author <a href="mailto:dmitri@apache.org">Dmitri Plotnikov</a>
   * @version $Id: ReflectedMap.java 155436 2005-02-26 13:17:48Z dirkv $
   */
  public class ReflectedMap extends AbstractMap {
      private Object instance;
      private ReflectedMappedProperty property;
      private int modCount = 0;
      
      /**
       * Constructor for ReflectedMap.
       */
      public ReflectedMap(
              Object instance,
              ReflectedMappedProperty property) 
      {
          this.instance = instance;
          this.property = property;
      }
      
      public Map getPropertyValue() {
          Method readMethod = property.getReadMethod();
          if (readMethod == null) {
              throw new ClazzAccessException(
                  "Cannot read property "
                      + property.getName()
                      + ": no read method");
          }
          try {
              return (Map) readMethod.invoke(instance, null);
          }
          catch (Exception ex) {
              throw accessException("Cannot read property", readMethod, ex);
          }
      }
  
      public void setPropertyValue(Map value) {
          Method writeMethod = property.getWriteMethod();
          if (writeMethod == null) {
              throw new ClazzAccessException(
                  "Cannot set property: "
                      + property.getName()
                      + ": no set(array) method");
          }
  
          try {
              writeMethod.invoke(instance, new Object[] { value });
          }
          catch (Exception ex) {
              throw accessException("Cannot set property", writeMethod, ex);
         }
     }
 
     public Set getPropertyKeySet() {
         Method keySetMethod = property.getKeySetMethod();
         if (keySetMethod != null) {
             Set set;
             try {
                 Object value = keySetMethod.invoke(instance, null);
                 if (value == null) {
                     set = Collections.EMPTY_SET;
                 }
                 else if (value instanceof Set) {
                     set = (Set) value;
                 }
                 else if (value instanceof Collection) {
                     set = new ConcurrentChangeSafeSet((Collection) value);
                 }
                 else {
                     set =
                         new ConcurrentChangeSafeSet(
                             Arrays.asList((Object[]) value));
                 }
             }
             catch (Exception ex) {
                 throw new ClazzAccessException(
                     "Cannot get key set: "
                         + property.getName()
                         + ": cannot invoke method: "
                         + keySetMethod.getName(),
                     ex);
             }
             return set;
         }
         else {
             Map map = getPropertyValue();
             if (map == null) {
                 return Collections.EMPTY_SET;
             }
             return map.keySet();
         }
     }
 
     /**
      * If there is a getFoo(key) method, calls that for every key.
      * Otherwise, calls getFooMap().get(key)
      * 
      * @see java.util.Map#get(java.lang.Object)
      */
     public Object get(Object key) {
         Method getMethod = property.getGetMethod();
         if (getMethod != null) {
             Object value;
             try {
                 value = getMethod.invoke(instance, new Object[]{key});
             }
             catch (Exception ex) {
                 throw new ClazzAccessException(
                     "Cannot get property : "
                         + property.getName()
                         + ": cannot invoke method: "
                         + getMethod.getName(),
                     ex);
             }
             return value;
         }
         else {
             Map map = getPropertyValue();
             if (map == null) {
                 return null;
             }
             return map.get(key);
         }
     }
 
     /**
      * @see java.util.Map#size()
      */
     public int size() {
         Method keySetMethod = property.getKeySetMethod();
         if (keySetMethod != null) {
             try {
                 Object value = keySetMethod.invoke(instance, null);
                 if (value == null) {
                     return 0;
                 }
                 else if (value instanceof Collection) {
                     return ((Collection) value).size();
                 }
                 else {
                     return Array.getLength(value);
                 }
             }
             catch (Exception ex) {
                 throw accessException("Cannot get key set", keySetMethod, ex);
             }
         }
         else {
             Map map = getPropertyValue();
             if (map == null) {
                 return 0;
             }
             return map.size();
         }
     }
 
     /**
      * @see java.util.Map#isEmpty()
      */
     public boolean isEmpty() {
         return size() == 0;
     }
 
     /**
      * @see java.util.Map#keySet()
      */
     public Set keySet() {
         return new EntrySet(KEYS);
     }
     
     /**
      * @see java.util.Map#entrySet()
      */
     public Set entrySet() {
         return new EntrySet(ENTRIES);
     }
     
     /**
      * @see java.util.Map#put(java.lang.Object, java.lang.Object)
      */
     public Object put(Object key, Object value) {        
         Method putMethod = property.getPutMethod();
         if (putMethod != null) {
             Object oldValue = null;
             try {
                 oldValue = get(key);
             }
             catch (Throwable t) {
                 // Ignore
             }
             
             try {
                 putMethod.invoke(instance, new Object[]{key, value});
             }
             catch (Exception ex) {
                 throw new ClazzAccessException(
                     "Cannot set property : "
                         + property.getName()
                         + ": cannot invoke method: "
                         + putMethod.getName(),
                     ex);
             }
             return oldValue;
         }
         else {
             Map map = getPropertyValue();
             if (map == null) {
                 map = new HashMap();
                 setPropertyValue(map);
             }
             return map.put(key, value);
         }
     }
 
     /**
      * @see java.util.Map#remove(java.lang.Object)
      */
     public Object remove(Object key) {
         Method removeMethod = property.getRemoveMethod();
         if (removeMethod != null) {
             Object oldValue = null;
             try {
                 oldValue = get(key);
             }
             catch (Throwable t) {
                 // Ignore
             }
 
             try {
                 removeMethod.invoke(instance, new Object[]{key});
             }
             catch (Exception ex) {
                 throw new ClazzAccessException(
                     "Cannot set property : "
                         + property.getName()
                         + ": cannot invoke method: "
                         + removeMethod.getName(),
                     ex);
             }
             return oldValue;
         }
         else {
             Map map = getPropertyValue();
             if (map != null) {
                 return map.remove(key);
             }
             return null;
         }
     }
     
     private RuntimeException accessException(
         String message,
         Method method,
         Throwable ex)
     {
         if (ex instanceof InvocationTargetException) {
             ex = ((InvocationTargetException) ex).getTargetException();
         }
 
         // Just re-throw all runtime exceptions - there is really no
         // point in wrapping them
         if (ex instanceof RuntimeException) {
             throw (RuntimeException) ex;
         }
         if (ex instanceof Error) {
             throw (Error) ex;
         }
 
         throw new ClazzAccessException(
             message
                 + ": "
                 + property.getName()
                 + ": cannot invoke method: "
                 + method.getName(),
             ex);
     }
 
     private static final int ENTRIES = 0;
     private static final int KEYS = 1;
     
     /**
      * An implementation of Set that delegates object deletion to the
      * encompassing ReflectedMap.
      */
     private class EntrySet extends AbstractSet {
         private int type;
         private int modCount = -1;
         private Set keySet;
         private int size;        
 
         public EntrySet(int type) {
             this.type = type;
             update();            
         }
 
         public void refresh() {
             // If EntrySet is out of sync with the 
             // parent ReflectedMap, update the cached key set and size
             if (modCount != ReflectedMap.this.modCount) {
                 update();
             }
         }
 
         public void update() {
             // Make sure modCount of EntrySet is maintained in sync with
             // that of the embracing List
             modCount = ReflectedMap.this.modCount;
             
             keySet = ReflectedMap.this.getPropertyKeySet();
             size = keySet.size();
         }
         
         public int size() {
             refresh();
             return size;
         }
         
         public Iterator iterator() {
             refresh();
             return new EntryIterator(keySet, type);
         }
         
         public boolean remove(Object object) {
             refresh();
             Object key =
                 (type == KEYS ? object : ((Map.Entry) object).getKey());
                 
             boolean exists = true;
             try {
                 exists = keySet.contains(key);
             }
             catch (Throwable t) {
                 // Ignore
             }
             if (exists) {
                 ReflectedMap.this.remove(key);
             }
             return exists;
         }
     }
     
     /**
      * An implementation of Iterator that delegates object deletion to the
      * encompassing ReflectedMap.
      */
     private class EntryIterator implements Iterator {
         private int type;
         private Set keySet;
         private Iterator keyIterator;
         private Object lastReturned = UNINITIALIZED;
         
         public EntryIterator(Set keySet, int type) {
             this.type = type;
             this.keySet = keySet;
             this.keyIterator = keySet.iterator();
         }
         
         /**
          * @see java.util.Iterator#hasNext()
          */
         public boolean hasNext() {
             return keyIterator.hasNext();
         }
 
         /**
          * @see java.util.Iterator#next()
          */
         public Object next() {            
             lastReturned = keyIterator.next();
             if (type == KEYS) {
                 return lastReturned;
             }
             else {
                 return new Entry(lastReturned);
             }
         }
 
         /**
          * @see java.util.Iterator#remove()
          */
         public void remove() {
             if (lastReturned == UNINITIALIZED) {
                 throw new IllegalStateException();
             }
             ensureConcurrentChangeSafety();
             ReflectedMap.this.remove(lastReturned);
         }
 
         /**
          * This is called when we are about to delete a key from the map.
          * The method checks if the set of keys we are iterating over is in fact
          * a copy of the set of keys of the original collection.  If it is not,
          * the method creates such copy and re-executes the iteration steps that
          * have already been made.  The assumption made here is that as long as
          * set remains unchanged, an iteration will always present elements in
          * the same order (which is not to say that the order is predicatble).
          */
         private void ensureConcurrentChangeSafety() {
             if (!(keySet instanceof ConcurrentChangeSafeSet)) {
                 keySet = new ConcurrentChangeSafeSet(keySet);
                 keyIterator = keySet.iterator(); 
                 while (keyIterator.hasNext()) {
                     Object key = keyIterator.next();
                     if ((key == null && lastReturned == null)
                         || (key != null && key.equals(lastReturned))) {
                         return;
                     }
                 }
                 throw new IllegalStateException(
                     "The second iteration over the key set"
                         + " did not produce the same elements");
             }
         }
     }
     
     private static final Object UNINITIALIZED = new Object();
     
     /**
      * An implementation of Map.Entry that maintains a key and gets the value
      * from the property, if needed.
      */
     private class Entry implements Map.Entry {
         private Object key;
         
         public Entry(Object key) {
             this.key = key;            
         }
         
         /**
          * @see java.util.Map.Entry#getKey()
          */
         public Object getKey() {
             return key;
         }
         /**
          * @see java.util.Map.Entry#getValue()
          */
         public Object getValue() {
             return ReflectedMap.this.get(key);
         }
         
         /**
          * @see java.util.Map.Entry#setValue(java.lang.Object)
          */
         public Object setValue(Object value) {
             return ReflectedMap.this.put(key, value);
         }        
 
         public boolean equals(Object o) {
             if (!(o instanceof Map.Entry)) {
                 return false;
             }
             
             Map.Entry e = (Map.Entry) o;
             return (key == null ? e.getKey() == null : key.equals(e.getKey()));
         }
 
         public int hashCode() {
             return key == null ? 0 : key.hashCode();
         }
 
         public String toString() {
             return key + "=" + getValue();
         }        
     }
     
     /**
      * This is a simple HashSet. We are only introducing the subclass as a
      * marker of the fact that we created the set rather than getting it
      * directly from the map value of the property.
      */
     private static class ConcurrentChangeSafeSet extends HashSet {
         public ConcurrentChangeSafeSet(Collection collection) {
             super(collection);
         }
     }
 }