package components.map;

/**
 * Layered implementations of secondary methods for {@code Map}.
 *
 * @param <K>
 *            type of {@code Map} domain (key) entries
 * @param <V>
 *            type of {@code Map} range (associated value) entries
 */
public abstract class MapSecondary<K, V> implements Map<K, V> {

    /*
     * Protected members ------------------------------------------------------
     */

    /**
     * Straightforward implementation of {@code Pair} interface.
     *
     * @param <K>
     *            type of {@code Pair} first entry ({@code Map} key entry)
     * @param <V>
     *            type of {@code Pair} second entry ({@code Map} value entry)
     */
    protected static final class SimplePair<K, V> implements Pair<K, V> {

        /**
         * The key.
         */
        private final K key;
        /**
         * The value.
         */
        private final V value;

        /**
         * Constructor.
         *
         * @param key
         *            the key
         * @param value
         *            the value
         */
        public SimplePair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        @Override
        public K key() {
            return this.key;
        }

        @Override
        public V value() {
            return this.value;
        }

        @Override
        public boolean equals(Object obj) {
            if (obj == this) {
                return true;
            }
            if (obj == null) {
                return false;
            }
            if (!(obj instanceof Pair<?, ?>)) {
                return false;
            }
            Pair<?, ?> pair = (Pair<?, ?>) obj;
            return this.key.equals(pair.key())
                    && this.value.equals(pair.value());
        }

        @Override
        public int hashCode() {
            return this.key.hashCode() + this.value.hashCode();
        }

        @Override
        public String toString() {
            return "(" + this.key + "," + this.value + ")";
        }

    }

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

    /**
     * Reports a key associated with {@code value} in {@code m} if such a key
     * exists, or {@code null} otherwise.
     *
     * @param <K>
     *            type of {@code Map} domain (key) entries
     * @param <V>
     *            type of {@code Map} range (associated value) entries
     * @param m
     *            the map in which to look for the given value
     * @param value
     *            the value whose associated key is to be reported
     * @return a key associated with value
     * @aliases reference returned by {@code keyForMap}, if such a key exists
     * @ensures <pre>
     * if value is in RANGE(m)
     *  then (keyForMap, value) is in m
     *  else [keyForMap is null]
     * </pre>
     */
    private static <K, V> K keyForMap(Map<K, V> m, V value) {
        assert m != null : "Violation of: m is not null";
        assert value != null : "Violation of: value is not null";
        K foundKey = null;
        /**
         * @maintains <pre>
         * value is not in
         *  {key: K, val: V
         *   where ((key, val) is in m  and  key is in entries(~m.seen))
         * (val)}
         * </pre>
         */
        for (Pair<K, V> pair : m) {
            if (pair.value().equals(value)) {
                foundKey = pair.key();
                break;
            }
        }
        return foundKey;
    }

    /*
     * Public members ---------------------------------------------------------
     */

    /*
     * Common methods (from Object) -------------------------------------------
     */

    @Override
    public final boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Map<?, ?>)) {
            return false;
        }
        /*
         * This feels like it can't be the right way to do this, but it compiles
         * with only an "unchecked cast" warning (and the cast cannot fail
         * because of type erasure). Using wildcard parameters prevents the loop
         * from compiling. So, it's still a question how it should be done!
         * Also, there is the technical question of whether it is possible to
         * tell whether two empty Maps (with different K and V) are equal; seems
         * not.
         */
        @SuppressWarnings("unchecked")
        Map<K, V> m = (Map<K, V>) obj;
        if (this.size() != m.size()) {
            return false;
        }
        /*
         * |this| = |m|, so every (key, value) pair in this is also in m iff
         * this = m.
         */
        for (Pair<K, V> pair : this) {
            if (!m.hasKey(pair.key())) {
                return false;
            } else if (!pair.value().equals(m.value(pair.key()))) {
                return false;
            }
        }
        return true;
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public int hashCode() {
        final int a = 37;
        final int b = 17;
        int result = 0;
        /*
         * This code does not run in O(1) time. Perhaps a better hash function
         * would be to return the size; there just doesn't seem to be anything
         * in between!
         */
        for (Pair<K, V> pair : this) {
            result += a * pair.key().hashCode() + b * pair.value().hashCode();
        }
        return result;
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public String toString() {
        StringBuilder result = new StringBuilder("{");
        boolean first = true;
        for (Pair<K, V> pair : this) {
            if (first) {
                first = false;
            } else {
                result.append(",");
            }
            result.append(pair.toString());
        }
        result.append("}");
        return result.toString();
    }

    /*
     * Other non-kernel methods -----------------------------------------------
     */

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public 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)";
        MapSecondary.Pair<K, V> p = this.remove(key);
        this.add(p.key(), value);
        return p.value();
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public K key(V value) {
        assert value != null : "Violation of: value is not null";
        K foundKey = keyForMap(this, value);
        assert foundKey != null : "Violation of: value is in RANGE(this)";
        return foundKey;
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public boolean hasValue(V value) {
        assert value != null : "Violation of: value is not null";
        K foundKey = keyForMap(this, value);
        return foundKey != null;
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public boolean sharesKeyWith(Map<K, V> m) {
        assert m != null : "Violation of: m is not null";
        assert m != this : "Violation of: m is not this";
        boolean found = false;
        /**
         * @maintains <pre>
         * if key is in entries(~this.seen)
         * then key is not in DOMAIN(m)
         * </pre>
         */
        for (Pair<K, V> pair : this) {
            if (m.hasKey(pair.key())) {
                found = true;
                break;
            }
        }
        return found;
    }

    // CHECKSTYLE: ALLOW THIS METHOD TO BE OVERRIDDEN
    @Override
    public void combineWith(Map<K, V> m) {
        assert m != null : "Violation of: m is not null";
        assert m != this : "Violation of: m is not this";
        assert !this.sharesKeyWith(m) : "Violation of: "
                + "DOMAIN(this) intersection DOMAIN(m) = {}";
        /**
         * @updates this
         * @maintains <pre>
         * this = #this union
         *  {key: K, value: V
         *    where ((key, value) is in m  and
         *          key is in entries(~m.seen))
         *   ((key, value))}
         * </pre>
         * @decreases |~m.unseen|
         */
        for (Pair<K, V> pair : m) {
            this.add(pair.key(), pair.value());
        }
        m.clear();
    }

}