import { Text, useMessage } from 'alemonjs'
export const selects = onSelects(['message.create'])
export default onResponse(selects, event => {
  const [message] = useMessage(event)
  // useSends 和 useSend 将废弃
  message.send(format(Text('Hello Word!')))
})

import { Text, useMessage } from 'alemonjs'
export const selects = onSelects(['message.create'])
export default onResponse(selects, event => {
  const [subscribe] = useSubscribe(event, selects)
  subscribe.monut(Res.current, ['UserId']) // res 响应之前

  // more ...
  subscribe.create(Res.current, []) // res 创建之后
  subscribe.unmonut(Res.current, []) // res 响应之后
})

import { createSelects } from 'alemonjs'
export const selects = createSelects(['message.create'])

export const selects = onSelects(['message.create'])

// 创建观察者
const [_, observer] = useSubscribe(event, selects)

import { Text, useSends } from 'alemonjs'
export const selects = onSelects(['message.create'])
export default onResponse(selects, event => {
  const [send] = useSend(event)
  send(format(Text('Hello Word!')))
})

import { createSelects } from 'alemonjs'
export const selects = createSelects(['message.create'])
// 仅限 # 和 / 开头的消息才执行该中间件
export const regular = /^(#|\/)/
export default onMiddleware(selects, (event, next) => {
  next()
})

import { createSelects } from 'alemonjs'
export const selects = createSelects(['message.create'])
export default onResponse(selects, event => {
  const res = {
    // any
  }
  return {
    // 允许分组，等同于 return true
    allowGrouping: true,
    // 即将要发送的数据
    data: [],
    ...res
  }
})

import { Logger, logger as log } from 'alemonjs'
const logger = new Logger().value // 同 logger as log

import { Response } from 'alemonjs'
// 内部所有的res索引
const res = new Response().value

import { Middleware } from 'alemonjs'
// 内部所有的mws索引
const res = new Middleware().value

import { SubscribeList } from 'alemonjs'
// 所有的 create + message.create 订阅
// 即 onSubscribe
const subscribeList = new SubscribeList(
  'create',
  'message.create'
).value
// const subscribeList = new SubscribeList('mount', 'message.create').value
// const subscribeList = new SubscribeList('unmount', 'message.create').value

import { StateSubscribe } from 'alemonjs'
const stateList = new StateSubscribe(
  'create',
  'message.create'
)
stateList.on(() => {}) // onState
stateList.un(() => {}) // unState
const stateSubscribe = stateList.value

import { State } from 'alemonjs'
// 即 useState
const stateList = new State('main:res:name') // new State('main:apps:name')
stateList.value = true // 设置为 true
stateList.value = false // 设置为 false

import { ChildrenApp } from 'alemonjs'
// 默认 main。
// 得到内部res、mw、周期等
const app = new ChildrenApp('main')?.value

import { sendToChannel, sendToUser, Text } from 'alemonjs'
// 向指定频道发送消息
sendToChannel('ChannelID', [Text('hello word')])
// 向指定用户发送消息
sendToUser('UserID', [Text('hello word')])

import { createDataFormat } from 'alemonjs'

const data = createDataFormat(Text('hello word'))

// 例1
sendToChannel('ChannelID', data)

// 例2
Send(...data)

import { ImageURL, useSend } from 'alemonjs'
const Send = useSend({})
// 网络图片地址
Send(ImageURL('https://xxx.yyy.com/image.png'))

import { ImageFile, useSend } from 'alemonjs'
import img_url from '@src/asstes/test.png'
const Send = useSend({})
// 本地图片地址
Send(ImageFile(img_url))

class Node<T> {
  data: T // 节点数据
  next: Node<T> | null // 指向下一个节点的指针
  constructor(data: T) {
    this.data = data
    this.next = null
  }
}

export class SinglyLinkedList<T> {
  private head: Node<T> | null // 链表的头节点
  private size: number // 链表的大小
  private current: Node<T> | null // 当前节点指针
  constructor(initialValues?: T[]) {}
}

export name = 'login'
export const regular = /^(#|\/)?login$/
export default OnResponse((event, next) => {
  // login code ...
}, 'message.create')

import { Text, useSend, useState } from 'alemonjs'
export const regular = /^(#|\/)?close:/
export default OnResponse((event, next) => {
  //   /close:login
  const name = event.MessageText.replace(regular, '')
  const [state, setState] = useState(name)
  if (state) {
    next()
    return
  }
  setState(false)
  const Send = useSend(event)
  Send(Text('关闭成功'))
  return
}, 'message.create')

import { eventState, unEventState } from 'alemonjs'

const login = state => {}

eventState('login', login)
unEventState('login', login)

const Res = OnResponse((event, next) => {
  console.log('text', event.MessageText)
  // 允许在同组响应中，继续后续的函数
  return true
}, 'message.create')

export default OnResponse(
  [
    // add
    Res.current,
    (event, next) => {
      console.log('完成')
    }
  ],
  'message.create'
)

// 不匹配该正则，自动进行next
export const regular = /^(#|\/)?hello$/
export default OnResponse((event, next) => {
  //
}, 'message.create')

// [事件创建之后，事件被中间件处理之后，事件被处理完成之后,]
const [create, monut, unmonut] = useSubscribe(event, <select event type>)
create(Res.current, [])
// 等同于 Observer ，它正是 SubscribeMount 的简写
monut(Res.current, [])
unmonut(Res.current, [])

const current = async (event, next) => {
  // 当前周期中进行
  next()
  // 下一个周期中进行
  next(true)
  // 下下个周期中进行
  next(true, true)
  // 以此类推
}