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


const helpers = {
  concat: {
    prepare: () => {
      const e1 = createEnumerable([1, 2, 3])
      const e2 = createEnumerable([10, 20, 30])
      return e1.concat(e2)._enumerator
    },
    expected: FusedEnumerator
  },
  drop: {
    prepare: () => createEnumerable().drop(0)._enumerator,
    expected: DropEnumerator
  },
  filter: {
    prepare: () => createEnumerable().filter(x => x)._enumerator,
    expected: FilterEnumerator
  },
  flatMap: {
    prepare: () => {
      const e = createEnumerable()
      return e.flatMap(() => createEnumerator([1]))._enumerator
    },
    expected: FlatMapEnumerator
  },
  map: {
    prepare: () => createEnumerable().map(x => x)._enumerator,
    expected: MapEnumerator
  },
  take: {
    prepare: () => createEnumerable().take(0)._enumerator,
    expected: TakeEnumerator
  }
}

export const EnumerableFrom = [
  it('from iterator', () => {
    const iterator = createIterator()

    const enumerator = Enumerable.from(iterator)._enumerator
    assert(enumerator instanceof CachedIteratorEnumerator, `${enumerator.constructor.name} is not an instance of 'CachedIterableEnumerator'`)
  }),

  it('from iterable', () => {
    const iterable = createIterable()

    const enumerator = Enumerable.from(iterable)._enumerator._enumerator
    assert(enumerator instanceof IterableEnumerator, `${enumerator.constructor.name} is not an instance of 'IterableEnumerator'`)
  }),

  it('from array', () => {
    const arr = [1, 2, 3]
    const enumerator = Enumerable.from(arr)._enumerator
    assert(enumerator instanceof ArrayEnumerator, `${enumerator.constructor.name} is not an instance of 'ArrayBuffer'`)
  }),

  it('from arraybuffer', () => {
    const ab = new Uint8Array(1)
    const enumerator = Enumerable.from(ab)._enumerator
    assert(enumerator instanceof ArrayEnumerator, `${enumerator.constructor.name} is not an instance of 'ArrayBuffer'`)
  }),

  it('from enumerator', () => {
    const iterable = createIterable()

    const enumerator1 = Enumerator.fromIterable(iterable)
    const enumerable1 = Enumerable.from(enumerator1)
    assert(enumerable1._enumerator._enumerator instanceof IterableEnumerator, `${enumerable1._enumerator._enumerator.constructor.name} is not an instance of IterableEnumerator`)

    const iterator = createIterator()

    const enumerator2 = Enumerator.fromIterator(iterator, false)
    const enumerable2 = Enumerable.from(enumerator2)
    assert(enumerable2._enumerator instanceof IteratorEnumerator, `${enumerable2._enumerator.constructor.name} is not an instance of IteratorEnumerator`)

    const enumerator3 = Enumerator.fromIterator(iterator, true)
    const enumerable3 = Enumerable.from(enumerator3)
    assert(enumerable3._enumerator instanceof CachedIteratorEnumerator, `${enumerable3._enumerator.constructor.name} is not an instance of CachedIteratorEnumerator`)
  }),

  it('from enumerable', () => {
    const enumerator = {
      get current() { return undefined },
      moveNext() { return false },
      reset() { },
    }

    const enumerable1 = new Enumerable(enumerator)
    const enumerable2 = Enumerable.from(enumerable1)
    assertEq(enumerable1, enumerable2)
  }),

  it('from invalid should error', () => {
    const expected = new TypeError('value is not enumerable')

    assertErr(() => {
      Enumerable.from(1)
    }, expected)

    assertErr(() => {
      Enumerable.from(Symbol())
    }, expected)
  })
]

export const EnumerableMethod = [
  it('at', () => {
    const arr = [3, 2, 1]
    const e1 = Enumerable.from(arr)

    const iterator = createIterator(arr)
    const e2 = Enumerable.from(iterator)

    const iterable = createIterator(arr)
    const e3 = Enumerable.from(iterable)

    const enums = [e1, e2, e3]

    enums.forEach(e => {
      arr.forEach((value, index) => {
        assertEq(e.at(index), value)
      })
    })
  }),

  it('atOrDefault', () => {
    const arr = [3]
    const e = Enumerable.from(arr)
    assertEq(e.atOrDefault(0, 12), 3)
    assertEq(e.atOrDefault(1, 12), 12)
  }),

  it('atOrElse', () => {
    const arr = [3]
    const e = Enumerable.from(arr)
    const orElse = () => 12
    assertEq(e.atOrElse(0, orElse), 3)
    assertEq(e.atOrElse(1, orElse), 12)
  }),

  it('enumerator', () => {
    assert(
      Enumerable.from([]).enumerator() instanceof ArrayEnumerator
    )
  }),

  it('every', () => {
    const e = Enumerable.from([1, 1, 1])

    assert(e.every(n => Number.isInteger(n)), `${e.toString()}.every failed`)
    assert(!e.every(n => n > 1), `${e.toString()}.every passed when it should have failed`)
  }),

  it('enumerator helpers', () => {
    Object.entries(helpers).forEach(([name, { prepare, expected }]) => {
      const enumerator = prepare()
      assert(enumerator instanceof expected, `Enumerable.${name}(): ${enumerator.constructor.name} is not an instance of ${expected.name}`)
    })
  }),

  it('some', () => {
    const e = createEnumerable([1, 2, 3])

    assert(e.some(n => n === 1), `${e.toString()}.some failed`)
    assert(!e.some(n => n === 4), `${e.toString()}.some passed when it should have failed`)
  })
]