// test AssignmentNode
var assert = require('assert')
var approx = require('../../../tools/approx')
var math = require('../../../src/index')
var Node = math.expression.node.Node
var AccessorNode = math.expression.node.AccessorNode
var ConstantNode = math.expression.node.ConstantNode
var SymbolNode = math.expression.node.SymbolNode
var RangeNode = math.expression.node.RangeNode
var ArrayNode = math.expression.node.ArrayNode
var AssignmentNode = math.expression.node.AssignmentNode
var OperatorNode = math.expression.node.OperatorNode
var IndexNode = math.expression.node.IndexNode

describe('AssignmentNode', function () {
  it('should create an AssignmentNode', function () {
    var n = new AssignmentNode(new SymbolNode('a'), new Node())
    assert(n instanceof AssignmentNode)
    assert(n instanceof Node)
    assert.equal(n.type, 'AssignmentNode')
  })

  it('should have property isAssignmentNode', function () {
    var node = new AssignmentNode(new SymbolNode('a'), new Node())
    assert(node.isAssignmentNode)
  })

  it('should throw an error when calling without new operator', function () {
    assert.throws(function () { AssignmentNode(new SymbolNode('a'), new Node()) }, SyntaxError)
  })

  it('should throw an error when creating an AssignmentNode with a reserved keyword', function () {
    assert.throws(function () {
      new AssignmentNode(new SymbolNode('end'), new Node())
    }, /Cannot assign to symbol "end"/)
  })

  it('should throw an error on wrong constructor arguments', function () {
    assert.throws(function () { new AssignmentNode() }, TypeError)
    assert.throws(function () { new AssignmentNode(new Node(), new Node()) }, TypeError)
    assert.throws(function () { new AssignmentNode('a', new Node()) }, TypeError)
    assert.throws(function () { new AssignmentNode(2, new Node()) }, TypeError)
    assert.throws(function () { new AssignmentNode(new Node(), new Node(), new Node()) }, TypeError)
  })

  it('should get the name of an AssignmentNode', function () {
    var n = new AssignmentNode(new SymbolNode('a'), new ConstantNode(1))
    assert.equal(n.name, 'a')

    var n2 = new AccessorNode(new SymbolNode('a'), new IndexNode([new ConstantNode('b')]))
    var n3 = new AssignmentNode(n2, new ConstantNode(1))
    assert.equal(n3.name, 'b')

    var n4 = new AssignmentNode(new SymbolNode('a'), new IndexNode([new ConstantNode('b')]), new ConstantNode(1))
    assert.equal(n4.name, 'b')

    var n5 = new AssignmentNode(new SymbolNode('a'), new IndexNode([new ConstantNode(1)]), new ConstantNode(1))
    assert.equal(n5.name, '')
  })

  it('should compile an AssignmentNode without index', function () {
    var n = new AssignmentNode(new SymbolNode('b'), new ConstantNode(3))

    var expr = n.compile()

    var scope = {}
    assert.equal(expr.eval(scope), 3)
    assert.equal(scope.b, 3)
  })

  it('should compile an AssignmentNode with property index', function () {
    var object = new SymbolNode('a')
    var index = new IndexNode([new ConstantNode('b')])
    var value = new ConstantNode(3)
    var n = new AssignmentNode(object, index, value)

    var expr = n.compile()

    var scope = {
      a: {}
    }
    assert.equal(expr.eval(scope), 3)
    assert.deepEqual(scope, {a: {b: 3}})
  })

  it('should compile an AssignmentNode with nested property index', function () {
    var a = new SymbolNode('a')
    var object = new AccessorNode(a, new IndexNode([new ConstantNode('b')]))
    var index = new IndexNode([new ConstantNode('c')])
    var value = new ConstantNode(3)
    var n = new AssignmentNode(object, index, value)

    var expr = n.compile()

    var scope = {
      a: {
        b: {}
      }
    }
    assert.equal(expr.eval(scope), 3)
    assert.deepEqual(scope, {a: {b: {c: 3}}})
  })

  it('should compile an AssignmentNode with matrix index', function () {
    var object = new SymbolNode('a')
    var index = new IndexNode([
      new ConstantNode(2),
      new ConstantNode(1)
    ])
    var value = new ConstantNode(5)
    var n = new AssignmentNode(object, index, value)
    var expr = n.compile()

    var scope = {
      a: [[0, 0], [0, 0]]
    }
    assert.strictEqual(expr.eval(scope), 5)
    assert.deepEqual(scope, {
      a: [[0, 0], [5, 0]]
    })
  })

  it('should compile an AssignmentNode with range and context parameters', function () {
    var object = new SymbolNode('a')
    var index = new IndexNode([
      new ConstantNode(2),
      new RangeNode(
        new ConstantNode(1),
        new SymbolNode('end')
      )
    ])
    var value = new SymbolNode('b')
    var n = new AssignmentNode(object, index, value)
    var expr = n.compile()

    var scope = {
      a: [[0, 0], [0, 0]],
      b: [5, 6]
    }
    assert.deepEqual(expr.eval(scope), [5, 6])
    assert.deepEqual(scope, {
      a: [[0, 0], [5, 6]],
      b: [5, 6]
    })
  })

  it('should compile an AssignmentNode with bignumber setting', function () {
    var bigmath = math.create({number: 'BigNumber'})

    var object = new bigmath.expression.node.SymbolNode('a')
    var index = new bigmath.expression.node.IndexNode([
      new bigmath.expression.node.ConstantNode(2),
      new bigmath.expression.node.ConstantNode(1)
    ])
    var value = new bigmath.expression.node.ConstantNode(bigmath.bignumber(5))
    var n = new bigmath.expression.node.AssignmentNode(object, index, value)
    var expr = n.compile()

    var scope = {
      a: [[0, 0], [0, 0]]
    }
    assert.deepEqual(expr.eval(scope), bigmath.bignumber(5))
    assert.deepEqual(scope, {
      a: [[0, 0], [bigmath.bignumber(5), 0]]
    })
  })

  it('should throw an error when applying an index onto a scalar', function () {
    var a = new SymbolNode('a')
    var index = new IndexNode([new ConstantNode(4)])
    var value = new ConstantNode(2)
    var n = new AssignmentNode(a, index, value)
    var expr = n.compile()

    var scope = {
      a: 42
    }
    assert.throws(function () { expr.eval(scope) }, /Cannot apply index: unsupported type of object/)
  })

  it('should filter an AssignmentNode', function () {
    var a = new SymbolNode('a')
    var b = new ConstantNode(2)
    var c = new ConstantNode(1)
    var i = new IndexNode([b, c])
    var v = new ConstantNode(2)
    var n = new AssignmentNode(a, i, v)

    assert.deepEqual(n.filter(function (node) { return node.isAssignmentNode }), [n])
    assert.deepEqual(n.filter(function (node) { return node.isSymbolNode }), [a])
    assert.deepEqual(n.filter(function (node) { return node.isConstantNode }), [b, c, v])
    assert.deepEqual(n.filter(function (node) { return node.value === 1 }), [c])
    assert.deepEqual(n.filter(function (node) { return node.value === 2 }), [b, v])
    assert.deepEqual(n.filter(function (node) { return node.name === 'q' }), [])
  })

  it('should filter an AssignmentNode without index', function () {
    var a = new SymbolNode('a')
    var v = new ConstantNode(2)
    var n = new AssignmentNode(a, v)

    assert.deepEqual(n.filter(function (node) { return node.isAssignmentNode }), [n])
    assert.deepEqual(n.filter(function (node) { return node.isSymbolNode }), [a])
    assert.deepEqual(n.filter(function (node) { return node.isConstantNode }), [v])
    assert.deepEqual(n.filter(function (node) { return node.value === 2 }), [v])
    assert.deepEqual(n.filter(function (node) { return node.name === 'q' }), [])
  })

  it('should run forEach on an AssignmentNode', function () {
    // A[1, x] = 3
    var a = new SymbolNode('A')
    var b = new ConstantNode(2)
    var c = new SymbolNode('x')
    var i = new IndexNode([b, c])
    var v = new ConstantNode(3)
    var n = new AssignmentNode(a, i, v)

    var nodes = []
    var paths = []
    n.forEach(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, n)
    })

    assert.equal(nodes.length, 3)
    assert.strictEqual(nodes[0], a)
    assert.strictEqual(nodes[1], i)
    assert.strictEqual(nodes[2], v)
    assert.deepEqual(paths, ['object', 'index', 'value'])
  })

  it('should run forEach on an AssignmentNode without index', function () {
    // A[1, x] = 3
    var a = new SymbolNode('A')
    var v = new ConstantNode(3)
    var n = new AssignmentNode(a, v)

    var nodes = []
    var paths = []
    n.forEach(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, n)
    })

    assert.equal(nodes.length, 2)
    assert.strictEqual(nodes[0], a)
    assert.strictEqual(nodes[1], v)
    assert.deepEqual(paths, ['object', 'value'])
  })

  it('should map an AssignmentNode', function () {
    // A[1, x] = 3
    var a = new SymbolNode('A')
    var b = new ConstantNode(2)
    var c = new SymbolNode('x')
    var i = new IndexNode([b, c])
    var v = new ConstantNode(3)
    var n = new AssignmentNode(a, i, v)

    var nodes = []
    var paths = []
    var e = new ConstantNode(4)
    var f = n.map(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, n)

      return node instanceof SymbolNode && node.name == 'x' ? e : node
    })

    assert.equal(nodes.length, 3)
    assert.strictEqual(nodes[0], a)
    assert.strictEqual(nodes[1], i)
    assert.strictEqual(nodes[2], v)
    assert.deepEqual(paths, ['object', 'index', 'value'])

    assert.notStrictEqual(f, n)
    assert.deepEqual(f.object, a)
    assert.deepEqual(f.index.dimensions[0], b)
    assert.deepEqual(f.index.dimensions[1], c) // not replaced, is nested
    assert.deepEqual(f.value, v)
  })

  it('should map an AssignmentNode without index', function () {
    // a = x + 2
    var a = new SymbolNode('a')
    var x = new SymbolNode('x')
    var d = new AssignmentNode(a, x)

    var e = new ConstantNode(3)
    var nodes = []
    var paths = []
    var f = d.map(function (node, path, parent) {
      nodes.push(node)
      paths.push(path)
      assert.strictEqual(parent, d)
      return node instanceof SymbolNode && node.name == 'x' ? e : node
    })

    assert.equal(nodes.length, 2)
    assert.strictEqual(nodes[0], a)
    assert.strictEqual(nodes[1], x)
    assert.deepEqual(paths, ['object', 'value'])

    assert.notStrictEqual(f, d)
    assert.strictEqual(d.value, x)
    assert.strictEqual(f.value, e)
  })

  it('should throw an error when the map callback does not return a node', function () {
    // A[1, x] = 3
    var a = new SymbolNode('A')
    var b = new ConstantNode(2)
    var c = new SymbolNode('x')
    var i = new IndexNode([b, c])
    var v = new ConstantNode(3)
    var n = new AssignmentNode(a, i, v)

    assert.throws(function () {
      n.map(function () {})
    }, /Callback function must return a Node/)
  })

  it('should transform an AssignmentNodes (nested) parameters', function () {
    // a = x + 2
    var object = new SymbolNode('a')
    var x = new SymbolNode('x')
    var index = new IndexNode([x])
    var b = new ConstantNode(2)
    var value = new OperatorNode('+', 'add', [x, b])
    var d = new AssignmentNode(object, index, value)

    var e = new ConstantNode(3)
    var f = d.transform(function (node) {
      return node.isSymbolNode && node.name == 'x' ? e : node
    })

    assert.notStrictEqual(f, d)
    assert.deepEqual(f.index.dimensions[0], e)
    assert.deepEqual(f.value.args[0], e)
    assert.deepEqual(f.value.args[1], b)
  })

  it('should transform an AssignmentNode itself', function () {
    // a = x + 2
    var object = new SymbolNode('a')
    var x = new SymbolNode('x')
    var b = new ConstantNode(2)
    var c = new OperatorNode('+', 'add', [x, b])
    var d = new AssignmentNode(object, c)

    var e = new ConstantNode(5)
    var f = d.transform(function (node) {
      return node instanceof AssignmentNode ? e : node
    })

    assert.notStrictEqual(f, d)
    assert.deepEqual(f, e)
  })

  it('should traverse an AssignmentNode', function () {
    var object = new SymbolNode('a')
    var i = new IndexNode([])
    var value = new ConstantNode(2)
    var a = new AssignmentNode(object, i, value)

    var count = 0
    a.traverse(function (node, index, parent) {
      count++

      switch (count) {
        case 1:
          assert.strictEqual(node, a)
          assert.strictEqual(index, null)
          assert.strictEqual(parent, null)
          break

        case 2:
          assert.strictEqual(node, object)
          assert.strictEqual(index, 'object')
          assert.strictEqual(parent, a)
          break

        case 3:
          assert.strictEqual(node, i)
          assert.strictEqual(index, 'index')
          assert.strictEqual(parent, a)
          break

        case 4:
          assert.strictEqual(node, value)
          assert.strictEqual(index, 'value')
          assert.strictEqual(parent, a)
          break
      }
    })

    assert.equal(count, 4)
  })

  it('should clone an AssignmentNode without index', function () {
    var object = new SymbolNode('a')
    var value = new ConstantNode(2)
    var a = new AssignmentNode(object, value)

    var b = a.clone()
    assert(b instanceof AssignmentNode)
    assert.deepEqual(b, a)
    assert.notStrictEqual(b, a)
    assert.strictEqual(b.object, a.object)
    assert.strictEqual(b.index, a.index)
    assert.strictEqual(b.value, a.value)
  })

  it('should clone an AssignmentNode', function () {
    // A[1, x] = 3
    var a = new SymbolNode('A')
    var b = new ConstantNode(2)
    var c = new SymbolNode('x')
    var i = new IndexNode([b, c])
    var v = new ConstantNode(3)
    var d = new AssignmentNode(a, i, v)

    var e = d.clone()

    assert(e instanceof AssignmentNode)
    assert.deepEqual(e, d)
    assert.notStrictEqual(e, d)
    assert.strictEqual(e.object, d.object)
    assert.strictEqual(e.index, d.index)
    assert.strictEqual(e.value, d.value)
  })

  it('test equality another Node', function () {
    var a = new AssignmentNode(
      new SymbolNode('A'),
      new IndexNode([new ConstantNode(2), new SymbolNode('x')]),
      new ConstantNode(3))
    var b = new AssignmentNode(
      new SymbolNode('A'),
      new IndexNode([new ConstantNode(2), new SymbolNode('x')]),
      new ConstantNode(3))
    var c = new AssignmentNode(
      new SymbolNode('B'),
      new IndexNode([new ConstantNode(2), new SymbolNode('x')]),
      new ConstantNode(3))
    var d = new AssignmentNode(
      new SymbolNode('A'),
      new IndexNode([new ConstantNode(2)]),
      new ConstantNode(3))
    var e = new AssignmentNode(
      new SymbolNode('A'),
      new IndexNode([new ConstantNode(2), new SymbolNode('x')]),
      new ConstantNode(4))

    assert.strictEqual(a.equals(null), false)
    assert.strictEqual(a.equals(undefined), false)
    assert.strictEqual(a.equals(b), true)
    assert.strictEqual(a.equals(c), false)
    assert.strictEqual(a.equals(d), false)
    assert.strictEqual(a.equals(e), false)
  })

  it('should respect the \'all\' parenthesis option', function () {
    var object = new SymbolNode('a')
    var value = new ConstantNode(1)
    var n = new AssignmentNode(object, value)

    assert.equal(n.toString({parenthesis: 'all'}), 'a = (1)')
    assert.equal(n.toTex({parenthesis: 'all'}), ' a:=\\left(1\\right)')
  })

  it('should stringify a AssignmentNode', function () {
    var object = new SymbolNode('b')
    var value = new ConstantNode(3)
    var n = new AssignmentNode(object, value)

    assert.equal(n.toString(), 'b = 3')
  })

  it('should stringify an AssignmentNode containing an AssignmentNode', function () {
    var value = new ConstantNode(2)
    var a = new AssignmentNode(new SymbolNode('a'), value)
    var n = new AssignmentNode(new SymbolNode('b'), a)

    assert.equal(n.toString(), 'b = (a = 2)')
  })

  it('should stringify an AssignmentNode with custom toString', function () {
    // Also checks if custom funcions get passed to the children
    var customFunction = function (node, options) {
      if (node.type === 'AssignmentNode') {
        return node.object.toString(options) +
            (node.index ? node.index.toString(options) : '') +
            ' equals ' + node.value.toString(options)
      } else if (node.type === 'ConstantNode') {
        return 'const(' + node.value + ', ' + math.typeof(node.value) + ')'
      }
    }

    var object = new SymbolNode('a')
    var value = new ConstantNode(1)
    var n = new AssignmentNode(object, value)

    assert.equal(n.toString({handler: customFunction}), 'a equals const(1, number)')
  })

  it('toJSON and fromJSON', function () {
    var a = new SymbolNode('a')
    var b = new ConstantNode(1)
    var c = new ConstantNode(2)
    var d = new ConstantNode(3)

    var node = new AssignmentNode(a, new IndexNode([b, c]), d)

    var json = node.toJSON()

    assert.deepEqual(json, {
      mathjs: 'AssignmentNode',
      index: {
        dimensions: [ b, c ],
        dotNotation: false
      },
      object: a,
      value: d
    })

    var parsed = AssignmentNode.fromJSON(json)
    assert.deepEqual(parsed, node)
  })

  it('should LaTeX a AssignmentNode', function () {
    var value = new ConstantNode(2)
    var a = new AssignmentNode(new SymbolNode('a'), value)

    assert.equal(a.toTex(), ' a:=2')
  })

  it('should LaTeX an AssignmentNode containing an AssignmentNode', function () {
    var value = new ConstantNode(2)
    var a = new AssignmentNode(new SymbolNode('a'), value)
    var q = new AssignmentNode(new SymbolNode('q'), a)

    assert.equal(q.toTex(), ' q:=\\left( a:=2\\right)')
  })

  it('should LaTeX an AssignmentNode with custom toTex', function () {
    // Also checks if custom funcions get passed to the children
    var customFunction = function (node, options) {
      if (node.isAssignmentNode) {
        return node.object.toTex(options) +
            (node.index ? node.index.toTex(options) : '') +
            '\\mbox{equals}' + node.value.toTex(options)
      } else if (node.type === 'ConstantNode') {
        return 'const\\left(' + node.value + ', ' + math.typeof(node.value) + '\\right)'
      }
    }

    var object = new SymbolNode('a')
    var value = new ConstantNode(1)
    var n = new AssignmentNode(object, value)

    assert.equal(n.toTex({handler: customFunction}), ' a\\mbox{equals}const\\left(1, number\\right)')
  })
})