import _ from "lodash"
import moment from "moment"
import plugin from "../../../lib/plugins/plugin.js"
import { common } from "../model/index.js"
import { sleep } from "../tools/index.js"

const ROLE_MAP = {
  admin: "群管理",
  owner: "群主",
  member: "群员"
}
export class NewHandle extends plugin {
  constructor() {
    super({
      name: "椰奶申请处理",
      event: "message",
      priority: 500,
      rule: [
        {
          reg: "^#?(同意|拒绝)$",
          fnc: "Handle"
        },
        {
          reg: "^#?回复",
          fnc: "Replys",
          event: "message.private"
        },
        {
          reg: "^#?(同意|拒绝|查看)(全部)?好友申请(\\d+)?$",
          fnc: "PrivateAdd"
        },
        {
          reg: "^#?(加为|添加)好友$",
          fnc: "addFriend",
          event: "message.private"
        },
        {
          reg: "^#?(同意|拒绝|查看)(全部)?(加|入)?群申请(\\d+)?$",
          fnc: "GroupAdd",
          event: "message.group"
        },
        {
          reg: "^#?(同意|拒绝|查看)(全部)?群邀请(\\d+)?$",
          fnc: "GroupInvite"
        },
        {
          reg: "^#?查看全部请求$",
          fnc: "SystemMsgAll"
        }
      ]
    })
  }

  /**
   * 同意拒绝好友申请
   * @param e
   */
  async PrivateAdd(e) {
    if (!common.checkPermission(e, "master")) return false
    let yes = !!/同意/.test(e.msg)

    const systemMsg = (await (e.bot ?? Bot).getSystemMsg())
    let FriendAdd = systemMsg.filter(
      item => item.request_type == "friend" &&
      (item.sub_type === "add" || item.sub_type === "single")
    )

    if (_.isEmpty(FriendAdd)) return e.reply("暂无好友申请(。-ω-)zzz", true)

    if (/查看好友申请/.test(e.msg)) {
      FriendAdd = FriendAdd.map((item) => {
        return [
          segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${item.user_id}`),
          `\n申请人QQ：${item.user_id}\n`,
          `申请人昵称：${item.nickname}\n`,
          `申请来源：${item.source || "未知"}\n`,
          `申请时间：${moment(item.time * 1000).format("YYYY-MM-DD HH:mm:ss")}\n`,
          `附加信息：${item.comment || "无附加信息"}`
        ]
      })
      let msg = [
        `现有未处理的好友申请如下，共${FriendAdd.length}条`,
        "可用\"#同意好友申请<QQ>\"或\"#拒绝好友申请<QQ>\"进行处理",
        ...FriendAdd
      ]
      return common.getforwardMsg(e, msg)
    } else if (/全部/.test(e.msg)) {
      // 同意全部好友申请
      await e.reply("好哒，我开始处理辣٩(๑•ㅂ•)۶")
      let success = []; let fail = []
      for (let i of FriendAdd) {
        logger.mark(`${e.logFnc}${yes ? "同意" : "拒绝"}${i.user_id}的好友申请`)
        let res = await i.approve(yes)
        if (res) {
          success.push(`${success.length + 1}、${i.user_id}`)
        } else {
          fail.push(`${fail.length + 1}、${i.user_id}`)
        }
        await sleep(2000)
      }
      let msg = [ `本次共${yes ? "同意" : "拒绝"}${FriendAdd.length}条好友申请\n成功：${success.length}\n失败：${fail.length}` ]
      if (!_.isEmpty(success)) msg.push([ "以下为成功的名单：\n", success.join("\n") ])
      if (!_.isEmpty(fail)) msg.push([ "以下为失败的名单：\n", fail.join("\n") ])

      return common.getforwardMsg(e, msg)
    } else {
      // 处理单个好友申请
      let qq = e.msg.replace(/#|(同意|拒绝)好友申请/g, "").trim()
      if (!qq) return e.reply("❎ 请输入正确的QQ")

      let member = FriendAdd.find(item => item.user_id == qq)
      if (_.isEmpty(member)) return e.reply("❎ 没有找到这个人的好友申请")

      let result = member.approve(yes)
      if (result) {
        e.reply(`✅ 已${yes ? "同意" : "拒绝"}${member.nickname}(${qq})的好友申请`)
      } else {
        e.reply("❎ 未知错误")
      }
    }
  }

  /**
   * 引用同意好友申请和群邀请
   * @param e
   */
  async Handle(e) {
    const source = await common.takeSourceMsg(e)
    if (!source || source.user_id != (e.bot ?? Bot).uin) return false
    const sourceMsg = source.raw_message?.split("\n")
    if (!sourceMsg) return e.reply("❎ 获取原消息失败，请使用\"同意xxx\"进行处理")
    const yes = /同意/.test(e.msg)
    if (e.isGroup) {
      if (!common.checkPermission(e, "admin", "admin")) return
      logger.mark(`${e.logFnc}${yes ? "同意" : "拒绝"}加群通知`)
      let userId = await redis.get(`yenai:groupAdd:${source.message_id}`)
      if (!userId) return e.reply("找不到原消息了，手动同意叭~")

      let member = (await (e.bot ?? Bot).getSystemMsg())
        .find(item => item.request_type == "group" && item.sub_type == "add" && item.group_id == e.group_id && item.user_id == userId)

      if (_.isEmpty(member)) return e.reply("呜呜呜，没找到这个淫的加群申请(つд⊂)")

      if (/风险/.test(member.tips)) return e.reply("该账号为风险账号请手动处理哦ಠ~ಠ")

      if (await member.approve(yes)) {
        e.reply(`已${yes ? "同意" : "拒绝"}${member.nickname}(${member.user_id})的加群申请辣٩(๑^o^๑)۶`)
      } else {
        e.reply("呜呜呜，处理失败辣(இωஇ)")
      }
      return true
    } else {
      if (!common.checkPermission(e, "master")) return false
      if (/添加好友申请/.test(sourceMsg[0])) {
        let qq = sourceMsg[1].match(/[1-9]\d*/g)
        if ((e.bot ?? Bot).fl.get(Number(qq) || qq)) return e.reply("❎ 已经同意过该申请了哦~")

        logger.mark(`${e.logFnc}${yes ? "同意" : "拒绝"}好友申请`)

        await (e.bot ?? Bot).pickFriend(qq)
          .setFriendReq("", yes)
          .then(() => e.reply(`✅ 已${yes ? "同意" : "拒绝"}${qq}的好友申请`))
          .catch(() => e.reply("❎ 请检查是否已同意该申请"))
      } else if (/邀请机器人进群/.test(sourceMsg[0])) {
        let groupid = sourceMsg[1].match(/[1-9]\d*/g)
        if ((e.bot ?? Bot).fl.get(Number(groupid))) { return e.reply("❎ 已经同意过该申请了哦~") }

        let qq = sourceMsg[3].match(/[1-9]\d*/g)
        let seq = sourceMsg[6].match(/[1-9]\d*/g)

        logger.mark(`${e.logFnc}${yes ? "同意" : "拒绝"}群邀请`);

        (e.bot ?? Bot).pickUser(qq)
          .setGroupInvite(groupid, seq, yes)
          .then(() => e.reply(`✅ 已${yes ? "同意" : "拒绝"}${qq}的群邀请`))
          .catch(() => e.reply("❎ 请检查是否已同意该邀请"))
      } else if (/加群申请/.test(sourceMsg[0])) {
        let groupId = sourceMsg[1].match(/\d+/g)
        let qq = sourceMsg[3].match(/\d+/g)

        let member = (await (e.bot ?? Bot).getSystemMsg()).find(item => item.sub_type == "add" && item.group_id == groupId && item.user_id == qq)
        if (_.isEmpty(member)) return e.reply("没有找到这个人的加群申请哦")

        let result = member.approve(yes)
        if (result) {
          e.reply(`已${yes ? "同意" : "拒绝"}${member.nickname}(${qq})的加群申请`)
        } else {
          e.reply("失败了，可能为风险账号请手动处理")
        }
      } else {
        return false
      }
    }
  }

  // 回复好友消息
  async Replys(e) {
    if (!common.checkPermission(e, "master")) return false
    let qq = ""
    let group = ""
    let msgs = e.message[0].text.split(" ")
    const source = await common.takeSourceMsg(e)
    if (source) {
      let res
      try {
        res = source.raw_message.split("\n")
      } catch {
        return e.reply("❎ 消息可能已过期")
      }
      if (/好友消息/.test(res[0]) && /好友账号/.test(res[1])) {
        qq = res[1].match(/[1-9]\d*/g)
      } else if (/群临时消息/.test(res[0])) {
        qq = res[2].match(/[1-9]\d*/g)
        group = res[1].match(/[1-9]\d*/g)
      } else {
        return e.reply("❎ 请检查是否引用正确")
      }
      e.message[0].text = e.message[0].text.replace(/#|回复/g, "").trim()
    } else {
      if (msgs.length == 1 && !/\d/.test(msgs[0])) {
        return e.reply("❎ QQ号不能为空")
      } else if (/\d/.test(msgs[0])) {
        qq = msgs[0].match(/[1-9]\d*/g)
        e.message[0].text = msgs.slice(1).join(" ")
      } else {
        qq = msgs[1]
        e.message[0].text = msgs.slice(2).join(" ")
      }
    }
    if (!e.message[0].text) e.message.shift()

    if (e.message.length === 0) return e.reply("❎ 消息不能为空")
    if (group) {
      logger.mark(`${e.logFnc}回复临时消息`)
      return (e.bot ?? Bot).sendTempMsg(group, qq, e.message)
        .then(() => e.reply("✅ 已把消息发给它了哦~"))
        .catch((err) => common.handleException(e, err, { MsgTemplate: "❎ 发送失败\n错误信息为:{error}" }))
    }

    if (!/^\d+$/.test(qq)) return e.reply("❎ QQ号不正确，人家做不到的啦>_<~")

    if (!(e.bot ?? Bot).fl.get(Number(qq))) return e.reply("❎ 好友列表查无此人")

    logger.mark(`${e.logFnc}回复好友消息`);

    (e.bot ?? Bot).pickFriend(qq)
      .sendMsg(e.message)
      .then(() => e.reply("✅ 已把消息发给它了哦~"))
      .catch((err) => common.handleException(e, err, { MsgTemplate: "❎ 发送失败\n错误信息为:{error}" }))
  }

  // 加群员为好友
  async addFriend(e) {
    if (!common.checkPermission(e, "master")) return false
    const source = await common.takeSourceMsg(e)
    if (!source) return false
    let msg = source.raw_message.split("\n")
    if (!/临时消息/.test(msg[0]) || !/来源群号/.test(msg[1]) || !/发送人QQ/.test(msg[2])) return false
    let group = msg[1].match(/\d+/g)
    let qq = msg[2].match(/\d+/g)
    if ((e.bot ?? Bot).fl.get(Number(qq))) return e.reply("❎ 已经有这个人的好友了哦~")
    if (!(e.bot ?? Bot).gl.get(Number(group))) { return e.reply("❎ 群聊列表查无此群") }
    logger.mark(`${e.logFnc}主动添加好友`);

    (e.bot ?? Bot).addFriend(group, qq)
      .then(() => e.reply(`✅ 已向${qq}发送了好友请求`))
      .catch(() => e.reply("❎ 发送请求失败"))
  }

  // 入群请求
  async GroupAdd(e) {
    let SystemMsg = (await (e.bot ?? Bot).getSystemMsg())
      .filter(item => item.request_type == "group" && item.sub_type == "add" && item.group_id == e.group_id)
    if (_.isEmpty(SystemMsg)) return e.reply("暂无加群申请(。-ω-)zzz", true)
    // 查看
    if (/查看/.test(e.msg)) {
      SystemMsg = SystemMsg.map(item => {
        return [
          segment.image(`https://q1.qlogo.cn/g?b=qq&s=100&nk=${item.user_id}`),
          `\nQQ：${item.user_id}\n`,
          `昵称：${item.nickname}\n`,
          item.tips ? `Tips：${item.tips}\n` : "",
          `${item.comment}`
        ]
      })
      let msg = [
        `现有未处理的加群申请如下，总共${SystemMsg.length}条`,
        "可使用 \"#(同意|拒绝)加群申请xxx\"\n或 \"#(同意|拒绝)全部加群申请\"",
        ...SystemMsg
      ]
      return common.getforwardMsg(e, msg)
    }
    if (!common.checkPermission(e, "admin", "admin")) return
    let yes = /同意/.test(e.msg)

    if (/全部/.test(e.msg)) {
      e.reply("好哒，我开始处理辣٩(๑•ㅂ•)۶")
      let success = []; let fail = []; let risk = []
      for (let i of SystemMsg) {
        if (await i.approve(yes)) {
          success.push(`${success.length + 1}、${i.user_id}`)
        } else {
          if (/风险/.test(i.tips)) {
            risk.push(`${risk.length + 1}、${i.user_id}`)
          } else {
            fail.push(`${fail.length + 1}、${i.user_id}`)
          }
        }
        await sleep(1000)
      }
      let msg = [ `本次共处理${SystemMsg.length}条群申请\n成功：${success.length}\n失败：${fail.length}\n风险：${risk.length}` ]
      if (!_.isEmpty(success)) msg.push([ "以下为成功的名单：\n", success.join("\n") ])
      if (!_.isEmpty(fail)) msg.push([ "以下为失败的名单：\n", fail.join("\n") ])
      if (!_.isEmpty(risk)) msg.push([ "以下为风险账号名单：\n", risk.join("\n") ])
      common.getforwardMsg(e, msg)
    } else {
      let qq = e.msg.replace(/#(同意|拒绝)(加|入)群申请/g, "").trim()

      if (!qq) return e.reply("QQ号呢，QQ号呢d(ŐдŐ๑)", true)

      let member = SystemMsg.find(item => item.user_id == qq)

      if (_.isEmpty(member)) return e.reply("呜呜呜，没找到这个淫的加群申请(つд⊂)")

      if (/风险/.test(member.tips)) return e.reply("该账号为风险账号请手动处理哦ಠ~ಠ")

      if (await member.approve(yes)) {
        e.reply(`已${yes ? "同意" : "拒绝"}${member.nickname}(${member.user_id})的加群申请辣٩(๑^o^๑)۶`)
      } else {
        e.reply("呜呜呜，处理失败辣(இωஇ)")
      }
    }
  }

  // 群邀请列表
  async GroupInvite(e) {
    if (!common.checkPermission(e, "master")) return false
    let SystemMsg = (await (e.bot ?? Bot).getSystemMsg()).filter(item => item.request_type == "group" && item.sub_type == "invite")
    if (_.isEmpty(SystemMsg)) return e.reply("暂无群邀请哦(。-ω-)zzz", true)
    let yes = /同意/.test(e.msg)
    // 查看
    if (/查看/.test(e.msg)) {
      SystemMsg = SystemMsg.map(item => {
        return [
          segment.image(`https://p.qlogo.cn/gh/${item.group_id}/${item.group_id}/100`),
          `\n邀请群号：${item.group_id}\n`,
          `邀请群名：${item.group_name}\n`,
          `邀请人QQ：${item.user_id}\n`,
          `邀请人昵称：${item.nickname}\n`,
          `邀请人身份：${ROLE_MAP[item.role]}`
        ]
      })
      let msg = [
        `现有未处理的群邀请如下，总共${SystemMsg.length}条`,
        "可使用 \"#(同意|拒绝)群邀请xxx\"\n或 \"#(同意|拒绝)全部群邀请\"",
        ...SystemMsg
      ]
      return common.getforwardMsg(e, msg)
    } else if (/全部/.test(e.msg)) {
      e.reply("好哒，我开始处理辣٩(๑•ㅂ•)۶")
      let success = []; let fail = []
      for (let i of SystemMsg) {
        if (await i.approve(yes)) {
          success.push(`${success.length + 1}、${i.user_id}`)
        } else {
          fail.push(`${fail.length + 1}、${i.user_id}`)
        }
        await sleep(1000)
      }
      let msg = [ `本次共处理${SystemMsg.length}条群邀请\n成功：${success.length}\n失败：${fail.length}` ]
      if (!_.isEmpty(success)) msg.push([ "以下为成功的名单：\n", success.join("\n") ])
      if (!_.isEmpty(fail)) msg.push([ "以下为失败的名单：\n", fail.join("\n") ])
      common.getforwardMsg(e, msg)
    } else {
      let groupid = e.msg.replace(/#(同意|拒绝)群邀请/g, "").trim()

      if (!groupid) return e.reply("群号呢，群号呢d(ŐдŐ๑)", true)

      let Invite = SystemMsg.find(item => item.group_id == groupid)

      if (_.isEmpty(Invite)) return e.reply("欸，你似不似傻哪有这个群邀请(O∆O)")

      if (await Invite.approve(yes)) {
        e.reply(`已${yes ? "同意" : "拒绝"}${Invite.group_id}这个群邀请辣٩(๑^o^๑)۶`)
      } else {
        e.reply("呜呜呜，处理失败辣(இωஇ)")
      }
    }
  }

  // 全部请求
  async SystemMsgAll(e) {
    if (!common.checkPermission(e, "master")) return false
    let SystemMsg = await (e.bot ?? Bot).getSystemMsg()
    let FriendAdd = []; let onewayFriend = []; let GroupAdd = []; let GroupInvite = []
    for (let i of SystemMsg) {
      if (i.request_type == "friend") {
        if (i.sub_type == "add") {
          FriendAdd.push(i)
        } else {
          onewayFriend.push(i)
        }
      } else {
        if (i.sub_type == "add") {
          GroupAdd.push(i)
        } else {
          GroupInvite.push(i)
        }
      }
    }
    let msg = []
    if (!_.isEmpty(FriendAdd)) msg.push(`好友申请：${FriendAdd.length}条\n可使用"#查看好友申请" 查看详情`)
    if (!_.isEmpty(GroupInvite)) msg.push(`群邀请：${GroupInvite.length}条\n可使用"#查看群邀请" 查看详情`)
    if (!_.isEmpty(onewayFriend)) msg.push(`单向好友：${onewayFriend.length}条`)
    if (e.isGroup) {
      GroupAdd = GroupAdd.filter(item => item.group_id == e.group.id)
      if (!_.isEmpty(GroupAdd)) msg.push(`当前群申请：${GroupAdd.length}条`)
    }
    if (_.isEmpty(msg)) return e.reply("好耶！！一条请求都没有哦o( ❛ᴗ❛ )o", true)
    msg.unshift("以下为暂未处理的请求")
    common.getforwardMsg(e, msg)
  }
}