/**
    *    Copyright 2009-2018 the original author or authors.
    *
    *    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.ibatis.reflection.wrapper;
  
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.ibatis.reflection.MetaObject;
  import org.apache.ibatis.reflection.SystemMetaObject;
  import org.apache.ibatis.reflection.factory.ObjectFactory;
  import org.apache.ibatis.reflection.property.PropertyTokenizer;
  
  /**
   * @author Clinton Begin
   */
  public class MapWrapper extends BaseWrapper {
  
    private final Map<String, Object> map;
  
    public MapWrapper(MetaObject metaObject, Map<String, Object> map) {
      super(metaObject);
      this.map = map;
    }
  
    @Override
    public Object get(PropertyTokenizer prop) {
      if (prop.getIndex() != null) {
        Object collection = resolveCollection(prop, map);
        return getCollectionValue(prop, collection);
      } else {
        return map.get(prop.getName());
      }
    }
  
    @Override
    public void set(PropertyTokenizer prop, Object value) {
      if (prop.getIndex() != null) {
        Object collection = resolveCollection(prop, map);
        setCollectionValue(prop, collection, value);
      } else {
        map.put(prop.getName(), value);
      }
    }
  
    @Override
    public String findProperty(String name, boolean useCamelCaseMapping) {
      return name;
    }
  
    @Override
    public String[] getGetterNames() {
      return map.keySet().toArray(new String[map.keySet().size()]);
    }
  
    @Override
    public String[] getSetterNames() {
      return map.keySet().toArray(new String[map.keySet().size()]);
    }
  
    @Override
    public Class<?> getSetterType(String name) {
      PropertyTokenizerrty/PropertyTokenizer.html#PropertyTokenizer">PropertyTokenizer prop = new PropertyTokenizer(name);
      if (prop.hasNext()) {
        MetaObject metaValue = metaObject.metaObjectForProperty(prop.getIndexedName());
        if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
          return Object.class;
        } else {
          return metaValue.getSetterType(prop.getChildren());
        }
      } else {
        if (map.get(name) != null) {
          return map.get(name).getClass();
        } else {
          return Object.class;
        }
      }
    }
  
    @Override
    public Class<?> getGetterType(String name) {
      PropertyTokenizerrty/PropertyTokenizer.html#PropertyTokenizer">PropertyTokenizer prop = new PropertyTokenizer(name);
      if (prop.hasNext()) {
        MetaObject metaValue = metaObject.metaObjectForProperty(prop.getIndexedName());
        if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
          return Object.class;
       } else {
         return metaValue.getGetterType(prop.getChildren());
       }
     } else {
       if (map.get(name) != null) {
         return map.get(name).getClass();
       } else {
         return Object.class;
       }
     }
   }
 
   @Override
   public boolean hasSetter(String name) {
     return true;
   }
 
   @Override
   public boolean hasGetter(String name) {
     PropertyTokenizerrty/PropertyTokenizer.html#PropertyTokenizer">PropertyTokenizer prop = new PropertyTokenizer(name);
     if (prop.hasNext()) {
       if (map.containsKey(prop.getIndexedName())) {
         MetaObject metaValue = metaObject.metaObjectForProperty(prop.getIndexedName());
         if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
           return true;
         } else {
           return metaValue.hasGetter(prop.getChildren());
         }
       } else {
         return false;
       }
     } else {
       return map.containsKey(prop.getName());
     }
   }
 
   @Override
   public MetaObject instantiatePropertyValue(String name, PropertyTokenizer prop, ObjectFactory objectFactory) {
     HashMap<String, Object> map = new HashMap<>();
     set(prop, map);
     return MetaObject.forObject(map, metaObject.getObjectFactory(), metaObject.getObjectWrapperFactory(), metaObject.getReflectorFactory());
   }
 
   @Override
   public boolean isCollection() {
     return false;
   }
 
   @Override
   public void add(Object element) {
     throw new UnsupportedOperationException();
   }
 
   @Override
   public <E> void addAll(List<E> element) {
     throw new UnsupportedOperationException();
   }
 
 }