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

const AST = require('../src/ast/index')
const tt = require('../src/tokenTypes')

test('parses token stream into a tree', t => {
  t.plan(1)
  const tree = helpers.parse(`
    (div :class "foobar"
      (p :class (cond #t "primary" "secondary")))
  `)

  t.deepEqual(tree, [
    new AST.Application({
      functionName: new AST.Identifier({ name: 'div' }),
      args: [
        new AST.Attribute({
          name: 'class',
          value: new AST.String({ value: 'foobar' }),
        }),
        new AST.Application({
          functionName: new AST.Identifier({ name: 'p' }),
          args: [
            new AST.Attribute({
              name: 'class',
              value: new AST.Application({
                functionName: new AST.Identifier({ name: 'cond' }),
                args: [
                  new AST.Boolean({ value: true }),
                  new AST.String({ value: 'primary' }),
                  new AST.String({ value: 'secondary' }),
                ],
              }),
            }),
          ],
        }),
      ],
    }),
  ])
})

test('allow empty strings', t => {
  t.plan(1)
  const tree = helpers.parse('(p "")')

  t.deepEqual(tree, [
    new AST.Application({
      functionName: new AST.Identifier({ name: 'p' }),
      args: [new AST.String({ value: '' })],
    }),
  ])
})

test('parses calls to define into a function definition', t => {
  t.plan(1)
  const tree = helpers.parse('(define plusOne (n) (+ n 1))')

  t.deepEqual(tree, [
    new AST.FunctionDefinition({
      name: new AST.Identifier({ name: 'plusOne' }),
      parameters: [new AST.Identifier({ name: 'n' })],
      body: new AST.Application({
        functionName: new AST.Identifier({ name: '+' }),
        args: [new AST.Identifier({ name: 'n' }), new AST.Number({ value: 1 })],
      }),
    }),
  ])
})