/*
 * 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();
    }
}