import { isFunction, isString, isObj, isTrue, isFalse } from '../../is'
import all from '../../conditional/all'
import or from '../../conditional/or'
import and from '../../conditional/and'
import not from '../../conditional/not'
import some from '../../conditional/some'
import eq from '../../conditional/eq'
import includes from '../../conditional/includes/haystackNeedle'
import includesAll from '../../conditional/includes/all'
import includesAny from '../../conditional/includes/any'
import stress from '../../../jest/_stress'

test('all', () => {
  expect(all(isTrue)([true, true])).toBe(true)
  expect(all(isTrue)([true, false])).toBe(false)
  expect(all(isTrue)([false, false])).toBe(false)
  expect(all(isString)(['string', false])).toBe(false)
  stress(all)
})

test('some', () => {
  expect(some(isTrue)([true, true])).toBe(true)
  expect(some(isTrue)([true, false])).toBe(true)
  expect(some(isTrue)([false, false])).toBe(false)
  expect(some(isString)(['string', false])).toBe(true)
  expect(some(isString)(['string', 'string'])).toBe(true)
  stress(some)
})

test('or', () => {
  expect(or(isTrue, isFalse)(true)).toBe(true)
  expect(or(isTrue, isFalse)(false)).toBe(true)
  expect(or(isTrue, isString)('string')).toBe(true)
  expect(or(isTrue, isString)(false)).toBe(false)
  stress(or)
})

test('and', () => {
  expect(and(isObj, isFunction)(() => {})).toBe(true)
  expect(and(isObj, isFunction)({})).toBe(false)
  expect(and(isObj, isFunction)(false)).toBe(false)
  stress(and)
})

test('and', () => {
  expect(and(isObj, not(isFunction))({})).toBe(true)
  expect(and(isTrue, not(isString))(true)).toBe(true)
  expect(not(isString)(true)).toBe(true)
  expect(not(isTrue)(false)).toBe(true)

  expect(and(isObj, not(isFunction))(() => {})).toBe(false)
  expect(not(isTrue)(true)).toBe(false)
  stress(not)
})

test('eq', () => {
  expect(eq('number')('number')).toBe(true)
  expect(eq('true')('true')).toBe(true)
  expect(eq(true)(true)).toBe(true)
  expect(eq(null)(null)).toBe(true)
  expect(eq(false)(null)).toBe(false)
  expect(eq('true')(null)).toBe(false)
  stress(eq)
})

test('includes', () => {
  expect(includes('haystack', 'needle')).toBe(false)
  expect(includes('haystack', 'haystack')).toBe(true)
  expect(includes('haystack', 'hay')).toBe(true)
  expect(includes(['haystack'], 'haystack')).toBe(true)
  expect(includes(['haystack'], 'hay')).toBe(false)
  // stress(includes)
})
test('includesAll', () => {
  expect(includesAll('hay', 'hay')).toBe(true)
  expect(includesAll(['any'], 'any')).toBe(true)
  expect(includesAll(['none'], 'any')).toBe(false)
  // stress(includesAll)
})
test('includesAny', () => {
  expect(includesAny('hay', 'hay')).toBe(true)
  expect(includesAny(['any'], 'any')).toBe(true)
  expect(includesAny(['none'], 'any')).toBe(false)
  expect(includesAny('none', 'any')).toBe(false)
  // was marked rom anyOrAll but removed
  expect(includesAny('hay'.split(''), 'hay')).toBe(true)
  expect(includesAny('any'.split(''), 'any')).toBe(true)

  // has `n`
  expect(includesAny(['n', '0', 'n', 'e'], 'any')).toBe(true)
  // stress(includesAnyOrAll)
  // stress(includesAny)
})