package steamplaying

import (
	"fmt"
	"regexp"
	"time"

	"git.lxtend.com/qqbot/action"
	"git.lxtend.com/qqbot/constants"
	"git.lxtend.com/qqbot/handler"
	"git.lxtend.com/qqbot/model"
	"git.lxtend.com/qqbot/util"
)

func init() {
	// Register the handler with the server
	handler.RegisterHandler("绑steam", bindSteam, constants.LEVEL_USER)
	handler.RegisterHelpInform("绑steam", "steam", "绑定您的steam账号。可以通过右上角-账户明细页面 https://store.steampowered.com/account/ 查看，位于页面左上角")
	handler.RegisterHandler("群绑定steam", bindSteamInGroup, constants.LEVEL_USER)
	handler.RegisterHelpInform("群绑定steam", "steam", "在群内启用你的steam游戏状态查询")
	// handler.RegisterHandler("群通报steam", bindSteamInGroupBroadCast, constants.LEVEL_USER)
	// handler.RegisterHelpInform("群通报steam", "在群内启用你的steam游戏上线通报")
	handler.RegisterHandler("解绑steam", unbindSteam, constants.LEVEL_USER)
	handler.RegisterHelpInform("解绑steam", "steam", "解绑您的steam账号，并解绑所有群监听")
	handler.RegisterHandler("群解绑steam", unbindSteamInGroup, constants.LEVEL_USER)
	handler.RegisterHelpInform("群解绑steam", "steam", "解绑本群群监听steam游戏状态")
	handler.RegisterHandler("查房", checkSteamPlaying, constants.LEVEL_USER)
	handler.RegisterHelpInform("查房", "steam", "查看群内成员的steam游戏状态")
	go RoundCheckSteamPlaying()
}

func bindSteam(msg model.Message) model.Reply {
	token := util.SplitN(msg.RawMsg, 2)
	if len(token) < 2 {
		return model.Reply{
			ReplyMsg:       "请输入steamID",
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	} else {
		re := regexp.MustCompile(`https://steamcommunity\.com/profiles/([0-9]+)`)
		steamIdInUrl := re.FindStringSubmatch(token[1])
		if steamIdInUrl != nil {
			token[1] = steamIdInUrl[1]
		}
		if valid, err := checkSteamIDValid(token[1]); !valid {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("steamID无效: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		} else if err != nil {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("steamID验证失败: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		}
		if err := bindSteamUser(msg.UserId, token[1]); err != nil {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("绑定失败: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		}
	}
	return model.Reply{
		ReplyMsg:       fmt.Sprintf("绑定steam用户%s成功", token[1]),
		ReferOriginMsg: true,
		FromMsg:        msg,
	}
}

func bindSteamInGroup(msg model.Message) model.Reply {
	if user, err := getSteamUser(msg.UserId); err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("查询steam绑定失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	} else if err := bindUserInGroup(msg.GroupInfo.GroupId, user.SteamID); err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("绑定至群监听列表失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	}
	return model.Reply{
		ReplyMsg:       "绑定至群监听列表成功",
		ReferOriginMsg: true,
		FromMsg:        msg,
	}
}

func unbindSteam(msg model.Message) model.Reply {
	if user, err := getSteamUser(msg.UserId); err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("解绑失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	} else {
		if err := unbindUserInAllGroup(user.SteamID); err != nil {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("解绑所有群监听列表失败: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		}
		if err := unbindSteamUser(msg.UserId); err != nil {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("解绑失败: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		}
	}
	return model.Reply{
		ReplyMsg:       "解绑成功",
		ReferOriginMsg: true,
		FromMsg:        msg,
	}
}

func unbindSteamInGroup(msg model.Message) model.Reply {
	if user, err := getSteamUser(msg.UserId); err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("群监听解绑失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	} else {
		if err := unbindUserInGroup(msg.GroupInfo.GroupId, user.SteamID); err != nil {
			return model.Reply{
				ReplyMsg:       fmt.Sprintf("群监听解绑失败: %v", err),
				ReferOriginMsg: true,
				FromMsg:        msg,
			}
		}
	}
	return model.Reply{
		ReplyMsg:       "群监听解绑成功，本群内将不再查询你的steam游戏状态",
		ReferOriginMsg: true,
		FromMsg:        msg,
	}
}

func checkSteamPlaying(msg model.Message) model.Reply {
	users, err := getSteamUsersInGroup(msg.GroupInfo.GroupId)
	if err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("获取群成员steam列表失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	}
	var steamIds []string
	for _, user := range users {
		steamIds = append(steamIds, user.SteamID)
	}
	gameList, err := checkSteamGameStatus(steamIds)
	if err != nil {
		return model.Reply{
			ReplyMsg:       fmt.Sprintf("获取游戏列表失败: %v", err),
			ReferOriginMsg: true,
			FromMsg:        msg,
		}
	}
	return model.Reply{
		ReplyMsg:       gameList,
		ReferOriginMsg: true,
		FromMsg:        msg,
	}
}

func RoundCheckSteamPlaying() {
	once := true
	playingMap := map[int64]map[string]string{}
	util.AddCycleTask("checkSteamPlaying", 15*time.Second, 15*time.Second, func() {
		groups, err := getAllGroupID()
		if err != nil {
			fmt.Println("获取群列表失败: ", err)
			return
		}

		for _, group := range groups {
			time.Sleep(15 * time.Second)
			if _, ok := playingMap[group]; !ok {
				playingMap[group] = map[string]string{}
			}
			users, err := getSteamUsersInGroup(group)
			if err != nil {
				fmt.Println("获取群成员steam列表失败: ", err)
				continue
			}
			var steamIds []string
			for _, user := range users {
				steamIds = append(steamIds, user.SteamID)
			}
			gameList, err := checkDiffSteamGameStatus(steamIds, playingMap[group])
			if err != nil {
				fmt.Println("获取游戏列表失败: ", err)
				continue
			}
			if gameList != "" && !once {
				msg := model.Reply{
					ReplyMsg:       "速报：\n" + gameList,
					ReferOriginMsg: false,
					FromMsg:        model.Message{GroupInfo: model.GroupInfo{GroupId: group}},
				}
				action.ActionManager.SendMsg(msg)
			}
		}
		once = false
	})
}