import { assert, assertEq, it } from 'folktest'
import { createIterator, createIterable, createEnumerator, createEnumerable } from './common.js'
import { CachedIteratorEnumerator, DropEnumerator, Enumerator, FilterEnumerator, FlatMapEnumerator, FusedEnumerator, IterableEnumerator, IteratorEnumerator, MapEnumerator, TakeEnumerator } from '../../dist/index.esm.min.js'

export const EnumeratorFrom = [
  it('from iterator', () => {
    const iterator = createIterator()
    const enumerator1 = Enumerator.fromIterator(iterator)
    assert(enumerator1 instanceof CachedIteratorEnumerator)

    const enumerator2 = Enumerator.fromIterator(iterator, false)
    assert(enumerator2 instanceof IteratorEnumerator)
  }),

  it('from iterable', () => {
    const iterable = createIterable()
    const enumerator = Enumerator.fromIterable(iterable)._enumerator
    assert(enumerator instanceof IterableEnumerator, `${enumerator.constructor.name} is not instance of 'IterableEnumerator'`)
  })
]

export const HelperEnumerator = [
  it('FusedEnumerator', () => {
    const expected = [1, 2, 3, 10, 20, 30]
    const e1 = createEnumerator([1, 2, 3])
    const e2 = createEnumerator([10, 20, 30])
    const fe = new FusedEnumerator([e1, e2])
    expected.forEach(n => {
      fe.moveNext()
      assertEq(fe.current, n)
    })
  }),

  it('DropEnumerator', () => {
    const expected = [4, 5, 6]
    const e = new DropEnumerator(createEnumerator([1, 2, 3, 4, 5, 6]), 3)
    expected.forEach(n => {
      e.moveNext()
      assertEq(e.current, n)
    })
  }),

  it('FilterEnumerator', () => {
    const expected = [1, 3, 5]
    const e = new FilterEnumerator(createEnumerator([1, 2, 3, 4, 5, 6]), x => x % 2 !== 0)
    expected.forEach(n => {
      e.moveNext()
      assertEq(e.current, n)
    })
  }),

  it('FlatMapEnumerator', () => {
    const expected = [1, 2, 2, 3, 3, 3]
    const e = new FlatMapEnumerator(
      createEnumerator([1, 2, 3]),
      n => {
        const arr = Array.from({ length: n }).fill(n)
        return createEnumerator(arr)
      }
    )

    expected.forEach(n => {
      e.moveNext()
      assertEq(e.current, n)
    })
  }),

  it('MapEnumerator', () => {
    const expected = [1, 4, 9]
    const e = new MapEnumerator(createEnumerator([1, 2, 3]), n => n * n)
    expected.forEach(n => {
      e.moveNext()
      assertEq(e.current, n)
    })
  }),

  it('TakeEnumerator', () => {
    const expected = [1, 2, 3]
    const e = new TakeEnumerator(createEnumerator([1, 2, 3, 4, 5, 6]), 3)
    expected.forEach(n => {
      e.moveNext()
      assertEq(e.current, n)
    })
  })
]