package net.abhinavsarkar.algorist;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Stack;

public class BinarySearchTree<K extends Comparable<K>,V> implements Iterable<BinarySearchTree.Entry<K,V>>
{
    private Node<K,V> root = EmptyNode.instance();

    public void insert(K key, V val) {
        this.root = this.root.insert(key, val);
    }

    public Optional<V> get(K key) {
        return this.root.get(key);
    }

    public void delete(K key) {
        this.root.delete(key);
    }

    public Optional<K> minimum() {
        return this.root.minimum();
    }

    public Optional<K> maximum() {
        return this.root.maximum();
    }

    public Optional<K> successor(K key) {
        return this.root.successor(key);
    }

    public Optional<K> predecessor(K key) {
        return this.root.predecessor(key);
    }

    public String toString() {
        return this.root.toStringBuilder(0).toString();
    }

    @Override
    public Iterator<Entry<K, V>> iterator()
    {
        return new PreOrderIterator<>(this.root);
    }

    private interface Node<K extends Comparable<K>, V>
    {
        Node<K,V> insert(K key, V val);
        Optional<V> get(K key);
        Node<K,V> delete(K key);
        Optional<K> minimum();
        Optional<K> maximum();
        Optional<K> successor(K key);
        Optional<K> predecessor(K key);
        boolean isEmpty();
        StringBuilder toStringBuilder(int level);
        boolean checkIfBST();

        default ValueNode<K,V> toValueNode() {
            if (this.isEmpty()) {
                throw new UnsupportedOperationException();
            } else {
                return (ValueNode<K, V>) this;
            }
        }
    }

    private static class ValueNode<K extends Comparable<K>,V> implements Node<K, V>
    {
        private K key;
        private V val;
        private Node<K,V> left = EmptyNode.instance();
        private Node<K,V> right = EmptyNode.instance();

        ValueNode(K key, V val) {
            if (key == null) {
                throw new IllegalArgumentException("Key cannot be null");
            }
            if (val == null) {
                throw new IllegalArgumentException("Value cannot be null");
            }

            this.key = key;
            this.val = val;
        }

        @Override
        public boolean isEmpty()
        {
            return false;
        }

        @Override
        public Node<K, V> insert(K key, V val)
        {
            if (this.key.equals(key)) {
                this.val = val;
            } else if (this.key.compareTo(key) > 0) {
                this.left = this.left.insert(key, val);
            } else {
                this.right = this.right.insert(key, val);
            }
            return this;
        }

        @Override
        public Optional<V> get(K key)
        {
            if (this.key.equals(key)) {
                return Optional.of(val);
            } else if (this.key.compareTo(key) > 0) {
                return this.left.get(key);
            } else {
                return this.right.get(key);
            }
        }

        @Override
        public Node<K,V> delete(K key)
        {
            if (this.key.equals(key)) {
                return doDelete();
            } else if (this.key.compareTo(key) > 0) {
                this.left = this.left.delete(key);
            } else {
                this.right = this.right.delete(key);
            }
            return this;
        }

        private Node<K, V> doDelete()
        {
            if (this.left.isEmpty())
            {
                return this.right.isEmpty() ? EmptyNode.instance() : this.right;
            }
            else if (this.right.isEmpty())
            {
                return this.left;
            }
            else
            {
                ValueNode<K, V> node = deleteSuccessor();
                this.key = node.key;
                this.val = node.val;
                return this;
            }
        }

        private ValueNode<K, V> deleteSuccessor()
        {
            Node<K,V> current = this.right;
            ValueNode<K,V> successor = this.right.toValueNode();
            ValueNode<K,V> successorParent = this.right.toValueNode();
            do
            {
                ValueNode<K, V> cur = current.toValueNode();
                Node<K, V> curLeft = cur.left;
                if (!curLeft.isEmpty()) {
                    successor = curLeft.toValueNode();
                    successorParent = cur;
                }
                current = curLeft;
            } while (!current.isEmpty());

            successorParent.left = EmptyNode.instance();
            return successor;
        }

        @Override
        public Optional<K> minimum()
        {
            return Optional.of(this.left.minimum().orElse(this.key));
        }

        @Override
        public Optional<K> maximum()
        {
            return Optional.of(this.right.maximum().orElse(this.key));
        }

        @Override
        public Optional<K> successor(K key)
        {
            if (this.key.compareTo(key) > 0) {
                return Optional.of(this.left.successor(key).orElse(this.key));
            } else {
                return this.right.successor(key);
            }
        }

        @Override
        public Optional<K> predecessor(K key)
        {
            if (this.key.compareTo(key) < 0) {
                return Optional.of(this.right.predecessor(key).orElse(this.key));
            } else {
                return this.left.predecessor(key);
            }
        }

        @Override
        public boolean checkIfBST()
        {
            return this.left.checkIfBST() && this.right.checkIfBST()
                    && isKeyMoreThanLeftKey() && isKeyLessThanRightKey();
        }

        private boolean isKeyMoreThanLeftKey()
        {
            return this.left.isEmpty() || this.key.compareTo(this.left.toValueNode().key) > 0;
        }

        private boolean isKeyLessThanRightKey()
        {
            return this.right.isEmpty() || this.key.compareTo(this.right.toValueNode().key) < 0;
        }

        @Override
        public StringBuilder toStringBuilder(int level) {
            return new StringBuilder().append(gutter(level))
                    .append('<')
                    .append(key)
                    .append(':')
                    .append(val)
                    .append(">\n")
                    .append(this.left.toStringBuilder(level + 1))
                    .append(this.right.toStringBuilder(level + 1));
        }

        @Override
        public String toString()
        {
            return "{" + key + ':' + val + '}';
        }
    }

    private static class EmptyNode<K extends Comparable<K>,V> implements Node<K,V>
    {
        @SuppressWarnings("rawtypes")
        private static final EmptyNode INSTANCE = new EmptyNode();

        public static <K extends Comparable<K>,V> EmptyNode<K,V> instance() {
            return INSTANCE;
        }

        @Override
        public Node<K, V> insert(K key, V val)
        {
            return new ValueNode<>(key, val);
        }

        @Override
        public boolean isEmpty()
        {
            return true;
        }

        @Override
        public Optional<V> get(K key)
        {
            return Optional.empty();
        }

        @Override
        public Node<K, V> delete(K key) {
            return this;
        }

        @Override
        public Optional<K> minimum()
        {
            return Optional.empty();
        }

        @Override
        public Optional<K> maximum()
        {
            return Optional.empty();
        }

        public Optional<K> successor(K key) {
            return Optional.empty();
        }

        public Optional<K> predecessor(K key) {
            return Optional.empty();
        }

        @Override
        public boolean checkIfBST()
        {
            return true;
        }

        @Override
        public StringBuilder toStringBuilder(int level)
        {
            return new StringBuilder().append(gutter(level)).append("<NULL>\n");
        }

        @Override
        public String toString()
        {
            return "<NULL>";
        }
    }

    private static StringBuilder gutter(int times) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < times; i++)
        {
            sb.append('│');
        }
        return sb.append("├ ");
    }

    public static class Entry<K, V> {
        private K key;
        private V val;

        public Entry(K key, V val) {
            this.key = key;
            this.val = val;
        }

        public K getKey()
        {
            return key;
        }

        public V getVal()
        {
            return val;
        }

        public String toString() {
            return "<" + key + "," + val + ">";
        }
    }

    private static class InOrderIterator<K extends Comparable<K>, V> implements Iterator<Entry<K, V>>
    {
        private final Stack<Node<K, V>> stack = new Stack<>();

        public InOrderIterator(Node<K, V> node)
        {
            pushToStack(node);
        }

        @Override
        public boolean hasNext()
        {
            return !(this.stack.isEmpty() || this.stack.peek().isEmpty());
        }

        /*
        inorder(a):
            if a.left != null:
                yield inorder(a.left)
            yield a.val
            if a.right != null:
                yield inorder(a.right)
         */
        @Override
        public Entry<K, V> next()
        {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            ValueNode<K, V> vNode = this.stack.pop().toValueNode();
            pushToStack(vNode.right);

            return new Entry<>(vNode.key, vNode.val);
        }

        private void pushToStack(Node<K, V> node)
        {
            Node<K, V> current = node;
            while (!current.isEmpty())
            {
                this.stack.push(current);
                current = current.toValueNode().left;
            }
        }
    }

    private static class PreOrderIterator<K extends Comparable<K>, V> implements Iterator<Entry<K, V>>
    {
        private final Stack<Node<K, V>> stack = new Stack<>();
        private Node<K, V> current;

        public PreOrderIterator(Node<K, V> node)
        {
            current = node;
        }

        @Override
        public boolean hasNext()
        {
            return !this.current.isEmpty();
        }

        /*
        preorder(a):
            yield a.val
            if a.left != null:
                yield preorder(a.left)
            if a.right != null:
                yield preorder(a.right)
         */
        @Override
        public Entry<K, V> next()
        {
            if (!hasNext()) {
                throw new NoSuchElementException();
            }

            ValueNode<K, V> vNode = current.toValueNode();
            if (!vNode.left.isEmpty()) {
                stack.push(current);
                current = vNode.left;
            } else if (!vNode.right.isEmpty()) {
                current = vNode.right;
            } else if (stack.isEmpty()){
                current = EmptyNode.instance();
            } else {
                do {
                    Node<K, V> node = stack.pop();
                    current = node.toValueNode().right;
                } while (current.isEmpty());
            }

            return new Entry<>(vNode.key, vNode.val);
        }

    }

    public static void main(String[] args)
    {
        BinarySearchTree<String, String> bst = new BinarySearchTree<>();
        bst.insert("q", "barista");
        bst.insert("y", "duck");
        bst.insert("k", "carpool");
        bst.insert("p", "duck");
        bst.insert("c", "carpool");
        bst.insert("e", "barista");
        bst.insert("d", "duck");
        bst.insert("f", "abhinav");
        bst.insert("j", "abhinav");
        bst.insert("t", "duck");
        bst.insert("s", "carpool");
        bst.insert("g", "carpool");
        bst.insert("v", "abhinav");
        bst.insert("h", "duck");
        bst.insert("r", "abhinav");
        bst.insert("n", "abhinav");
        bst.insert("w", "carpool");
        bst.insert("u", "barista");
        bst.insert("z", "duck");
        bst.insert("b", "barista");
        bst.insert("o", "carpool");
        bst.insert("a", "abhinav");
        bst.insert("l", "duck");
        bst.insert("m", "barista");
        bst.insert("i", "barista");
        bst.insert("x", "duck");

        System.out.println(bst);
        System.out.println(bst.root.checkIfBST());

        System.out.println(bst.get("a"));
        System.out.println(bst.get("b"));
        System.out.println(bst.get("c"));
        System.out.println(bst.get("d"));
        System.out.println(bst.get("A"));

        bst.delete("q");
        bst.delete("r");
        bst.delete("c");
        System.out.println(bst);
        System.out.println(bst.root.checkIfBST());

        System.out.println(bst.minimum());
        System.out.println(bst.maximum());
        System.out.println(bst.successor("a"));
        System.out.println(bst.successor("z"));
        System.out.println(bst.successor("q"));

        System.out.println(bst.predecessor("a"));
        System.out.println(bst.predecessor("z"));
        System.out.println(bst.predecessor("q"));

        for (Entry<String,String> entry: bst) {
            System.out.println(entry.key);
        }
    }
}