class TreeNode {
  public value: number;
  public left!: TreeNode;
  public right!: TreeNode;

  constructor(value: number) {
    this.value = value;
  }
}

type Method = "preOrder" | "inOrder" | "postOrder";

class BinaryTree {
  public root: TreeNode;

  constructor(value: number) {
    this.root = new TreeNode(value);
  }

  public add(value: number) {
    const newNode = new TreeNode(value);

    if (!this.root) {
      this.root = newNode;
      return;
    }

    let currentNode = this.root;

    while (currentNode) {
      if (newNode.value < currentNode.value) {
        if (!currentNode.left) {
          currentNode.left = newNode;
          return;
        }

        currentNode = currentNode.left;
      } else {
        if (!currentNode.right) {
          currentNode.right = newNode;
          return;
        }

        currentNode = currentNode.right;
      }
    }
  }

  public traverseDFS(method: Method, callback: (node: TreeNode) => void) {
    switch (method) {
      case "preOrder":
        return this.preOrder(this.root, callback);
      case "inOrder":
        return this.inOrder(this.root, callback);
      default:
        return this.postOrder(this.root, callback);
    }
  }

  public traverseBFS(callback: (node: TreeNode) => void) {
    const queue = [this.root];

    while (queue.length) {
      const node = queue.shift()!;
      callback(node);
      if (node.left) queue.push(node.left);
      if (node.right) queue.push(node.right);
    }
  }

  private preOrder(node: TreeNode, callback: (node: TreeNode) => void) {
    if (!node) return;

    callback && callback(node);
    this.preOrder(node.left, callback);
    this.preOrder(node.right, callback);
  }

  private inOrder(node: TreeNode, callback: (node: TreeNode) => void) {
    if (!node) return;

    this.preOrder(node.left, callback);
    callback && callback(node);
    this.preOrder(node.right, callback);
  }

  private postOrder(node: TreeNode, callback: (node: TreeNode) => void) {
    if (!node) return;

    this.preOrder(node.left, callback);
    this.preOrder(node.right, callback);
    callback && callback(node);
  }
}

const tree = new BinaryTree(8);

tree.add(7);
tree.add(9);
tree.add(5);
tree.add(10);
tree.add(20);
tree.add(6);
tree.add(2);
tree.add(11);

//              8
//          7       9
//      5               10
//  2       6               20
//                      11

// tree.traverseDFS("preOrder", (node: TreeNode) => { console.log(node.value) })
tree.traverseBFS((node: TreeNode) => {
  console.log(node.value);
});