import {
  binaryTweenPipeAtom,
  combineT,
  useGeneralDriver
} from './libs/mobius-utils'
import { storageConnectorDriver } from './storage-connector'
import { processDispatcherDriver } from './process-dispatcher'
import { recordContainerDriver } from './record-container'
import { updateContainerDriver } from './update-container'
import { recordManagerDriver } from './record-manager'
import { updateManagerDriver } from './update-manager'
import { INTERNAL_STORAGE_DRIVERS } from './storages/index'

export const tagletLauncherDriver = (options = {}) => {
  const { storage = {}, connector = {}, uuidGenerator } = options

  /*********************************************************************************************************************
   *                                                  初始化各模块实例
   * - DI -> aka. DriverInstance
   *********************************************************************************************************************/

  const storageConnectorDI = storageConnectorDriver({ ...connector })
  const processDispatcherDI = processDispatcherDriver({})
  const recordContainerDI = recordContainerDriver({})
  const updateContainerDI = updateContainerDriver({})
  const recordManagerDI = recordManagerDriver({})
  const updateManagerDI = updateManagerDriver({ uuidGenerator })

  /*********************************************************************************************************************
   *                                                建立模块与调度器之间的通讯
   *********************************************************************************************************************/

  binaryTweenPipeAtom(combineT({
    recordContainer: recordContainerDI.outputs.executeStatus,
    updateContainer: updateContainerDI.outputs.executeStatus,
    recordManager: recordManagerDI.outputs.executeStatus,
    updateManager: updateManagerDI.outputs.executeStatus
  }), processDispatcherDI.inputs.executeStatus)
  binaryTweenPipeAtom(processDispatcherDI.outputs.process, recordContainerDI.inputs.process)
  binaryTweenPipeAtom(processDispatcherDI.outputs.process, updateContainerDI.inputs.process)
  binaryTweenPipeAtom(processDispatcherDI.outputs.process, recordManagerDI.inputs.process)
  binaryTweenPipeAtom(processDispatcherDI.outputs.process, updateManagerDI.inputs.process)

  /*********************************************************************************************************************
   *                                                     数据初始化
   *********************************************************************************************************************/

  binaryTweenPipeAtom(storageConnectorDI.outputs.runtimeRecords, recordContainerDI.inputs.records)
  binaryTweenPipeAtom(storageConnectorDI.outputs.runtimeUpdates, updateContainerDI.inputs.updates)
  binaryTweenPipeAtom(recordContainerDI.outputs.records, storageConnectorDI.inputs.runtimeRecords)
  binaryTweenPipeAtom(updateContainerDI.outputs.updates, storageConnectorDI.inputs.runtimeUpdates)

  // TODO: 有效性检验模块，检验 records 和 updates 是否匹配

  /*********************************************************************************************************************
   *                                                   更新的核心流程
   *********************************************************************************************************************/

  binaryTweenPipeAtom(updateManagerDI.outputs.updateDetail, recordManagerDI.inputs.updateDetail)

  binaryTweenPipeAtom(recordManagerDI.outputs.collectRequest, recordContainerDI.inputs.collectRequest)
  binaryTweenPipeAtom(recordContainerDI.outputs.collectResult, recordManagerDI.inputs.collectResult)
  binaryTweenPipeAtom(recordManagerDI.outputs.updateResult, recordContainerDI.inputs.acceptRequest)
  binaryTweenPipeAtom(recordContainerDI.outputs.acceptResult, recordManagerDI.inputs.acceptResult)

  binaryTweenPipeAtom(recordManagerDI.outputs.updateSummary, updateManagerDI.inputs.updateSummary)

  binaryTweenPipeAtom(updateManagerDI.outputs.collectRequest, updateContainerDI.inputs.collectRequest)
  binaryTweenPipeAtom(updateContainerDI.outputs.collectResult, updateManagerDI.inputs.collectResult)
  binaryTweenPipeAtom(updateManagerDI.outputs.updateItems, updateContainerDI.inputs.updateItems)
  binaryTweenPipeAtom(updateContainerDI.outputs.acceptResult, updateManagerDI.inputs.acceptResult)

  /*********************************************************************************************************************
   *                                                    连接数据存储
   *********************************************************************************************************************/

  const connectStorage = (storageOptions, storageConnectorDI) => {
    const {
      type = 'mock',
      storageDriverInstance = undefined, storageDriver = undefined,
      options = {}
    } = storageOptions

    if (!Object.keys(INTERNAL_STORAGE_DRIVERS).includes(type) && type !== 'custom') {
      throw (new Error(`There is no storageDriver of type "${type}" in INTERNAL_STORAGE_DRIVERS.`))
    }
    if (type === 'custom' && !storageDriverInstance && !storageDriver) {
      throw (new Error('At least one of "storageDriverInstance" and "storageDriver" is required when type specified to "custom".'))
    }

    let storageDI
    if (type === 'custom') {
      storageDI = storageDriverInstance || storageDriver(options)
    } else {
      storageDI = INTERNAL_STORAGE_DRIVERS[type](options)
    }

    binaryTweenPipeAtom(storageDI.outputs.records, storageConnectorDI.inputs.storageRecords)
    binaryTweenPipeAtom(storageDI.outputs.updates, storageConnectorDI.inputs.storageUpdates)
    binaryTweenPipeAtom(storageConnectorDI.outputs.storageRecords, storageDI.inputs.records)
    binaryTweenPipeAtom(storageConnectorDI.outputs.storageUpdates, storageDI.inputs.updates)
  }
  connectStorage(storage, storageConnectorDI)

  return {
    inputs: {
      records: storageConnectorDI.inputs.records,
      updates: storageConnectorDI.inputs.updates,
      updateRequest: updateManagerDI.inputs.updateRequest
    },
    outputs: {},
    others: {
      storageConnector: storageConnectorDI,
      recordContainer: recordContainerDI,
      updateContainer: updateContainerDI,
      recordManager: recordManagerDI,
      updateManager: updateManagerDI
    }
  }
}

export const useTagletLauncherDriver = useGeneralDriver(tagletLauncherDriver)