const test = require('tape')
const helpers = require('./helpers')

const AST = require('../src/ast')
const OsloError = require('../src/osloError')

test('list function', t => {
  t.plan(1)

  const tree = helpers.evaluate('(list 1 2 3)')
  t.deepEqual(
    tree[0],
    new AST.List({
      elements: [
        new AST.Number({ value: 1, line: 1 }),
        new AST.Number({ value: 2, line: 1 }),
        new AST.Number({ value: 3, line: 1 }),
      ],
    }),
  )
})

test('length function', t => {
  t.plan(1)

  const tree = helpers.evaluate('(length (list 1 2 3))')
  t.deepEqual(tree[0], new AST.Number({ value: 3 }))
})

test('map', t => {
  t.plan(1)
  const tree = helpers.evaluate(`
    (define my-map
      (lambda (f xs)
        (if (= (length xs) 0)
          (list)
          (cons
            (f (first xs))
            (my-map f (rest xs))))))

    (my-map (lambda (x) (+ x 1)) (list 1 2 3))
  `)
  t.deepEqual(
    tree[0],
    new AST.List({
      elements: [
        new AST.Number({ value: 2 }),
        new AST.Number({ value: 3 }),
        new AST.Number({ value: 4 }),
      ],
    }),
  )
})

test('div', t => {
  t.plan(1)
  const tree = helpers.evaluate('(div :class "hello" "world")')
  t.deepEqual(
    tree[0],
    new AST.HTMLElement({
      name: 'div',
      attributes: [
        new AST.Attribute({
          name: 'class',
          value: new AST.String({ value: 'hello' }),
        })
      ],
      contents: [ new AST.String({ value: 'world' }) ],
      selfClosing: false,
    })
  )
})

test('nested elements', t => {
  t.plan(1)
  const tree = helpers.evaluate('(div :class "hello" (div :class "world"))')
  t.deepEqual(
    tree[0],
    new AST.HTMLElement({
      name: 'div',
      attributes: [
        new AST.Attribute({
          name: 'class',
          value: new AST.String({ value: 'hello' }),
        }),
      ],
      contents: [
        new AST.HTMLElement({
          name: 'div',
          attributes: [
            new AST.Attribute({
              name: 'class',
              value: new AST.String({ value: 'world' }),
            })
          ],
          contents: [],
          selfClosing: false,
        })
      ],
      selfClosing: false,
    })
  )
})

test('self closing tag', t => {
  t.plan(1)
  const tree = helpers.evaluate('(img)')
  t.deepEqual(
    tree[0],
    new AST.HTMLElement({
      name: 'img',
      attributes: [],
      contents: [],
      selfClosing: true,
    })
  )
})