function sigmoid(x) {
  return 1 / (1 + Math.exp(-x));
}

function dsigmoid(y) {
  //return sigmoid(x) * (1 - sigmoid(x));
  return y * (1 - y);
}

class NeuralNetwork {

  // hiddenLayersConfiguration is an object =
  // {numberOfLayers: number, nodesPerLayer: number}
  constructor(inputNodes, hiddenLayers, outputNodes, learningRate) {
    this.inputNodes = inputNodes;
    this.hiddenLayers = hiddenLayers;
    this.outputNodes = outputNodes;

    this.weights = this.setupWeights();
    this.biases = this.setupBiases();
    this.learningRate = learningRate;
  }

  setupWeights() {
    let weights = new Array();
    weights.push(new Matrix(this.hiddenLayers.nodesPerLayer, this.inputNodes));

    for (let i = 0; i < this.hiddenLayers.numberOfLayers - 1; i++) {
      weights.push(new Matrix(this.hiddenLayers.nodesPerLayer, this.hiddenLayers.nodesPerLayer));
    }

    weights.push(new Matrix(this.outputNodes, this.hiddenLayers.nodesPerLayer));

    for (let i = 0; i < weights.length; i++) {
      weights[i].randomize();
    }

    return weights;
  }

  setupBiases() {
    let biases = new Array();
    biases.push(new Matrix(this.hiddenLayers.nodesPerLayer, 1));

    for (let i = 0; i < this.hiddenLayers.numberOfLayers - 1; i++) {
      biases.push(new Matrix(this.hiddenLayers.nodesPerLayer, 1));
    }

    biases.push(new Matrix(this.outputNodes, 1));

    for (let i = 0; i < biases.length; i++) {
      biases[i].randomize();
    }

    return biases;
  }

  guess(inputArray) {
    let current = Matrix.fromArray(inputArray);
    for (let i = 0; i < this.weights.length; i++) {
      current = Matrix.multiply(this.weights[i], current);
      current.add(this.biases[i]);
      current.map(sigmoid);
    }

    return current.toArray();
  }

  feedFoward(inputArray) {
    let steps = new Array();
    let current = Matrix.fromArray(inputArray);
    steps.push(current);
    for (let i = 0; i < this.weights.length; i++) {
      current = Matrix.multiply(this.weights[i], current);
      current.add(this.biases[i]);
      current.map(sigmoid);
      steps.push(current);
    }

    return steps;
  }

  train(inputArray, targetArray) {
    let steps = this.feedFoward(inputArray);
    let targets = Matrix.fromArray(targetArray);
    let errors = null;
    let gradient = null;
    let deltas = null;

    for (let i = steps.length - 1 ; i >= 1; i--) {
      // Calculates error
      if (i != steps.length - 1) {
        targets = Matrix.transpose(this.weights[i]);
        errors = Matrix.multiply(targets, errors);
      } else {
        errors = Matrix.subtract(targets, steps[i]);
      }

      // Calculates gradient
      gradient = Matrix.map(steps[i], dsigmoid);
      gradient.multiply(errors);
      gradient.multiply(this.learningRate);

      // Calculate deltas
      let transposed = Matrix.transpose(steps[i - 1]);
      deltas = Matrix.multiply(gradient, transposed);

      // Adjust weights
      this.weights[i - 1].add(deltas);
      this.biases[i - 1].add(gradient);
    }
  }
}