import { types } from 'xmobx/mobx-state-tree'
// import { Typed } from 'modules/modeler'
// import { forOwn, uniq } from 'chain'
import {
  toEmpty,
  isNumberish,
  isMap,
  toKindOf,
  isPrimitive,
  isFrozen,
  isObj,
  isArray,
  isFunction,
  isNumber,
  isBoolean,
  isString,
  toBoolean,
  toString,
  toNumber,
  toArray,
  toObject,
} from 'exotic'
import 'modules/thisless/statetree'
import { selfless, thisless } from 'modules/thisless'
import UniqueDictionary from './UniqueDictionary'
import { bindToSelf } from './deps/bindToSelf'

const { boolean, number, string, array, map, model } = types
const { identifier, frozen } = types
const { optional, maybe } = types
const { late, reference } = types
const { compose, union, refinement, literal, enumeration } = types
const date = types.Date

// .named('nil')
const nil = union(types.null, types.undefined)
const any = union(types.boolean, types.number, types.string)

const isAny = x => isPrimitive(x)
const looseyType = {
  name: 'primitiveloosey',
  // flags: TypeFlags
  is: isAny,
  // thing: any, context: IContext): IValidationResult
  validate: isAny,
  // create(snapshot?: S, environment?: any): T
  isType: true,
  describe: 'better',

  // Type: T
  // SnapshotType: S
  // Internal api's
  // instantiate(parent: Node | null, subpath: string, environment: any, initialValue?: any): Node
  // reconcile(current: Node, newValue: any): Node
  // getValue(node: Node): T
  // getSnapshot(node: Node): S
  // applySnapshot(node: Node, snapshot: S): void
  // applyPatchLocally(node: Node, subpath: string, patch: IJsonPatch): void
  // getChildren(node: Node): Node[]
  // getChildNode(node: Node, key: string): Node
  // getChildType(key: string): IType<any, any>
  // removeChild(node: Node, subpath: string): void
  // isAssignableFrom(type: IType<any, any>): boolean
}
const loosy = union(string, number, boolean)
const stateString = refinement(loosy, x => isString(x) || true)
const stateNumber = refinement(loosy, x => isNumberish(x) || true)
const stateBoolean = refinement(loosy, x => isBoolean(x) || true)
// const stateIdentity = types.refinement(types.identity, isId)
// const stateSymbol = types.refinement
// const stateArray = types.refinement(types.array, isArrayLike)

// https://github.com/mobxjs/mobx-state-tree/blob/master/API.md#typesrefinement
// @TODO shoulduse reference type, and start bottom up?
const toMobModel = (x, name) =>
  (name ? model().named(name).props(x) : model().props(x))
const toMobArray = x => maybe(array(maybe(x)))
const toMobArrayModel = (x, name) => toMobArray(toMobModel(x, name))
const toMobString = x => optional(stateString, () => x)
const toMobBoolean = x => optional(stateBoolean, () => x)
const toMobNumber = x => optional(stateNumber, () => x)
const toMobFrozen = x => frozen // (x)
const toMobDate = x => date(x)
const toMobSet = (x, name) => set(x).named(name)
const toMobIdentity = x => identifier(x)
const toMobMap = _toMobx => (x, name) => {
  const keys = Array.from(x.keys())
  const obj = x.get(keys[0])
  const objSchema = _toMobx(obj, name)
  return map(objSchema)
}
const toMobLate = x => late(x)

// @UGH annoying thing forgot how I overcame this in the state-tree, some kind of refinement
// annoying thing
const toMobArrayOfAny = (x, name = undefined) => {
  // const arrayOfX = types.array(x)

  // const maybeArrayOfX = types.compose(types.reference(arrayOfX), emptyArrayType)
  const valueX = types.union(
    x,
    any
    // types.literal([])
  )
  const maybeArrayOfX = array(
    optional(maybe(valueX), undefined)
  )

  return maybeArrayOfX
}

export { any, nil, date }
export {
  number, string, array, boolean,
  identifier, frozen, late,
  optional, maybe, model,
  compose, union, refinement,
  literal, enumeration, reference,
}

export {
  toMobArrayOfAny,
  toMobArray,
  toMobModel,
  toMobArrayModel,
  toMobString,
  toMobBoolean,
  toMobNumber,
  toMobFrozen,
  toMobDate,
  toMobSet,
  toMobIdentity,
  toMobLate,
  toMobMap,
  looseyType,
}