const ASSIGNMENT = 'assignment';
const ANSWER = 'answer';
const NEWLINE_CHARACTER = '\n';
const MAX_SIZE = 100000;
const UPDATE_SIZE = 30000000;
const TOTAL_SPACE = 70000000;

/**
 * Main function
 */
window.onload = function() {
    document.getElementById(ASSIGNMENT).addEventListener("input", calculateAnswer);
}

class TreeNode {
  constructor(value, parent) {
    console.debug(((!parent)?"Root ":"") + "node created: " + value);

    this.parent = parent;
    this.value = value;
    this.size = 0;
    this.descendants = [];
  }

  getDir = function(path) {
    for(let descendant of this.descendants) {
      if(descendant.value == path) {
        return descendant;
      }
    }
  }

  contains = function(path) {
    // Recursive case
    let subPathIndex = path.indexOf('/');
    let subPath = path.substring(0, subPathIndex-1);
    let leftOverPath = path.substring(subPathIndex);

    // Base case
    if(subPath == '') {
      return false;
    }

    for(let descendant of this.descendants) {
      if(descendant.value == subPath) {
        return descendant.contains(subPath);
      }
    }
  }

  findClosestNodeToSize = function(minSize) {
    let closest = this;

    for(let descendant of this.descendants) {
      let closestDescendant = descendant.findClosestNodeToSize(minSize);

      if (closestDescendant.size > minSize && closestDescendant.size < closest.size) {
        console.debug("New closest:" + closestDescendant.size);
        closest = closestDescendant;
      }
    }

    return closest;
  }

  increaseSize = function(size) {
    // TODO: Wat doen we met duplicate files?
    this.size += size;
    if(this.parent) {
      this.parent.increaseSize(size);
    }
  }

  getSum = function(maxSize) {
    let result = (this.size < maxSize) ? this.size: 0;

    for(let descendant of this.descendants) {
      result += descendant.getSum(maxSize);
    }

    return result;
  }
}

/**
 * Listener function for input in assignment field.
 * @param event the onInput event 
 */
function calculateAnswer(event) {
  console.info("Calculating answer for input...");
  let answer = algorithm(event.target.value);

  document.getElementById(ANSWER).innerText = answer;
}

/**
 * Calculate the answer to assignment.
 * @param assignment the input from the assignment.
 * @return string the answer
 */
function algorithm(assignment) {
  let lines = assignment.trim().split(NEWLINE_CHARACTER);
  console.info("Linecount:" + lines.length);

  let root = new TreeNode('/');
  let currentdir = root;

  for(let i=0; i<lines.length; i++) {
    let terminalLine = lines[i].trim();

    if(terminalLine.substring(0, 4) == "$ cd") {
      let changeDirectory = terminalLine.substring(5).trim();
      if(changeDirectory == "..") {
        console.debug("One directory up from: " + currentdir.value);
        currentdir = currentdir.parent;
        console.debug("navigates to: " + currentdir.value);
        continue;
      }

      if(changeDirectory == "/") {
        currentdir = root;
        continue;
      }

      if(!currentdir.contains(changeDirectory)) {
        currentdir.descendants.push(new TreeNode(changeDirectory, currentdir));
      } 

      currentdir = currentdir.getDir(changeDirectory);
    } else if(terminalLine.substring(0, 3) != 'dir' && !terminalLine.includes('$')) {
      console.debug(terminalLine);
      spaceIndex = terminalLine.indexOf(' ');
      size = parseInt(terminalLine.substring(0, spaceIndex));
      currentdir.increaseSize(size);
    }
  }

  let freeDiskSpace = TOTAL_SPACE - root.size;
  console.debug("Free disk space: " + freeDiskSpace);

  console.debug("Root size:" + root.size);
  console.debug("Value to find: " + (UPDATE_SIZE - freeDiskSpace));
  let closestNode = root.findClosestNodeToSize(UPDATE_SIZE - freeDiskSpace);
  console.debug("Closest value: " + closestNode.size);

  return "Sum below maxSize " + MAX_SIZE + ": " + root.getSum(MAX_SIZE);
}