const R = require('ramda')
const {
  toSpecies,
  cast,
  is,
  isBuiltIn,
  isNative,
  isNotEmpty,
  isSafe,
} = require('exotic')
const {
  isAction,
  isComputed,
  isBoxedObservable,
  isObservable,
  isObservableArray,
  isObservableObject,
  isObservableMap,
} = require('xmobx/mobx')
const consoleHACK = require('../../src/bootstrapper/setup/console')

require('@skava/modules/___dist/polyfil/console')

const {
  isFrozen,
  isSealed,
  toKindOf,
  isTypeEq,
  isType,
  isArguments,
  isPairs,
  isArrayOf,
  isArrayLike,
  isAsyncish,
  isArray,
  isArrayTyped,
  isArrayBuffer,
  isAsync,
  isBoolean,
  isBooleanPrimitive,
  isBooleanLike,
  isBrowser,
  isCircular,
  isCollection,
  isClass,
  isDate,
  isDataView,
  isDot,
  isError,
  isEnumerable,
  isElement,
  isEmpty,
  isExtensible,
  isFunction,
  isFalse,
  isFalsy,
  isFlattenable,
  isFinite,
  isGenerator,
  // not named is
  hasIn,
  ownPropertyIs,
  // back to it
  isNegativeInfinity,
  isIterator,
  isIn,
  isInfinity,
  isIteratable,
  isIndexable,
  isInstanceOf,
  isInteger,
  isJSON,
  isMatcher,
  isMap,
  isMapish,
  isMatch,
  isMatchWith,
  isNil,
  isNull,
  isNumber,
  isNumberPrimitive,
  isNumberish,
  isNumberishWithDecimals,
  isNaN,
  isNodeJS,
  isObj,
  isObjTag,
  isObjTypeof,
  isObjPure,
  isObjWithKeys,
  isObjNotNull,
  isObjPlain,
  isPrimitive,
  isPromise,
  isPrototypeOf,
  isRegExp,
  isReal,
  isSize,
  isStringOrNumber,
  isInfinite,
  isString,
  isSet,
  isSymbol,
  isTrue,
  isUndefined,
  isUndefinedLike,
  isUnsignedInteger,
  isURL,
  isValidArrayIndex,
  isValidIndex,
  isValidPropertyKey,
  isWeakMap,
  isWeakMapUsable,
  isWeakSet,
  isWebWorker,
  isZeroish,
  hasDecimals,
} = is

// @TODO test setup
// const stringify = x => JSON.stringify(x, null, 2)
const stringify = x => R.toString(x)

/**
 * @param {Function} predicate
 * @param {String} key
 * @param {String | Function | undefined} passMsg
 * @param {String | Function | undefined} failMsg
 */
const extend = (predicate, key, passMsg, failMsg) => {
  expect.extend({
    [key](received, expected) {
      const pass = predicate(received, expected)
      if (pass) {
        return {
          message: () =>
            isFunction(passMsg)
              ? passMsg(received, predicate)
              : passMsg ||
                `${key} pass; received: ${stringify(
                  received
                )}, expected: ${expected}`,
          pass: true,
        }
      } else {
        return {
          message: () =>
            isFunction(failMsg)
              ? failMsg(received, predicate)
              : failMsg ||
                `${key} fail; received: ${stringify(
                  received
                )}, expected: ${expected}`,
          pass: false,
        }
      }
    },
  })
}

const isSpecies = (received, expected) => {
  // when we use `is`
  if (typeof expected === 'function' && expected !== Function) {
    return expected(received)
  }

  // console.log(Typed(expected))
  return Typed(expected).is(received)
  // console.log(Typed(expected))
  if (isBuiltIn(expected)) {
    // console.log(Typed(expected))
    return Typed(expected).is(received)
  } else {
    return false
  }
}

// console.log('@TODO .at(index | prop).toBe')

const allAre = (received, expected) => {
  return received.every(value => isSpecies(value, expected))
}

// extend(fn, 'check')
// function fn() {
//   console.log(arguments)
//   return true
// }

const has = (received, expected) => {
  if (isCollection(received)) {
    return received.has(expected)
  }
  return hasIn(received, expected)
}

extend(has, 'has')
extend(hasIn, 'toHaveIn')
// extend(beKind, 'toBeKind')
// extend(beKind, 'toBeType')
extend(isSpecies, 'toBeSpecies')
extend(isSpecies, 'is')
extend(allAre, 'allAre')
extend(isArguments, 'toBeArguments')
extend(isPairs, 'toBePairs')
extend(isArray, 'toBeArray')
extend(isAsync, 'toBeAsync')
extend(isBooleanLike, 'toBeBoolean')
extend(isDate, 'toBeDate')
extend(isError, 'toBeError')
extend(isEmpty, 'toBeEmpty')
extend(isFunction, 'toBeFunction')
extend(isGenerator, 'toBeGenerator')
extend(isInfinite, 'toBeInfinite')
extend(isExtensible, 'toBeExtensible')
extend(isPrimitive, 'toBePrimitive')
extend(isEnumerable, 'toBeEnumerable')
extend(isInstanceOf, 'toBeInstanceOf')
extend(isNaN, 'toBeNaN')
extend(isNil, 'toBeNull')
extend(isNil, 'toBeNil')
extend(isNumber, 'toBeNumber')
extend(isReal, 'toBeReal')
extend(isSymbol, 'toBeSymbol')
extend(isZeroish, 'toBeZero')
extend(isFalse, 'false')
extend(isTrue, 'true')
extend(isRegExp, 'toBeRegExp')
extend(isString, 'toBeString')
extend(isObj, 'toBeObj')
extend(isObj, 'toBeFlattenable')
extend(hasDecimals, 'toBeFloat')
extend(isArrayTyped, 'toBeTypedArray')
extend(isWeakSet, 'toBeWeakSet')
extend(isWeakMap, 'toBeWeakMap')
extend(isSet, 'toBeSet')
extend(isMap, 'toBeMap')
extend(isCollection, 'toBeCollection')
extend(isSize, 'toBeSize')
extend(isFrozen, 'toBeFrozen')
extend(isSealed, 'toBeSealed')

// alias as is
extend(isSpecies, 'isSpecies')
extend(isArguments, 'isArguments')
extend(isPairs, 'isPairs')
extend(isArray, 'isArray')
extend(isAsync, 'isAsync')
extend(isBooleanLike, 'isBoolean')
extend(isDate, 'isDate')
extend(isError, 'isError')
extend(isEmpty, 'isEmpty')
extend(isFunction, 'isFunction')
extend(isGenerator, 'isGenerator')
extend(isInfinite, 'isInfinite')
extend(isExtensible, 'isExtensible')
extend(isPrimitive, 'isPrimitive')
extend(isEnumerable, 'isEnumerable')
extend(isInstanceOf, 'isInstanceOf')
extend(isNaN, 'isNaN')
extend(isNil, 'isNull')
extend(isNil, 'isNil')
extend(isNumber, 'isNumber')
extend(isReal, 'isReal')
extend(isSymbol, 'isSymbol')
extend(isZeroish, 'isZero')
extend(isFalse, 'isFalse')
extend(isTrue, 'isTrue')
extend(isRegExp, 'isRegExp')
extend(isString, 'isString')
extend(isObj, 'isObj')
extend(isObj, 'isFlattenable')
extend(hasDecimals, 'isFloat')
extend(isArrayTyped, 'isTypedArray')
extend(isWeakSet, 'isWeakSet')
extend(isWeakMap, 'isWeakMap')
extend(isSet, 'isSet')
extend(isMap, 'isMap')
extend(isCollection, 'isCollection')
extend(isSize, 'isSize')
extend(isFrozen, 'isFrozen')
extend(isSealed, 'isSealed')
//
extend(isSafe, 'isSafe')
extend(isNotEmpty, 'isNotEmpty')
//
extend(isAction, 'isAction')
// extend(isStrictModeEnabled, 'isStrictModeEnabled')
// extend(isModifierDescriptor, 'isModifierDescriptor')
extend(isComputed, 'isComputed')
extend(isBoxedObservable, 'isBoxedObservable')
extend(isObservable, 'isObservable')
extend(isObservableArray, 'isObservableArray')
extend(isObservableObject, 'isObservableObject')
extend(isObservableMap, 'isObservableMap')
// extend(isPromiseBasedObservable, 'isPromiseBasedObservable')
//
extend(isStringOrNumber, 'isStringOrNumber')
extend(isUndefined, 'isUndefined')
extend(isUndefinedLike, 'isUndefinedLike')
extend(isURL, 'isURL')
extend(isValidArrayIndex, 'isValidArrayIndex')