import { it, assert, assertEq } from 'folktest'
import { char, charNoCase, noneOf, oneOf, parse, tag, tagNoCase, take, takeWhile } from '../../src/index.js'
import { Alphanumeric } from '../../src/const.js'
import { chain, curry, map } from 'izuna'

const assertState = expected => state => {
  assertEq(expected, state[0])
}

const parseEq = curry((parser, input, expected) =>
  chain(assertState(expected), parse(parser, input))
)

const parseErr = curry((parser, input) =>
  assert(parse(parser, input).isErr(), `expected an error but "${input}" parsed successfully`)
)

export const Byte = [
  it('char', () => {
    const parser = char('a')

    parseEq(parser, 'abc', ['a'])
    assert(parse(parser, ' abc').isErr())
    assert(parse(parser, 'bc').isErr())
    assert(parse(parser, '').isErr())
  }),

  it('oneOf', () => {
    parse(oneOf('abc'), 'b').chain(assertState('b'))
    assert(parse(oneOf('a'), 'bc').isErr())
    assert(parse(oneOf('a'), '').isErr())
  }),

  it('noneOf', () => {
    parse(noneOf('abc'), 'z').chain(assertState(['z']))
    assert(parse(noneOf('ab'), 'a').isErr())
    assert(parse(noneOf('ab'), '').isErr())
  }),

  it('tag', () => {
    const parser = tag('Hello')
    parse(parser, 'Hello, World!').chain(assertState(['Hello']))
    assert(parse(parser, 'Something').isErr())
    assert(parse(parser, '').isErr())
  }),

  it('charNoCase', () => {
    const parser = charNoCase('a')
    parse(parser, 'abc').chain(assertState(['a']))
    parse(parser, 'Abc').chain(assertState(['A']))
    assert(parse(parser, ' abc').isErr())
    assert(parse(parser, 'bc').isErr())
    assert(parse(parser, '').isErr())
  }),

  it('tagNoCase', () => {
    const parser = tagNoCase('hello')
    parse(parser, 'Hello, World!').chain(assertState(['Hello']))
    parse(parser, 'hello, World!').chain(assertState(['hello']))
    parse(parser, 'HeLlO, World!').chain(assertState(['HeLlO']))
    assert(parse(parser, 'Something').isErr())
    assert(parse(parser, '').isErr())
  }),

  it('take', () => {
    const parser = take(6)
    parse(parser, '1234567').chain(assertState('123456'.split('')))
    parse(parser, 'things').chain(assertState('things'.split('')))
    assert(parse(parser, 'short').isErr())
    assert(parse(parser, '').isErr())
  }),

  it('takeWhile', () => {
    const parser = takeWhile(x => Alphanumeric.includes(x))
    parse(parser, 'latin123').chain(assertState(['latin']))
    parse(parser, '123').chain(assertState([]))
    parse(parser, 'latin').chain(assertState(['latin']))
    parse(parser, '').chain(assertState([]))
  })
]