package nova;

import java.util.*;
import java.util.concurrent.*;

/**
 * Warranty & Liability
 * To the extent permitted by applicable law and unless explicitly
 * otherwise agreed upon, XLOG Technologies AG makes no warranties
 * regarding the provided information. XLOG Technologies AG assumes
 * no liability that any problems might be solved with the information
 * provided by XLOG Technologies AG.
 *
 * Rights & License
 * All industrial property rights regarding the information - copyright
 * and patent rights in particular - are the sole property of XLOG
 * Technologies AG. If the company was not the originator of some
 * excerpts, XLOG Technologies AG has at least obtained the right to
 * reproduce, change and translate the information.
 *
 * Reproduction is restricted to the whole unaltered document. Reproduction
 * of the information is only allowed for non-commercial uses. Selling,
 * giving away or letting of the execution of the library is prohibited.
 * The library can be distributed as part of your applications and libraries
 * for execution provided this comment remains unchanged.
 *
 * Restrictions
 * Only to be distributed with programs that add significant and primary
 * functionality to the library. Not to be distributed with additional
 * software intended to replace any components of the library.
 *
 * Trademarks
 * Jekejeke is a registered trademark of XLOG Technologies AG.
 */
public final class Handler {

    /**
     * make_special(), flags=MASK_PRED_SPECIAL
     */
    public static interface Builtin {
        public abstract Object run(Object[] args);
    }

    /**
     * make_check(), flags=MASK_PRED_TEST
     */
    public static interface Check {
        public abstract boolean run(Object[] args);
    }

    /**
     * make_arithmetic(), flags=MASK_PRED_ARITH
     * Use german spelling to distinguish from Function
     */
    public static interface Funktion {
        public abstract Number eval(Object[] obj);
    }

    /**
     * Choice point callback.
     */
    public static interface Callback {
        public abstract Object run(Object rope, int at, Machine.Choice choice);
    }

    /**
     * A runtime exception with a Prolog term.
     */
    public static class Problem extends RuntimeException {
        public Object term;

        public Problem(Object term) {
            this.term = term;
        }
    }

    /**
     * An array list which exposes removeRange.
     */
    public static class Rope extends ArrayList {

        public Rope() {
        }

        public Rope(Collection c) {
            super(c);
        }

        public void removeRange(int f, int t) {
            super.removeRange(f, t);
        }

    }

    /******************************************************************/
    /* Surrogate async/await                                          */
    /******************************************************************/

    public static Semaphore bouncer = new Semaphore(0, true);

    public static class Promise {
        Runnable proc;

        public Promise(Runnable proc) {
            this.proc = proc;
        }

        public void await() {
            bouncer.release();
            try {
                proc.run();
            } finally {
                bouncer.acquireUninterruptibly();
            }
        }

    }

    public static class Coroutine {
        Runnable proc;

        public Coroutine(Runnable proc) {
            this.proc = proc;
        }

        public void async() {
            new Thread(() -> {
                bouncer.acquireUninterruptibly();
                try {
                    proc.run();
                } finally {
                    bouncer.release();
                }
            }).start();
        }
    }

    public static class ArrayMap<K, V> extends AbstractMap<K, V>
            implements Map<K, V>, RandomAccess {
        public static final int MIN_SIZE = 2;

        public Object[] kvs;
        public int size;

        public ArrayMap() {
            kvs = new Object[MIN_SIZE];
        }

        public ArrayMap(Map<K, V> map) {
            size = map.size();
            int len = MIN_SIZE;
            while (size > len)
                len = len * 2;
            kvs = new Object[2 * len];
            len = 0;
            Iterator<Entry<K, V>> it = map.entrySet().iterator();
            while (it.hasNext()) {
                Entry<K, V> entry = it.next();
                kvs[len++] = entry.getKey();
                kvs[len++] = entry.getValue();
            }
        }

        public int size() {
            return size;
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public boolean containsKey(Object key) {
            return indexOfKey(key) >= 0;
        }

        public boolean containsValue(Object value) {
            return indexOfValue(value) >= 0;
        }

        public V get(Object key) {
            int i = indexOfKey(key);
            return (i >= 0 ? getValue(i) : null);
        }

        public V put(K key, V value) {
            int i = indexOfKey(key);
            if (i >= 0) {
                return setValue(i, value);
            } else {
                addLast(key, value);
                return null;
            }
        }

        public V remove(Object key) {
            int i = indexOfKey(key);
            if (i >= 0) {
                return removeAt(i);
            } else {
                return null;
            }
        }

        Set<Entry<K, V>> entrySet;

        public Set<Entry<K, V>> entrySet() {
            Set<Entry<K, V>> es = entrySet;
            if (es == null) {
                Set<Entry<K, V>> ses = new ArrayEntrySet();
                entrySet = ses;
                return ses;
            } else {
                return es;
            }
        }

        final class ArrayEntrySet extends AbstractSet<Entry<K, V>>
                implements Set<Entry<K, V>> {

            public final int size() {
                return size;
            }

            public final Iterator<Entry<K, V>> iterator() {
                return new ArrayEntryIterator();
            }

        }

        class ArrayEntryIterator implements Iterator<Entry<K, V>>, Entry<K, V> {
            int cursor;       // index of next element to return
            int lastRet = -1; // index of last element returned; -1 if no such

            public K getKey() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                return (K) kvs[lastRet * 2];
            }

            public V getValue() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                return (V) kvs[lastRet * 2 + 1];
            }

            public V setValue(V value) {
                if (lastRet < 0)
                    throw new IllegalStateException();
                V old = (V) kvs[lastRet * 2 + 1];
                kvs[lastRet * 2 + 1] = value;
                return old;
            }

            public boolean hasNext() {
                return cursor != size;
            }

            public Entry<K, V> next() {
                int i = cursor;
                if (i >= size)
                    throw new NoSuchElementException();
                lastRet = i;
                cursor = i + 1;
                return this;
            }

            public void remove() {
                if (lastRet < 0)
                    throw new IllegalStateException();
                removeAt(lastRet);
                cursor = lastRet;
                lastRet = -1;
            }

        }

        /***************************************************************/
        /* Helpers                                                     */
        /***************************************************************/

        /**
         * Retrieve a key.
         *
         * @param i The index.
         * @return The key.
         */
        public K getKey(int i) {
            return (K) kvs[2 * i];
        }

        /**
         * Retrieve a value.
         *
         * @param i The index.
         * @return The value.
         */
        public V getValue(int i) {
            return (V) kvs[2 * i + 1];
        }

        /**
         * Set a value.
         *
         * @param i     The index.
         * @param value The value.
         * @return The old value.
         */
        public V setValue(int i, V value) {
            V old = (V) kvs[2 * i + 1];
            kvs[2 * i + 1] = value;
            return old;
        }

        /**
         * Resize the pairs array to a new size.
         *
         * @param s The new size.
         */
        public void resize(int s) {
            Object[] newobs = new Object[2 * s];
            int k = Math.min(s, kvs.length / 2);
            System.arraycopy(kvs, 0, newobs, 0, 2 * k);
            kvs = newobs;
        }

        /**
         * Returns the first index of the key occurence.
         *
         * @param o The key.
         * @return The index, or -1.
         */
        public int indexOfKey(Object o) {
            for (int i = 0; i < size; i++)
                if (o != null ? o.equals(kvs[2 * i]) : null == kvs[2 * i])
                    return i;
            return -1;
        }

        /**
         * Returns the first index of the value occurence.
         *
         * @param o The value.
         * @return The index, or -1.
         */
        public int indexOfValue(Object o) {
            for (int i = 0; i < size; i++)
                if (o != null ? o.equals(kvs[2 * i + 1]) : null == kvs[2 * i + 1])
                    return i;
            return -1;
        }

        /**
         * Remove a key value pair at an index.
         *
         * @param i The index.
         * @return The old value at this index.
         */
        public V removeAt(int i) {
            V old = (V) kvs[2 * i + 1];
            int k = size - i - 1;
            if (k > 0)
                System.arraycopy(kvs, 2 * i + 2, kvs, 2 * i, 2 * k);
            --size;
            kvs[2 * size] = null;
            kvs[2 * size + 1] = null;
            return old;
        }

        /**
         * Add a key value at the end</p>
         *
         * @param key   The key.
         * @param value The value.
         */
        public void addLast(K key, V value) {
            if (size >= kvs.length / 2)
                resize(kvs.length);
            kvs[2 * size] = key;
            kvs[2 * size + 1] = value;
            size++;
        }

    }

}