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

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))

import { createDataFormat } from 'alemonjs'

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

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

// 例2
Send(...data)

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)
  // 以此类推
}

// OnMiddleware((事件体,控制体)=>消息体,消息类型)
export default OnMiddleware((event, next) => {
  // 新增字段
  event['user_id'] = event.UserId
  // 常用于兼容其他框架或增强event功能
  next()
}, 'message.create')

import { useMention } from 'alemonjs'
export default OnResponse(async (event, next) => {
  if (!/^(#|\/)?test$/.test(event.MessageText)) {
    next()
    return
  }

  const Mentions = await useMention(event)
  if (!Mentions || Mentions.length === 0) {
    return // @ 提及为空
  }

  // 查找用户类型的 @ 提及，且不是 bot
  const User = Mentions.find(item => !item.IsBot)
  if (!User) {
    return // 未找到用户Id
  }

  console.log('User:', User)

  // 处理被AT的用户...
}, 'message.create')

const url = await e.UserAvatar.toURL()