import serverRequest from '../api/scrm/serverRequest'
import servicesSendMsg from '../services/sendMsg'
import commonData from '../store/data'
import { formatJSONString } from '../utils/index'

// 通过接口获取要发送的消息，处理消息后发送
export default async function msgContorl(types): Promise<void> {
  if (commonData.get('sendMsgProcessing')) {
    // 如果有消息正在处理, 不获取新的消息
    return
  }
  // 轮询时消息处理：
  // - 1、坐班消息 globalIsBein
  // --- 获取回复消息并回复 getReplyMsg ，发送回调 sendMsgCb
  // - 2、定时消息 getTimingSendMsg, 定时消息回调 cbTimingSendMsg

  // 1、回复消息
  await msgContorlReply(types)
  // 2、定时消息  -  一分钟轮询一次
  if (types[0] == 'normal') {
    await msgContorlTiming()
  }
}
// msgContorlReply 坐班/非坐班消息回复
interface ExtendObject {
  msg: string
}
async function msgContorlReply(types): Promise<void> {
  const selfwxid: string = commonData.get('selfwxid')
  // 获取回复消息
  const replyMsg = await serverRequest.getReplyMsg({
    rereceiver: selfwxid,
    types: types // normal exact sys // normal：正常消息，exact：精准匹配消息，sys：系统类型消息
  })
  // console.log('-=--replyMsg----', JSON.stringify(replyMsg))
  if (replyMsg && replyMsg.length > 0) {
    replyMsg.forEach((item) => {
      if (item.answerList && item.answerList.length > 0) {
        try {
          if (item.answerGroupType === 'yq') {
            // 从item.scrmChat[]中]寻找寻找id为item.ids的数据并拿到publisher/wxRoomName/publishTime::作为{{nickName}} {{groupName}} {{sendTime}}
            const _ids = item.ids.split(',')
            _ids.map((id) => {
              const _chatInfo = item.scrmChats.find((v) => v.id === id)
              item.answerList.forEach((answerItem) => {
                const _extend = formatJSONString<ExtendObject>(answerItem.extend)
                _extend!.msg = _extend!.msg
                  .replace(/{{nickName}}/g, _chatInfo.publisher)
                  .replace(/{{groupName}}/g, _chatInfo.wxRoomName)
                  .replace(/{{sendTime}}/g, _chatInfo.publishTime)
                  .replace(/{{msgContent}}/g, _chatInfo.content)
                const _roomIds = answerItem.roomIds ? answerItem.roomIds.split(',') : []
                _roomIds.map((roomId) => {
                  const _answer = {
                    wxRoomId: roomId,
                    msgContent: JSON.stringify(_extend), // string
                    msgType: answerItem.answerType,
                    atIds: '',
                    addFields: answerItem.addFields || '',
                    taskInfo: {
                      sceneType: 'reply',
                      ids: item.ids // 回复的消息的id
                    }
                  }

                  // 判断消息是否需要艾特全体成员
                  if (
                    answerItem.msgTxtType == 'all' &&
                    (_answer.msgType == 'txt' || _answer.msgType == 'atTxt')
                  ) {
                    _answer.msgType = 'atTxt'
                    _answer.atIds = 'atall'
                  }
                  servicesSendMsg.sendMsgToWx(_answer)
                })
              })
            })
          } else {
            servicesSendMsg.sendAnswerList(item, item.answerList, {
              sceneType: 'reply',
              ids: item.ids // 回复的消息的id
            })
          }
        } catch (error) {
          console.log('----error----', error)
        }
      } else {
        // answerList 空
        servicesSendMsg.sendMsgCb(
          {
            // msgType: answerItem.answerType,
            // msgContent: answerItem.extend, // string
            wxRoomId: item.wxRoomId,
            atIds: item.publisherIds,
            taskInfo: {
              sceneType: 'reply',
              ids: item.ids // 回复的消息的id
            }
          },
          1
        )
      }
    })
  }
  // }
}

// msgContorlTiming 定时消息
async function msgContorlTiming(): Promise<void> {
  const selfwxid: string = commonData.get('selfwxid')
  if (!selfwxid) {
    console.log('---- msgContorlTiming：selfwxid is null ----')
    return
  }
  const timingSendMsg = await serverRequest.getTimingSendMsg(selfwxid)
  if (timingSendMsg.length > 0) {
    console.log(
      '---- msgContorlTiming：timingSendMsg-定时消息 ----',
      selfwxid,
      JSON.stringify(timingSendMsg)
    )
    timingSendMsg.forEach((item) => {
      // console.log('---- timingSendMsg-item ----', item)
      // 没有answerList 没有receiver 的错误逻辑不一样
      if (!item.answerList || !item.receiver || item.receiver.length === 0 || !item.nextTime) {
        console.log('---- timingSendMsg-item-error ----', JSON.stringify(item))
        servicesSendMsg.sendMsgCb(
          {
            msgType: 'error',
            msgContent: JSON.stringify(item.answerList),
            wxRoomId: JSON.stringify(item.receiver.map((v) => v.receiverId)),
            taskInfo: {
              sceneType: 'timing',
              taskId: item.id,
              taskTheme: item.taskTheme,
              sendType: item.sendType, // 频次
              receiverName: JSON.stringify(item.receiver.map((v) => v.receiverName))
            }
          },
          1
        )
        return
      }
      // 先循环接收人，再循环消息
      item.receiver.forEach((r_item) => {
        ;(item.answerList || []).forEach((answerItem) => {
          const _data = {
            msgType: answerItem.msgType,
            msgContent: answerItem.msgContent || '',
            wxRoomId: r_item.receiverId,
            atIds: '',
            addFields: answerItem.addFields,
            taskInfo: {
              sceneType: 'timing',
              receiverName: r_item.receiverName,
              sendType: item.sendType, // 频次
              taskId: answerItem.taskId,
              taskTheme: item.taskTheme,
              sendInterval: item.sendInterval, // 消息发送间隔
              objectInterval: item.objectInterval // 对象发送间隔
            }
          }
          // 判断消息是否需要艾特全体成员
          if (
            answerItem.msgTxtType == 'all' &&
            (_data.msgType == 'txt' || _data.msgType == 'atTxt')
          ) {
            _data.msgType = 'atTxt'
            _data.atIds = 'atall'
          }
          // 判断定时消息应该发送的时间，十分钟内的发送, 十分钟外的直接回调失败
          if (
            new Date().getTime() - new Date(item.nextTime).getTime() < 10 * 60 * 1000 &&
            _data.msgContent
          ) {
            servicesSendMsg.sendMsgToWx(_data)
          } else {
            servicesSendMsg.sendMsgCb(_data, 1)
          }
        })
      })
    })
  }
}