/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You 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
    *
    *      https://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.collections4.properties;
  
  import java.util.AbstractCollection;
  import java.util.AbstractMap.SimpleEntry;
  import java.util.AbstractSet;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.Enumeration;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.Map;
  import java.util.Objects;
  import java.util.Properties;
  import java.util.Set;
  import java.util.function.BiConsumer;
  import java.util.function.BiFunction;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  
  /**
   * A drop-in replacement for {@link Properties} for ordered keys.
   * <p>
   * Overrides methods to keep keys in insertion order. Allows other methods in the superclass to work with ordered keys.
   * </p>
   *
   * @see OrderedPropertiesFactory#INSTANCE
   * @since 4.5.0-M1
   */
  public class OrderedProperties extends Properties {
  
      /**
       * A key set view in insertion order.
       */
      private final class KeySet extends AbstractSet<Object> {
  
          @Override
          public void clear() {
              OrderedProperties.this.clear();
          }
  
          @Override
          public boolean contains(final Object key) {
              return containsKey(key);
          }
  
          @Override
          public Iterator<Object> iterator() {
              return orderedKeysIterator();
          }
  
          @Override
          public boolean remove(final Object key) {
              return OrderedProperties.this.remove(key) != null;
          }
  
          @Override
          public int size() {
              return OrderedProperties.this.size();
          }
      }
  
      /**
       * A values view in key insertion order.
       */
      private final class Values extends AbstractCollection<Object> {
  
          @Override
          public void clear() {
              OrderedProperties.this.clear();
          }
  
          @Override
          public boolean contains(final Object value) {
              return containsValue(value);
          }
  
          @Override
          public Iterator<Object> iterator() {
              final Iterator<Object> keys = orderedKeysIterator();
              return new Iterator<Object>() {
  
                  @Override
                  public boolean hasNext() {
                     return keys.hasNext();
                 }
 
                 @Override
                 public Object next() {
                     return get(keys.next());
                 }
 
                 @Override
                 public void remove() {
                     keys.remove();
                 }
             };
         }
 
         @Override
         public int size() {
             return OrderedProperties.this.size();
         }
     }
 
     private static final long serialVersionUID = 1L;
 
     /**
      * Preserves the insertion order.
      */
     private final LinkedHashSet<Object> orderedKeys = new LinkedHashSet<>();
 
     /**
      * Constructs a new instance.
      */
     public OrderedProperties() {
         // empty
     }
 
     @Override
     public synchronized void clear() {
         orderedKeys.clear();
         super.clear();
     }
 
     @Override
     public synchronized Object compute(final Object key, final BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {
         final Object compute = super.compute(key, remappingFunction);
         if (compute != null) {
             orderedKeys.add(key);
         } else {
             orderedKeys.remove(key);
         }
         return compute;
     }
 
     @Override
     public synchronized Object computeIfAbsent(final Object key, final Function<? super Object, ? extends Object> mappingFunction) {
         final Object computeIfAbsent = super.computeIfAbsent(key, mappingFunction);
         if (computeIfAbsent != null) {
             orderedKeys.add(key);
         }
         return computeIfAbsent;
     }
 
     @Override
     public Set<Map.Entry<Object, Object>> entrySet() {
         return orderedKeys.stream().map(k -> new SimpleEntry<>(k, get(k))).collect(Collectors.toCollection(LinkedHashSet::new));
     }
 
     /**
      * Enumerates all key/value pairs in the specified LinkedHashSet and omits the property if the key or value is not a string.
      *
      * @param result The result set to populate.
      * @return The given set.
      */
     private synchronized LinkedHashSet<String> enumerateStringProperties(final LinkedHashSet<String> result) {
         if (defaults != null) {
             result.addAll(defaults.stringPropertyNames());
         }
         for (final Enumeration<?> e = keys(); e.hasMoreElements();) {
             final Object k = e.nextElement();
             final Object v = get(k);
             if (k instanceof String && v instanceof String) {
                 result.add((String) k);
             }
         }
         return result;
     }
 
     @Override
     public synchronized void forEach(final BiConsumer<? super Object, ? super Object> action) {
         Objects.requireNonNull(action, "action");
         orderedKeys.forEach(k -> action.accept(k, get(k)));
     }
 
     @Override
     public synchronized Enumeration<Object> keys() {
         return Collections.enumeration(orderedKeys);
     }
 
     @Override
     public Set<Object> keySet() {
         return new KeySet();
     }
 
     @Override
     public synchronized Object merge(final Object key, final Object value,
             final BiFunction<? super Object, ? super Object, ? extends Object> remappingFunction) {
         final Object merge = super.merge(key, value, remappingFunction);
         if (merge != null) {
             orderedKeys.add(key);
         } else {
             orderedKeys.remove(key);
         }
         return merge;
     }
 
     /**
      * Creates an iterator over the keys in insertion order whose {@link Iterator#remove()} also removes the mapping.
      *
      * @return A new iterator.
      */
     private Iterator<Object> orderedKeysIterator() {
         final Iterator<Object> iterator = orderedKeys.iterator();
         return new Iterator<Object>() {
 
             private Object last;
 
             @Override
             public boolean hasNext() {
                 return iterator.hasNext();
             }
 
             @Override
             public Object next() {
                 last = iterator.next();
                 return last;
             }
 
             @Override
             public void remove() {
                 // All orderedKeys writes happen under the OrderedProperties monitor.
                 synchronized (OrderedProperties.this) {
                     // Not remove(Object), which would edit orderedKeys while this iterator walks it.
                     iterator.remove();
                     OrderedProperties.super.remove(last);
                 }
             }
         };
     }
 
     @Override
     public Enumeration<?> propertyNames() {
         return Collections.enumeration(stringPropertyNames());
     }
 
     @Override
     public synchronized Object put(final Object key, final Object value) {
         final Object put = super.put(key, value);
         if (put == null) {
             orderedKeys.add(key);
         }
         return put;
     }
 
     @Override
     public synchronized void putAll(final Map<? extends Object, ? extends Object> t) {
         orderedKeys.addAll(t.keySet());
         super.putAll(t);
     }
 
     @Override
     public synchronized Object putIfAbsent(final Object key, final Object value) {
         final Object putIfAbsent = super.putIfAbsent(key, value);
         if (putIfAbsent == null) {
             orderedKeys.add(key);
         }
         return putIfAbsent;
     }
 
     @Override
     public synchronized Object remove(final Object key) {
         final Object remove = super.remove(key);
         if (remove != null) {
             orderedKeys.remove(key);
         }
         return remove;
     }
 
     @Override
     public synchronized boolean remove(final Object key, final Object value) {
         final boolean remove = super.remove(key, value);
         if (remove) {
             orderedKeys.remove(key);
         }
         return remove;
     }
 
     @Override
     public Set<String> stringPropertyNames() {
         return enumerateStringProperties(new LinkedHashSet<>());
     }
 
     @Override
     public synchronized String toString() {
         // Must override for Java 17 to maintain order since the implementation is based on a map
         final int max = size() - 1;
         if (max == -1) {
             return "{}";
         }
         final StringBuilder sb = new StringBuilder();
         final Iterator<Map.Entry<Object, Object>> it = entrySet().iterator();
         sb.append('{');
         for (int i = 0;; i++) {
             final Map.Entry<Object, Object> e = it.next();
             final Object key = e.getKey();
             final Object value = e.getValue();
             sb.append(key == this ? "(this Map)" : key.toString());
             sb.append('=');
             sb.append(value == this ? "(this Map)" : value.toString());
             if (i == max) {
                 return sb.append('}').toString();
             }
             sb.append(", ");
         }
     }
 
     @Override
     public Collection<Object> values() {
         return new Values();
     }
 }