// Copyright 2003-2005 Arthur van Hoff Rick Blair
   // Licensed under Apache License version 2.0
   // Original license LGPL
   
   package javax.jmdns.impl;
   
   import java.util.AbstractMap;
   import java.util.ArrayList;
   import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import javax.jmdns.impl.constants.DNSRecordClass;
  import javax.jmdns.impl.constants.DNSRecordType;
  
  /**
   * A table of DNS entries. This is a map table which can handle multiple entries with the same name.
   * <p/>
   * Storing multiple entries with the same name is implemented using a linked list. This is hidden from the user and can change in later implementation.
   * <p/>
   * Here's how to iterate over all entries:
   *
   * <pre>
   *       for (Iterator i=dnscache.allValues().iterator(); i.hasNext(); ) {
   *             DNSEntry entry = i.next();
   *             ...do something with entry...
   *       }
   * </pre>
   * <p/>
   * And here's how to iterate over all entries having a given name:
   *
   * <pre>
   *       for (Iterator i=dnscache.getDNSEntryList(name).iterator(); i.hasNext(); ) {
   *             DNSEntry entry = i.next();
   *           ...do something with entry...
   *       }
   * </pre>
   *
   * @author Arthur van Hoff, Werner Randelshofer, Rick Blair, Pierre Frisch
   */
  public class DNSCache extends AbstractMap<String, List<? extends DNSEntry>> {
  
      // private static Logger logger = Logger.getLogger(DNSCache.class.getName());
  
      private transient Set<Map.Entry<String, List<? extends DNSEntry>>> _entrySet  = null;
  
      /**
       *
       */
      public static final DNSCache                                       EmptyCache = new _EmptyCache();
  
      static final class _EmptyCache extends DNSCache {
  
          /**
           * {@inheritDoc}
           */
          @Override
          public int size() {
              return 0;
          }
  
          /**
           * {@inheritDoc}
           */
          @Override
          public boolean isEmpty() {
              return true;
          }
  
          /**
           * {@inheritDoc}
           */
          @Override
          public boolean containsKey(Object key) {
              return false;
          }
  
          /**
           * {@inheritDoc}
           */
          @Override
          public boolean containsValue(Object value) {
              return false;
          }
  
          /**
           * {@inheritDoc}
           */
          @Override
          public List<DNSEntry> get(Object key) {
              return null;
          }
  
          /**
           * {@inheritDoc}
          */
         @Override
         public Set<String> keySet() {
             return Collections.emptySet();
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public Collection<List<? extends DNSEntry>> values() {
             return Collections.emptySet();
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public Set<Map.Entry<String, List<? extends DNSEntry>>> entrySet() {
             return Collections.emptySet();
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean equals(Object o) {
             return (o instanceof Map) && ((Map<?, ?>) o).size() == 0;
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public List<? extends DNSEntry> put(String key, List<? extends DNSEntry> value) {
             return null;
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public int hashCode() {
             return 0;
         }
 
     }
 
     /**
      *
      */
     protected static class _CacheEntry extends Object implements Map.Entry<String, List<? extends DNSEntry>> {
 
         private List<? extends DNSEntry> _value;
 
         private String                   _key;
 
         /**
          * @param key
          * @param value
          */
         protected _CacheEntry(String key, List<? extends DNSEntry> value) {
             super();
             _key = (key != null ? key.trim().toLowerCase() : null);
             _value = value;
         }
 
         /**
          * @param entry
          */
         protected _CacheEntry(Map.Entry<String, List<? extends DNSEntry>> entry) {
             super();
             if (entry instanceof _CacheEntry) {
                 _key = ((_CacheEntry) entry).getKey();
                 _value = ((_CacheEntry) entry).getValue();
             }
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public String getKey() {
             return (_key != null ? _key : "");
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public List<? extends DNSEntry> getValue() {
             return _value;
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public List<? extends DNSEntry> setValue(List<? extends DNSEntry> value) {
             List<? extends DNSEntry> oldValue = _value;
             _value = value;
             return oldValue;
         }
 
         /**
          * Returns <tt>true</tt> if this list contains no elements.
          *
          * @return <tt>true</tt> if this list contains no elements
          */
         public boolean isEmpty() {
             return this.getValue().isEmpty();
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public boolean equals(Object entry) {
             if (!(entry instanceof Map.Entry)) {
                 return false;
             }
             return this.getKey().equals(((Map.Entry<?, ?>) entry).getKey()) && this.getValue().equals(((Map.Entry<?, ?>) entry).getValue());
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public int hashCode() {
             return (_key == null ? 0 : _key.hashCode());
         }
 
         /**
          * {@inheritDoc}
          */
         @Override
         public synchronized String toString() {
             StringBuffer aLog = new StringBuffer(200);
             aLog.append("\n\t\tname '");
             aLog.append(_key);
             aLog.append("' ");
             if ((_value != null) && (!_value.isEmpty())) {
                 for (DNSEntry entry : _value) {
                     aLog.append("\n\t\t\t");
                     aLog.append(entry.toString());
                 }
             } else {
                 aLog.append(" no entries");
             }
             return aLog.toString();
         }
     }
 
     /**
      *
      */
     public DNSCache() {
         this(1024);
     }
 
     /**
      * @param map
      */
     public DNSCache(DNSCache map) {
         this(map != null ? map.size() : 1024);
         if (map != null) {
             this.putAll(map);
         }
     }
 
     /**
      * Create a table with a given initial size.
      *
      * @param initialCapacity
      */
     public DNSCache(int initialCapacity) {
         super();
         _entrySet = new HashSet<Map.Entry<String, List<? extends DNSEntry>>>(initialCapacity);
     }
 
     // ====================================================================
     // Map
 
     /*
      * (non-Javadoc)
      * @see java.util.AbstractMap#entrySet()
      */
     @Override
     public Set<Map.Entry<String, List<? extends DNSEntry>>> entrySet() {
         if (_entrySet == null) {
             _entrySet = new HashSet<Map.Entry<String, List<? extends DNSEntry>>>();
         }
         return _entrySet;
     }
 
     /**
      * @param key
      * @return map entry for the key
      */
     protected Map.Entry<String, List<? extends DNSEntry>> getEntry(String key) {
         String stringKey = (key != null ? key.trim().toLowerCase() : null);
         for (Map.Entry<String, List<? extends DNSEntry>> entry : this.entrySet()) {
             if (stringKey != null) {
                 if (stringKey.equals(entry.getKey())) {
                     return entry;
                 }
             } else {
                 if (entry.getKey() == null) {
                     return entry;
                 }
             }
         }
         return null;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public List<? extends DNSEntry> put(String key, List<? extends DNSEntry> value) {
         synchronized (this) {
             List<? extends DNSEntry> oldValue = null;
             Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(key);
             if (oldEntry != null) {
                 oldValue = oldEntry.setValue(value);
             } else {
                 this.entrySet().add(new _CacheEntry(key, value));
             }
             return oldValue;
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     protected Object clone() throws CloneNotSupportedException {
         return new DNSCache(this);
     }
 
     // ====================================================================
 
     /**
      * Returns all entries in the cache
      *
      * @return all entries in the cache
      */
     public synchronized Collection<DNSEntry> allValues() {
         List<DNSEntry> allValues = new ArrayList<DNSEntry>();
         for (List<? extends DNSEntry> entry : this.values()) {
             if (entry != null) {
                 allValues.addAll(entry);
             }
         }
         return allValues;
     }
 
     /**
      * Iterate only over items with matching name. Returns an list of DNSEntry or null. To retrieve all entries, one must iterate over this linked list.
      *
      * @param name
      * @return list of DNSEntries
      */
     public synchronized Collection<? extends DNSEntry> getDNSEntryList(String name) {
         Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
         if (entryList != null) {
             entryList = new ArrayList<DNSEntry>(entryList);
         } else {
             entryList = Collections.emptyList();
         }
         return entryList;
     }
 
     private Collection<? extends DNSEntry> _getDNSEntryList(String name) {
         return this.get(name != null ? name.toLowerCase() : null);
     }
 
     /**
      * Get a matching DNS entry from the table (using isSameEntry). Returns the entry that was found.
      *
      * @param dnsEntry
      * @return DNSEntry
      */
     public synchronized DNSEntry getDNSEntry(DNSEntry dnsEntry) {
         DNSEntry result = null;
         if (dnsEntry != null) {
             Collection<? extends DNSEntry> entryList = this._getDNSEntryList(dnsEntry.getKey());
             if (entryList != null) {
                 for (DNSEntry testDNSEntry : entryList) {
                     if (testDNSEntry.isSameEntry(dnsEntry)) {
                         result = testDNSEntry;
                         break;
                     }
                 }
             }
         }
         return result;
     }
 
     /**
      * Get a matching DNS entry from the table.
      *
      * @param name
      * @param type
      * @param recordClass
      * @return DNSEntry
      */
     public synchronized DNSEntry getDNSEntry(String name, DNSRecordType type, DNSRecordClass recordClass) {
         DNSEntry result = null;
         Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
         if (entryList != null) {
             for (DNSEntry testDNSEntry : entryList) {
                 if (testDNSEntry.getRecordType().equals(type) && ((DNSRecordClass.CLASS_ANY == recordClass) || testDNSEntry.getRecordClass().equals(recordClass))) {
                     result = testDNSEntry;
                     break;
                 }
             }
         }
         return result;
     }
 
     /**
      * Get all matching DNS entries from the table.
      *
      * @param name
      * @param type
      * @param recordClass
      * @return list of entries
      */
     public synchronized Collection<? extends DNSEntry> getDNSEntryList(String name, DNSRecordType type, DNSRecordClass recordClass) {
         Collection<? extends DNSEntry> entryList = this._getDNSEntryList(name);
         if (entryList != null) {
             entryList = new ArrayList<DNSEntry>(entryList);
             for (Iterator<? extends DNSEntry> i = entryList.iterator(); i.hasNext();) {
                 DNSEntry testDNSEntry = i.next();
                 if (!testDNSEntry.getRecordType().equals(type) || ((DNSRecordClass.CLASS_ANY != recordClass) && !testDNSEntry.getRecordClass().equals(recordClass))) {
                     i.remove();
                 }
             }
         } else {
             entryList = Collections.emptyList();
         }
         return entryList;
     }
 
     /**
      * Adds an entry to the table.
      *
      * @param dnsEntry
      * @return true if the entry was added
      */
     public synchronized boolean addDNSEntry(final DNSEntry dnsEntry) {
         boolean result = false;
         if (dnsEntry != null) {
             Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(dnsEntry.getKey());
 
             List<DNSEntry> aNewValue = null;
             if (oldEntry != null) {
                 aNewValue = new ArrayList<DNSEntry>(oldEntry.getValue());
             } else {
                 aNewValue = new ArrayList<DNSEntry>();
             }
             aNewValue.add(dnsEntry);
 
             if (oldEntry != null) {
                 oldEntry.setValue(aNewValue);
             } else {
                 this.entrySet().add(new _CacheEntry(dnsEntry.getKey(), aNewValue));
             }
             // This is probably not very informative
             result = true;
         }
         return result;
     }
 
     /**
      * Removes a specific entry from the table. Returns true if the entry was found.
      *
      * @param dnsEntry
      * @return true if the entry was removed
      */
     public synchronized boolean removeDNSEntry(DNSEntry dnsEntry) {
         boolean result = false;
         if (dnsEntry != null) {
             Map.Entry<String, List<? extends DNSEntry>> existingEntry = this.getEntry(dnsEntry.getKey());
             if (existingEntry != null) {
                 result = existingEntry.getValue().remove(dnsEntry);
                 // If we just removed the last one we need to get rid of the entry
                 if (existingEntry.getValue().isEmpty()) {
                     this.entrySet().remove(existingEntry);
                 }
             }
         }
         return result;
     }
 
     /**
      * Replace an existing entry by a new one.<br/>
      * <b>Note:</b> the 2 entries must have the same key.
      *
      * @param newDNSEntry
      * @param existingDNSEntry
      * @return <code>true</code> if the entry has been replace, <code>false</code> otherwise.
      */
     public synchronized boolean replaceDNSEntry(DNSEntry newDNSEntry, DNSEntry existingDNSEntry) {
         boolean result = false;
         if ((newDNSEntry != null) && (existingDNSEntry != null) && (newDNSEntry.getKey().equals(existingDNSEntry.getKey()))) {
             Map.Entry<String, List<? extends DNSEntry>> oldEntry = this.getEntry(newDNSEntry.getKey());
 
             List<DNSEntry> aNewValue = null;
             if (oldEntry != null) {
                 aNewValue = new ArrayList<DNSEntry>(oldEntry.getValue());
             } else {
                 aNewValue = new ArrayList<DNSEntry>();
             }
             aNewValue.remove(existingDNSEntry);
             aNewValue.add(newDNSEntry);
 
             if (oldEntry != null) {
                 oldEntry.setValue(aNewValue);
             } else {
                 this.entrySet().add(new _CacheEntry(newDNSEntry.getKey(), aNewValue));
             }
             // This is probably not very informative
             result = true;
         }
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public synchronized String toString() {
         StringBuffer aLog = new StringBuffer(2000);
         aLog.append("\t---- cache ----");
         for (Map.Entry<String, List<? extends DNSEntry>> entry : this.entrySet()) {
             aLog.append("\n\t\t");
             aLog.append(entry.toString());
         }
         return aLog.toString();
     }
 
 }