import hookInitialize from '../api/hookInitialize'
import hookRequest from '../api/hookRequest'
import serverRequest from '../api/scrm/serverRequest'
import servicesSendMsg from '../services/sendMsg'
import commonData from '../store/data'
import WebLog from '../utils/weblogs'
import { getRandomGroupData } from '../utils/index'
import { delay } from '../utils/index'
import { AccInfoTypes, GroupsData, GroupMemberData, memberInfo } from '../types/types'
import { TypeServerWorkTimes_item } from '../types/typesServer'
// 获取坐班时间
async function getWorkTime(): Promise<void> {
  const selfwxid = commonData.get('selfwxid')
  try {
    const _data: TypeServerWorkTimes_item[] = await serverRequest.getWorkTime(selfwxid)
    const _globalWorkTimeArr = _data.map((v) => {
      return {
        startTime: v.officeStart,
        endTime: v.officeEnd
      }
    })

    // 判断是否有变化
    if (
      JSON.stringify(_globalWorkTimeArr) !== JSON.stringify(commonData.get('globalWorkTimeArr'))
    ) {
      commonData.set('globalWorkTimeArr', _globalWorkTimeArr)
      let str = ''
      _globalWorkTimeArr.map((item, i) => {
        if (item.startTime && item.endTime) {
          if (i !== 0) {
            str += ', '
          }
          str += `${item.startTime} - ${item.endTime} `
        }
      })
      WebLog.set({ type: 'info', content: `坐班时间：${str} ` })
    }
  } catch (error) {
    console.log('----error----', error)
  }
}
// 判断坐班状态变化
async function checkBeinStatus(): Promise<void> {
  let _isBein = commonData.get('isBein') // 是否坐班
  const _curBein = checkTimeRange()

  // 坐班状态发生变化
  if (_isBein !== _curBein) {
    // console.log('----坐班状态发生变化----', _curBein ? '坐班' : '非坐班')
    commonData.set('isBein', _curBein)
    _isBein = _curBein
    if (_curBein) {
      WebLog.set({ type: 'info', content: '坐班状态变化：当前处于坐班时间' })
      serverRequest.startBein() // 开始坐班通知
    } else {
      WebLog.set({ type: 'info', content: '坐班状态变化：当前处于非坐班时间' })
      // serverRequest.endBein() // 结束坐班通知
    }
  }
}
// 检查是否在班次时间内
const checkTimeRange = (): boolean => {
  const globalWorkTimeArr: { startTime: string; endTime: string }[] =
    commonData.get('globalWorkTimeArr')
  //  bein 坐班时间。 normal 非坐班时间
  if (!globalWorkTimeArr.length) {
    return false
  }
  const now = new Date()
  for (const slot of globalWorkTimeArr) {
    const { startTime, endTime } = slot
    const start = new Date(`${now.toDateString()} ${startTime}`)
    const end = new Date(`${now.toDateString()} ${endTime}`)

    if (start <= end) {
      if (now >= start && now <= end) {
        return true
      }
    } else {
      if (now >= start || now <= end) {
        return true
      }
    }
  }

  return false
}

// 连接企微
async function startWxConnect(): Promise<void> {
  try {
    await hookInitialize.initHook()
    await delay(5000)

    await checkLoginStatus()
    await getAccInfo()

    console.log('服务连接成功')
    WebLog.set({
      type: 'success',
      content: '服务连接成功'
    })
  } catch (error) {
    const errMsg = (error as Error).message || '请检查企微状态或重启企微和本客户端'
    console.log('服务连接失败，尝试重连：', errMsg)
    WebLog.set({
      type: 'error',
      content: '服务连接失败: ' + errMsg
    })

    await delay(5000)
    await startWxConnect()
  }
}

async function checkLoginStatus(): Promise<void> {
  const loginStatus = await hookRequest.fetchGetLoginStatus()
  commonData.set('wxLoginStatus', loginStatus.status)
  if (loginStatus.status !== 1) throw new Error('暂未登录')
}
// 获取企微基础数据（账号数据 群数据）
async function getAccInfo(): Promise<AccInfoTypes | null> {
  // 获取账号信息
  const accInfo = await hookRequest.fetchGetAccInfo()
  if (accInfo) {
    commonData.set('accInfo', accInfo)
    commonData.set('selfwxid', accInfo.user_id)
    return accInfo
  }
  return null
}
// 获取群数据
async function getGroupsList(page_num, page_size): Promise<GroupsData> {
  const groupsList = await hookRequest.fetchGetGroupsList(page_num, page_size) // {list: [], room_total: 0 }
  return groupsList || []
}
// 获取群成员列表
async function getGroupMembers(room_id): Promise<GroupMemberData> {
  const groupMembers = await hookRequest.fetchGetGroupMembers(room_id)
  // console.log('群成员列表：', groupMembers)
  return groupMembers
}

// 新用户进群，获取用户信息，发送欢迎消息并上报数据
async function newMemberJoinRoom(room_id, memberIds): Promise<void> {
  console.log('新用户进群：', room_id, memberIds)
  await delay(3000)
  // 获取企微信息
  const selfwxid = commonData.get('selfwxid')
  if (!selfwxid) {
    console.log('没有获取到企微信息：selfwxid')
    return
  }

  const roomInfo = await hookRequest.fetchGetRoomInfo(room_id)
  const roomName = roomInfo?.nick_name || ''
  // 发送入群欢迎语
  sendJoinWelMessage(memberIds, room_id, roomName)

  getAndReportJoinMemberInfo(room_id, memberIds, roomName)
}

// 获取用户信息, 并上报入群成员信息
async function getAndReportJoinMemberInfo(room_id, memberIds, roomName): Promise<void> {
  let retryCount = 0
  const maxRetries = 6 // 最大重试次数

  while (retryCount < maxRetries) {
    // 格式化用户信息
    const memberInfoPromises = memberIds.map(async (wxid) => {
      const _info = await hookRequest.fetchGetMemberInfo(wxid)
      if (!_info) return null
      return {
        userId: wxid || _info?.user_id || '',
        nickname: _info?.nick_name || '',
        avatar: _info?.avatar_url || '',
        roomChatId: room_id,
        roomName: roomName
      }
    })
    const results = await Promise.all(memberInfoPromises)
    const _memberList: memberInfo[] = results.filter(Boolean)
    if (!_memberList.length) {
      retryCount++
      console.log(`没有获取到用户信息，第${retryCount}次重试`, JSON.stringify(results))
      if (retryCount <= maxRetries) {
        await delay(600000) // 10分钟后重试
        continue
      } else {
        console.log('达到最大重试次数，停止重试')
        return
      }
    }
    // 上报入群成员信息并获取群信息
    const data = await serverRequest.groupJoin(_memberList)
    if (!(data[0] && data[0].memberIds)) {
      console.log('没有获取到群信息', JSON.stringify(_memberList))
      return
    }
    // 成功处理，跳出循环
    break
  }
}

async function sendJoinWelMessage(_memberIds, room_id, roomName): Promise<void> {
  const drInfo = await serverRequest.getDridByRoomId(room_id)
  const selfwxid = commonData.get('selfwxid')
  if (!selfwxid) {
    console.log('没有获取到企微信息：selfwxid')
    return
  }
  // 发送欢迎消息(drId room_id)
  // 非默认医助，不发送欢迎消息
  const res = await serverRequest.getDefaultAcc()
  if (!(res && res.entWxId && res.entWxId == selfwxid)) {
    console.log('非默认医助，不发送欢迎消息')
    return
  }

  // 替换文字
  const txtReplaceOpts = {
    '{{医生姓名}}': drInfo?.drName || '',
    '{{群名}}': roomName
  }

  // 获取入群欢迎语
  const msgListRes = await serverRequest.getWelcomeByRoomId(room_id)
  if (msgListRes) {
    // 将msgListRes.answerList按groupKey的值进行分组，并随机取一组数据
    const msgList = getRandomGroupData(msgListRes.scrmWelcomeAnswers)

    msgList.forEach((answerItem) => {
      Object.keys(txtReplaceOpts).forEach((key) => {
        const regex = new RegExp(key, 'g')
        answerItem.extend = (answerItem.extend || '').replace(regex, txtReplaceOpts[key])
      })
      const _answer = {
        msgType: answerItem.answerType,
        msgContent: answerItem.extend, // string
        wxRoomId: room_id,
        atIds: _memberIds.join(','),
        addFields: answerItem.addFields || '',
        taskInfo: {
          sceneType: 'welcome'
        }
      }

      // 判断消息是否需要艾特全体成员
      if (
        answerItem.msgTxtType == 'all' &&
        (_answer.msgType == 'txt' || _answer.msgType == 'atTxt')
      ) {
        _answer.msgType = 'atTxt'
        _answer.atIds = 'atall'
      }
      servicesSendMsg.sendMsgToWx(_answer)
    })
  }
}

export default {
  getWorkTime,
  checkBeinStatus,
  startWxConnect,
  checkLoginStatus,
  getAccInfo,
  getGroupsList,
  getGroupMembers,
  newMemberJoinRoom
}