/// <reference path="../atom/types.d.ts" />
/// <reference path="../nucleus/types.d.ts" />
/// <reference path="../../atom/types/base.d.ts" />

type CanBeArray<T> = T | Array<T>
type ActionsAndN<T> = CanBeArray<GetValues<T> | GetActions<T>>

type IModelCore<Model> = Atomized<PureState<Instance<Model>>> & OnlyFunc<Instance<Model>>
type IModelState<Model> = PureState<Instance<Model>>
type INucleusInitEventData = {
  rune?: any
  nucleus: INucleus<any>
}

type INucleusChangeEventData = {
  value: any
  key: string
  atomId: string
  nucleus: INucleus<any>
}

type IAtomLifeCycleEventData = {
  name: string
  atom: IUnionAtom<any, any>
}

type IAlakCoreEvents = {
  UNION_ATOM_DECAY: IAtomLifeCycleEventData
  ATOM_INIT: IAtomLifeCycleEventData
  NUCLEUS_CHANGE: INucleusChangeEventData
  NUCLEUS_INIT: INucleusInitEventData
}

interface IUnionAtom<Model, Events extends object> {
  readonly state: IModelState<Model>
  readonly core: OnlyPublicKeys<IModelCore<Model>>
  readonly actions: OnlyPublicKeys<OnlyFunc<Instance<Model>>>
  readonly bus: IQuarkBus<IAlakCoreEvents & Events, Events>
  readonly known: IAtomKnown<Model>

  decay(): void
}

type QuantumAtom = {
  id?: any
  name: string
  data?: any
  bus?: IQuarkBus<any, any>
  union: IUnionCore<any, any, any, any>
  atom?: IAtom<any>
  eventListeners?: string[]
}

type IAlakAtomFactory<M, E extends Object> = {
  get(id: string | number, target?: any): IUnionAtom<M, E>
  delete(id: string | number): void
  readonly broadcast: IModelCore<M>
  readonly bus: IQuarkBus<IAlakCoreEvents & E, E>
}
type IStartupStrategy = 'lazy' | 'immediately'

interface IAlakConstructor<Model, E, N> {
  name: string
  namespace?: string
  model?: Model
  nucleusStrategy?: NucleusStrategy

  emitChanges?: boolean
  startup?: IStartupStrategy

  globalBus?: boolean
  disableSpringModel?: boolean
}
type IUnionSynthesis<M, F, S, E extends object> = {
  namespace?: string
  models?: M
  factories?: F
  events?: E
  services?: S
  emitChanges?: boolean
}

interface IUnionCoreService<Models, Factory, Events extends object> {
  readonly atoms: { [K in keyof Models]: IUnionAtom<Models[K], Events> }
  readonly bus: IQuarkBus<IAlakCoreEvents & Events, Events>
  readonly _injector: any
  readonly ns: string
}

type IFAInjector<O, N extends string> = {
  [K in keyof O as `${Capitalize<string & K>}${N}`]: O[K]
}

type IFUnionInjector<Models, Factory, Events extends object> = {
  [K in keyof (Models & Factory) as `${Capitalize<string & K>}Atom`]: (IAtomicModels<
    Models,
    Events
  > &
    IAtomicFactory<Factory, Events>)[K]
} & {
  [K in keyof Models as `${Capitalize<string & K>}Core`]: IAtomCore<Instance<Models[K]>>
} & {
  [K in keyof Models as `${Capitalize<string & K>}State`]: IModelState<Models[K]>
} & {
  [K in keyof Models as `${Capitalize<string & K>}Bus`]: IQuarkBus<IAlakCoreEvents & Events, Events>
}

type IUnionCore<Models, Factory, Services, Events extends object> = {
  readonly addAtom<M>(c:IAlakConstructor<M, any, N>):IAtom<M>
  readonly facade: IUnionFacade<Models, Factory, Events> & Services
  readonly services: IUnionCoreService<Models, Factory, Events>
  readonly bus: IQuarkBus<IAlakCoreEvents & Events, Events>
}

// type IUnionDevCore = IUnionCore<any, any, any, any>

type IAtomicModels<Models, E extends object> = {
  [K in keyof Models]: IUnionAtom<Models[K], E>
}

type IAtomicFactory<F, E> = {
  [K in keyof F]: IAlakAtomFactory<F[K], E>
}

type IUnionFacade<Models, Factory, Events extends object> = {
  readonly atoms: IAtomicModels<Models, Events> & IAtomicFactory<Factory, Events>
  readonly cores: { [K in keyof Models]: IAtomCore<Instance<Models[K]>> }
  readonly states: { [K in keyof Models]: IModelState<Models[K]> }
  readonly buses: { [K in keyof Models]: IQuarkBus<IAlakCoreEvents & Events, Events> }
  readonly bus: IQuarkBus<IAlakCoreEvents & Events, Events>
} & IFUnionInjector<Models, Factory, Events>