class Node {
  constructor(value, leftNode, rightNode) {
    this.value = value;
    this.leftNode = leftNode;
    this.rightNode = rightNode;
    this.min_value_possible = null;
    this.max_value_possible = null;
    this.isValid = null;
    this.setUpInstanceVariables();
  }

  setMinAndMaxValuesPossible(min_value_possible, max_value_possible) {
    this.min_value_possible = min_value_possible.toString();
    this.max_value_possible = max_value_possible.toString();

    this.min_value_possible = this.min_value_possible.replace("Infinity", "∞");
    this.max_value_possible = this.max_value_possible.replace("Infinity", "∞");

    if (this.value > min_value_possible && this.value < max_value_possible) {
      this.isValid = true;
    } else {
      this.isValid = false;
    }
  }

  representAsTreantJsConfig() {
    let config = {
      text: {
        name: this.val
      }
    };
    if (this.min_value_possible != null) {
      config.text.desc = `Min:${this.min_value_possible}, Max:${this.max_value_possible}`;
    }

    if (this.isValid == true) {
      config.HTMLclass = "valid_node";
    } else if (this.isValid == false) {
      config.HTMLclass = "in_valid_node";
    } else {
      config.HTMLclass = "to_check";
    }

    let childrenArray = [];
    if (this.leftNode != null) {
      childrenArray.push(this.leftNode.representAsTreantJsConfig());
    }

    if (this.rightNode != null) {
      childrenArray.push(this.rightNode.representAsTreantJsConfig());
    }

    config.children = childrenArray;
    return config;
  }

  setUpInstanceVariables() {
    this.val = this.value;
    this.left = this.leftNode;
    this.right = this.rightNode;
  }

  value() {
    return this.value;
  }

  leftNode() {
    return this.leftNode;
  }

  rightNode() {
    return this.rightNode;
  }
}

const constructBinaryTree = (treeAsArray, rootIdx) => {
  let value = treeAsArray[rootIdx];
  let leftNode = null;
  let rightNode = null;

  let leftNodeIdx = 2 * rootIdx + 1;
  let rightNodeIdx = 2 * rootIdx + 2;

  if (
    treeAsArray[leftNodeIdx] != null ||
    treeAsArray[leftNodeIdx] != undefined
  ) {
    leftNode = constructBinaryTree(treeAsArray, leftNodeIdx);
  }

  if (
    treeAsArray[rightNodeIdx] != null ||
    treeAsArray[rightNodeIdx] != undefined
  ) {
    rightNode = constructBinaryTree(treeAsArray, rightNodeIdx);
  }

  return new Node(value, leftNode, rightNode);
};

let isThisAValidSubTree = (node, min_value_possible, max_value_possible) => {
  node.setMinAndMaxValuesPossible(min_value_possible, max_value_possible);
  addToTreeConfigs();

  let nodeVal = node.val;
  if (nodeVal <= min_value_possible || nodeVal >= max_value_possible) {
    return false;
  }

  let leftChild = node.left;
  let leftChildMinValue = min_value_possible;
  let leftChildMaxValue = nodeVal;

  if (
    leftChild != null &&
    isThisAValidSubTree(leftChild, leftChildMinValue, leftChildMaxValue) ==
      false
  ) {
    return false;
  }

  let rightChild = node.right;
  let rightChildMinValue = nodeVal;
  let rightChildMaxValue = max_value_possible;

  if (
    rightChild != null &&
    isThisAValidSubTree(rightChild, rightChildMinValue, rightChildMaxValue) ==
      false
  ) {
    return false;
  }

  return true;
};

var isValidBST = function (root) {
  return isThisAValidSubTree(
    root,
    Number.NEGATIVE_INFINITY,
    Number.POSITIVE_INFINITY
  );
};

let treeConfigs = [];

const addToTreeConfigs = () => {
  let config = tree.representAsTreantJsConfig();
  let configCopy = JSON.parse(JSON.stringify(config));
  treeConfigs.push(configCopy);
};

const drawTree = (treeAsTreantJsConfig) => {
  let chart_config = {
    chart: {
      container: "#basic-example",
      connectors: {
        type: "straight"
      },
      siblingSeparation: 200,
      levelSeparation: 100,
      subTeeSeparation: 100
    },
    nodeStructure: treeAsTreantJsConfig
  };

  new Treant(chart_config);
  canDrawTree = false;
};

let indexOfConfigToDraw = undefined;
let setIntervalId = undefined;
let tree = undefined;
const jsConfetti = new JSConfetti();

const constructBinaryTreeOnBasisOfInput = () => {
  treeConfigs = [];
  shownConfetti = false;

  document.getElementById("success-result").style.display = "none";
  document.getElementById("failed-result").style.display = "none";

  clearInterval(setIntervalId);
  indexOfConfigToDraw = 0;
  let treeInput = document.getElementById("tree_input").value;
  let treeAsArray = treeInput.split(",").map((val) => {
    let theVal = val.trim();
    if (isNaN(theVal)) {
      return null;
    } else {
      return parseInt(theVal);
    }
  });
  tree = constructBinaryTree(treeAsArray, 0);
  let resultOfTreeValidity = isValidBST(tree);

  setIntervalId = setInterval(() => {
    if (indexOfConfigToDraw < treeConfigs.length) {
      drawTree(treeConfigs[indexOfConfigToDraw]);
      indexOfConfigToDraw++;
    } else {
      clearInterval(setIntervalId);
      if (resultOfTreeValidity == true) {
        document.getElementById("success-result").style.display = "block";
        jsConfetti.addConfetti({
          emojis: ["🎉", "🎊"],
          emojiSize: 50,
          confettiNumber: 100,
          confettiRadius: 6,
          confettiHeight: 6,
          wind: 0,
          gravity: 0.2,
          rotation: 0,
          rotationDeg: 0,
          colors: ["#a864fd", "#29cdff", "#78ff44", "#ff718d", "#fdff6a"]
        });
      } else {
        document.getElementById("failed-result").style.display = "block";
        document.getElementById("basic-example").classList.add("shake_me");
        setTimeout(() => {
          document.getElementById("basic-example").classList.remove("shake_me");
        }, 1000);
      }
    }
  }, 1000);
};

document.getElementById("validate_this_tree").addEventListener("click", () => {
  constructBinaryTreeOnBasisOfInput();
});