package components.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;

/**
 * {@code Map} represented as a {@link java.util.Map java.util.Map} with
 * implementations of primary methods.
 *
 * @param <K>
 *            type of {@code Map} domain (key) entries
 * @param <V>
 *            type of {@code Map} range (associated value) entries
 * @correspondence this = [value of $this]
 */
public class Map1L<K, V> extends MapSecondary<K, V> {

    /*
     * Private members --------------------------------------------------------
     */

    /**
     * Representation of {@code this}.
     */
    private java.util.Map<K, V> rep;

    /**
     * Creator of initial representation.
     */
    private void createNewRep() {
        this.rep = new HashMap<K, V>();
    }

    /*
     * Constructors -----------------------------------------------------------
     */

    /**
     * No-argument constructor.
     */
    public Map1L() {
        this.createNewRep();
    }

    /*
     * Standard methods -------------------------------------------------------
     */

    @SuppressWarnings("unchecked")
    @Override
    public final Map<K, V> newInstance() {
        try {
            return this.getClass().getConstructor().newInstance();
        } catch (ReflectiveOperationException e) {
            throw new AssertionError(
                    "Cannot construct object of type " + this.getClass());
        }
    }

    @Override
    public final void clear() {
        this.createNewRep();
    }

    @Override
    public final void transferFrom(Map<K, V> source) {
        assert source != null : "Violation of: source is not null";
        assert source != this : "Violation of: source is not this";
        assert source instanceof Map1L<?, ?>
                : "Violation of: source is of dynamic type Map1L<?,?>";
        /*
         * This cast cannot fail since the assert above would have stopped
         * execution in that case: source must be of dynamic type Map2<?,?>, and
         * the ?,? must be K,V or the call would not have compiled.
         */
        Map1L<K, V> localSource = (Map1L<K, V>) source;
        this.rep = localSource.rep;
        localSource.createNewRep();
    }

    /*
     * Kernel methods ---------------------------------------------------------
     */

    @Override
    public final void add(K key, V value) {
        assert key != null : "Violation of: key is not null";
        assert value != null : "Violation of: value is not null";
        assert !this.hasKey(key) : "Violation of: key is not in DOMAIN(this)";
        this.rep.put(key, value);
    }

    @Override
    public final Map.Pair<K, V> remove(K key) {
        assert key != null : "Violation of: key is not null";
        assert this.hasKey(key) : "Violation of: key is in DOMAIN(this)";
        /*
         * The following "obvious" code is incorrect because it creates an alias
         * where one is not specified in the contract (because no alias is
         * needed). This is a design flaw in java.util.Map that means Map1L is
         * not a competitive implementation of MapKernel when assertion-checking
         * is disabled.
         */
        // return new SimplePair<K, V>(key, this.rep.remove(key));
        /*
         * Note: null will never be returned, but we still need to initialize.
         */
        K keyRemoved = null;
        Set<K> keys = this.rep.keySet();
        for (K x : keys) {
            if (x.equals(key)) {
                keyRemoved = x;
                break;
            }
        }
        V valueRemoved = this.rep.remove(keyRemoved);
        return new SimplePair<K, V>(keyRemoved, valueRemoved);
    }

    @Override
    public final Pair<K, V> removeAny() {
        assert this.size() > 0 : "Violation of: this /= empty_set";
        Iterator<java.util.Map.Entry<K, V>> it = this.rep.entrySet().iterator();
        java.util.Map.Entry<K, V> entry = it.next();
        it.remove();
        return new SimplePair<K, V>(entry.getKey(), entry.getValue());
    }

    @Override
    public final V value(K key) {
        assert key != null : "Violation of: key is not null";
        assert this.hasKey(key) : "Violation of: key is in DOMAIN(this)";
        return this.rep.get(key);
    }

    @Override
    public final boolean hasKey(K key) {
        assert key != null : "Violation of: key is not null";
        return this.rep.containsKey(key);
    }

    @Override
    public final int size() {
        return this.rep.size();
    }

    @Override
    public final Iterator<Pair<K, V>> iterator() {
        return new Map1LIterator();
    }

    /**
     * Implementation of {@code Iterator} interface for {@code Map1L}.
     */
    private final class Map1LIterator implements Iterator<Pair<K, V>> {

        /**
         * Representation iterator.
         */
        private final Iterator<java.util.Map.Entry<K, V>> iterator;

        /**
         * No-argument constructor.
         */
        private Map1LIterator() {
            this.iterator = Map1L.this.rep.entrySet().iterator();
        }

        @Override
        public boolean hasNext() {
            return this.iterator.hasNext();
        }

        @Override
        public Pair<K, V> next() {
            assert this.hasNext() : "Violation of: ~this.unseen /= <>";
            if (!this.hasNext()) {
                /*
                 * Exception is supposed to be thrown in this case, but with
                 * assertion-checking enabled it cannot happen because of assert
                 * above.
                 */
                throw new NoSuchElementException();
            }
            java.util.Map.Entry<K, V> entry = this.iterator.next();
            return new SimplePair<K, V>(entry.getKey(), entry.getValue());
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("remove operation not supported");
        }

    }

    /*
     * Other methods (overridden for performance reasons) ---------------------
     */

    @Override
    public final V replaceValue(K key, V value) {
        assert key != null : "Violation of: key is not null";
        assert value != null : "Violation of: value is not null";
        assert this.hasKey(key) : "Violation of: key is in DOMAIN(this)";
        return this.rep.put(key, value);
    }

}