/*
    * Copyright 2005,2009 Ivan SZKIBA
    *
    * 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.ini4j;
  
  import org.ini4j.spi.Warnings;
  
  import java.io.Serializable;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.LinkedHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  
  public class BasicMultiMap<K, V> implements MultiMap<K, V>, Serializable
  {
      private static final long serialVersionUID = 4716749660560043989L;
      private final Map<K, List<V>> _impl;
  
      public BasicMultiMap()
      {
          this(new LinkedHashMap<K, List<V>>());
      }
  
      public BasicMultiMap(Map<K, List<V>> impl)
      {
          _impl = impl;
      }
  
      @Override public List<V> getAll(Object key)
      {
          return _impl.get(key);
      }
  
      @Override public boolean isEmpty()
      {
          return _impl.isEmpty();
      }
  
      @Override public void add(K key, V value)
      {
          getList(key, true).add(value);
      }
  
      @Override public void add(K key, V value, int index)
      {
          getList(key, true).add(index, value);
      }
  
      @Override public void clear()
      {
          _impl.clear();
      }
  
      @Override public boolean containsKey(Object key)
      {
          return _impl.containsKey(key);
      }
  
      @Override public boolean containsValue(Object value)
      {
          boolean ret = false;
  
          for (List<V> all : _impl.values())
          {
              if (all.contains(value))
              {
                  ret = true;
  
                  break;
              }
          }
  
          return ret;
      }
  
      @Override public Set<Entry<K, V>> entrySet()
      {
          Set<Entry<K, V>> ret = new HashSet<Entry<K, V>>();
  
          for (K key : keySet())
          {
              ret.add(new ShadowEntry(key));
         }
 
         return ret;
     }
 
     @Override public V get(Object key)
     {
         List<V> values = getList(key, false);
 
         return (values == null) ? null : values.get(values.size() - 1);
     }
 
     @Override public V get(Object key, int index)
     {
         List<V> values = getList(key, false);
 
         return (values == null) ? null : values.get(index);
     }
 
     @Override public Set<K> keySet()
     {
         return _impl.keySet();
     }
 
     @Override public int length(Object key)
     {
         List<V> values = getList(key, false);
 
         return (values == null) ? 0 : values.size();
     }
 
     @Override public V put(K key, V value)
     {
         V ret = null;
         List<V> values = getList(key, true);
 
         if (values.isEmpty())
         {
             values.add(value);
         }
         else
         {
             ret = values.set(values.size() - 1, value);
         }
 
         return ret;
     }
 
     @Override public V put(K key, V value, int index)
     {
         return getList(key, false).set(index, value);
     }
 
     @SuppressWarnings(Warnings.UNCHECKED)
     @Override public void putAll(Map<? extends K, ? extends V> map)
     {
         if (map instanceof MultiMap)
         {
             MultiMap<K, V> mm = (MultiMap<K, V>) map;
 
             for (Object key : mm.keySet())
             {
                 putAll((K) key, mm.getAll(key));
             }
         }
         else
         {
             for (K key : map.keySet())
             {
                 put(key, map.get(key));
             }
         }
     }
 
     @Override public List<V> putAll(K key, List<V> values)
     {
         List<V> ret = _impl.get(key);
 
         _impl.put(key, new ArrayList<V>(values));
 
         return ret;
     }
 
     @Override public V remove(Object key)
     {
         List<V> prev = _impl.remove(key);
 
         return (prev == null) ? null : prev.get(0);
     }
 
     @Override public V remove(Object key, int index)
     {
         V ret = null;
         List<V> values = getList(key, false);
 
         if (values != null)
         {
             ret = values.remove(index);
             if (values.isEmpty())
             {
                 _impl.remove(key);
             }
         }
 
         return ret;
     }
 
     @Override public int size()
     {
         return _impl.size();
     }
 
     @Override public String toString()
     {
         return _impl.toString();
     }
 
     @Override public Collection<V> values()
     {
         List<V> all = new ArrayList<V>(_impl.size());
 
         for (List<V> values : _impl.values())
         {
             all.addAll(values);
         }
 
         return all;
     }
 
     @SuppressWarnings(Warnings.UNCHECKED)
     private List<V> getList(Object key, boolean create)
     {
         List<V> values = _impl.get(key);
 
         if ((values == null) && create)
         {
             values = new ArrayList<V>();
             _impl.put((K) key, values);
         }
 
         return values;
     }
 
     class ShadowEntry implements Map.Entry<K, V>
     {
         private final K _key;
 
         ShadowEntry(K key)
         {
             _key = key;
         }
 
         @Override public K getKey()
         {
             return _key;
         }
 
         @Override public V getValue()
         {
             return get(_key);
         }
 
         @Override public V setValue(V value)
         {
             return put(_key, value);
         }
     }
 }