const Compare ={
    LESS_THAN:-1,
    BIGGER_THAN:1,
    EQUALS:0
}
class Node{
    constructor(key){
        this.key = key;
        this.left = null;
        this.right = null;
    }
}
function defaultCompare(a,b){
    return a == b ? Compare.EQUALS:(a < b) ? Compare.LESS_THAN : Compare.BIGGER_THAN;
}
class BinarySearchTree{
    constructor(comPareFn 
 
= defaultCompare){
        this.root = null;
        this.comPareFn = comPareFn;
    }

    insert(key){
        if(this.root == null){
            this.root = new Node(key);
        }else{
            this.insertNode(this.root,key);
        }
        
    }
    insertNode(node,key){
        if(this
 
.comPareFn(key,node.key) === Compare.LESS_THAN){
            if(node.left == null){
                node.left = new Node(key);      
            }else{
                this.insertNode(node.left,key);
            }
        }else{
            if(node.right == null){
                node.right = new Node(key);
            }
 
else{
                this.insertNode(node.right,key);
            }
        }
    }
    search(key){
        return this.searchNode(this.root,key);
    }
    searchNode(node,key){
        if(node == null){
            return false;
        }
        if(this.comPareFn(key,node.key) === Compare.LESS_THAN){
            return this.searchNode(node.left,key);
        }
        else if(this.comPareFn(key,node.key) === Compare.BIGGER_THAN){
            return this.searchNode(node.right,key);
        }else{
            return true;
        }
    }
    min(){
        return this.minNode(this.root);
    }
    minNode(node){
        if(node == null){
            return node;
        }
        while(node.left!=null){
            node = node.left;
        }
        return node;
    }
    max(){
        return this.maxNode(this.root);
    }
    maxNode(node){
        if(node == null){
            return node;
        }
        while(node.right != null){
            node = node.right;
        }
        return node;
    }
    inOrderTraverse(callback){
       this.inOrderTraverseNode(this.root,callback);
    }
    inOrderTraverseNode(node,callback){
        if(node == null){
            return;
        }
        this.inOrderTraverseNode(node.left,callback);
        callback(node.key);
        this.inOrderTraverseNode(node.right,callback);
    }
    preTraverse(callback){
        this.preTraverseNode(this.root,callback);
    }
    preTraverseNode(node,callback){
        if(node == null){
            return;
        }
        callback(node.key);
        this.preTraverseNode(node.left,callback);
        this.preTraverseNode(node.right,callback);
    }
    postTraverse(callback){
        this.postTraverseNode(this.root,callback);
    }
    postTraverseNode(node,callback){
        if(node == null){
            return;
        }
        this.postTraverseNode(node.left,callback);
        this.postTraverseNode(node.right,callback);
        callback(node.key);
    }
    remove(key){
        this.root =  this.removeNode(this.root,key);
    }
    removeNode(node,key){
        if(node == null){
            return false;
        }
        if(this.comPareFn(key,node.key) === Compare.LESS_THAN){
            node.left =  this.removeNode(node.left,key);
            return node;
        }else if(this.comPareFn(key,node.key) === Compare.BIGGER_THAN){
            node.right =  this.removeNode(node.right,key);
            return node;
        }else{
            if(node.left == null && node.right == null){
                node = null;
                return node;
            }
            if(node.left == null){
                node = node.right;
                return node;
            }
            if(node.right == null){
                node = node.left;
                return node;
            }
            let tmp = this.minNode(node.right);
            node.key = tmp.key;
            node.right = this.removeNode(node.right,tmp.key);
            return node;
        }
    }
}

const BalanceFactor ={
    UNBALANCED_RIGHT:1,
    SLIGHTLY_UNBALANCED_RIGHT:2,
    BALANCED:3,
    UNBALANCED_LEFT:4,
    SLIGHTLY_UNBALANCED_LEFT:5
}

const printNode = (value) => console.log(value);
class AVLTree extends BinarySearchTree{
    constructor(comPareFn = defaultCompare){
        super(comPareFn);
    }
    getNodeHeight(node){
        if(node == null){
            return -1;
        }
        return Math.max(
            this.getNodeHeight(node.left),this.getNodeHeight(node.right)
            )+1;
     }
     getBalanceFactor(node){
        const factor = this.getNodeHeight(node.left) - this.getNodeHeight(node.right);
        switch(factor){
            case 1:
               return BalanceFactor.SLIGHTLY_UNBALANCED_LEFT;
            case 2:
               return BalanceFactor.UNBALANCED_LEFT;
            case -1:
               return BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT;
            case -2:
               return BalanceFactor.UNBALANCED_RIGHT;
            default:
               return BalanceFactor.BALANCED;
        }
    }
    insert(key){
        this.root = this.insertNode(this.root,key);
    }
    insertNode(node,key){
        if(node == null){
            return new Node(key);
        }
        if(this.comPareFn(key,node.key) === Compare.LESS_THAN){
            node.left = this.insertNode(node.left,key);
        }
        else if(this.comPareFn(key,node.key) === Compare.BIGGER_THAN){
            node.right = this.insertNode(node.right,key);
        }else{
            return node;
        }
        const balanceFactor = this.getBalanceFactor(node);
        if(balanceFactor === BalanceFactor.UNBALANCED_LEFT){
            if(this.comPareFn(key,node.key) === Compare.LESS_THAN){
                node =  this.rotationLL(node);
            }else{
                return this.rotationLR(node);
            }
        }else if(balanceFactor === BalanceFactor.UNBALANCED_RIGHT){
            if(this.comPareFn(key,node.key) === Compare.BIGGER_THAN){
                node =  this.rotationRR(node);
            }else{
                return this.rotationRL(node);
            }
        }
        return node;
    }
    rotationLL(node){
        const tmp = node.left;
        node.left = tmp.right;
        tmp.right = node;
        node = tmp;
        return tmp;
    }
    rotationRR(node){
        const tmp = node.right;
        node.right = tmp.left;
        tmp.left = node;
        return tmp;
    }
    rotationLR(node){
        node.left = this.rotationLL(node);
        return this.rotationRR(node);
    }
    rotationRL(node){
        node.right = this.rotationRR(node);
        return this.rotationLL(node);
    }
    remove(key){
        this.root = this.removeNode(this.root,key);
    }
    removeNode(node,key){
        node = super.removeNode(node,key);
        if(node == null){
            return node;
        }
        let balanceFactor = this.getBalanceFactor(node);
        if(balanceFactor === BalanceFactor.UNBALANCED_LEFT){
            let balanceFactor = this.getBalanceFactor(node.left);
            if(balanceFactor == BalanceFactor.SLIGHTLY_UNBALANCED_LEFT || balanceFactor == BalanceFactor.BALANCED){
                return this.rotationLL(node.left);
            }
            if(balanceFactor == BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT){
                return this.rotationLR(node.left);
            }
        }
        if(balanceFactor === BalanceFactor.UNBALANCED_RIGHT){
            let balanceFactor = this.getBalanceFactor(node.left);
            if(balanceFactor == BalanceFactor.SLIGHTLY_UNBALANCED_RIGHT || balanceFactor == BalanceFactor.BALANCED){
                return this.rotationRR(node.right);
            }else if(balanceFactor == BalanceFactor.SLIGHTLY_UNBALANCED_LEFT){
                return this.rotationRL(node.right);
            }
        }
        return node;
    }
}