const Error = require('./Error')

const AST = require('./ast')

const tokenTypes = require('./tokenTypes')

module.exports = class Parser {
  constructor(tokenStream) {
    this.tokenStream = tokenStream
  }

  parse() {
    let tree = []
    while (this.tokenStream.peek().type !== tokenTypes.EOF) {
      tree.push(this.expr())
      if (this.tokenStream.error) {
        return {
          error: this.tokenStream.error,
        }
      }
    }
    return tree
  }

  expr() {
    let token = this.tokenStream.peek()
    switch (token.type) {
      case tokenTypes.ATTRIBUTE:
        return this.attribute()
      case tokenTypes.BOOLEAN:
        return this.bool()
      case tokenTypes.IDENTIFIER:
        return this.identifier()
      case tokenTypes.NUMBER:
        return this.number()
      case tokenTypes.QUOTE:
        return this.string()
      case tokenTypes.SYMBOL:
        return this.symbol()
      case tokenTypes.OPAREN:
        return this.form()
      default:
        this.tokenStream.error = `Unexpected ${token.type} on line ${token.line}`
        break;
    }
  }

  form() {
    this.tokenStream.eat(tokenTypes.OPAREN)

    let node = new AST.Application()

    node.functionName = this.identifier()
    node.args = []

    while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
      node.args.push(this.expr())
    }

    this.tokenStream.eat(tokenTypes.CPAREN)

    return node
  }

  attribute() {
    return new AST.Attribute({
      name: this.tokenStream.eat(tokenTypes.ATTRIBUTE).value,
      value: this.expr()
    })
  }

  bool() {
    return new AST.Boolean({
      value: this.tokenStream.eat(tokenTypes.BOOLEAN).value
    })
  }

  identifier() {
    return new AST.Identifier({
      name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value
    })
  }

  number() {
    return new AST.Number({
      value: this.tokenStream.eat(tokenTypes.NUMBER).value
    })
  }

  string() {
    this.tokenStream.eat(tokenTypes.QUOTE)

    let value = ''

    if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
      value = this.tokenStream.eat(tokenTypes.LITERAL).value
    }

    let node = new AST.String({
      value: value
    })

    this.tokenStream.eat(tokenTypes.QUOTE)

    return node
  }

  symbol() {
    return new AST.Symbol({
      value: this.tokenStream.eat(tokenTypes.SYMBOL).value
    })
  }
}