package steamplaying

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"strconv"
	"sync"
	"time"

	"git.lxtend.com/lixiangwuxian/qqbot/config"
	"git.lxtend.com/lixiangwuxian/qqbot/sqlite3"
	"golang.org/x/net/proxy"
)

var SteamAPIKey = ""
var ProxyAddr = ""

func init() {
	SteamAPIKey = config.ConfigManager.GetConfig().SteamApiKey
	ProxyAddr = config.ConfigManager.GetConfig().Management.ProxyAddr
}

func init() {
	// 使用GORM自动迁移替代手写SQL
	sqlite3.AutoMigrate(&SteamUser{}, &SteamUserForGroup{})
}

func bindSteamUser(qqid int64, steamid string) error {
	db := sqlite3.GetGormDB()

	// 检查是否已绑定
	var count int64
	result := db.Model(&SteamUser{}).Where("qqid = ?", qqid).Count(&count)
	if result.Error != nil {
		return result.Error
	}
	if count > 0 {
		return errors.New("已绑定")
	}

	// 创建新绑定
	steamUser := SteamUser{
		QQID:    qqid,
		SteamID: steamid,
	}
	return db.Create(&steamUser).Error
}

func unbindSteamUser(qqid int64) error {
	db := sqlite3.GetGormDB()
	result := db.Where("qqid = ?", qqid).Delete(&SteamUser{})
	return result.Error
}

func bindUserInGroup(groupID int64, steamid string) error {
	db := sqlite3.GetGormDB()

	// 检查是否已绑定
	var count int64
	result := db.Model(&SteamUserForGroup{}).Where("group_id = ? AND steamid = ?", strconv.FormatInt(groupID, 10), steamid).Count(&count)
	if result.Error != nil {
		return result.Error
	}
	if count > 0 {
		return errors.New("已绑定")
	}

	// 创建新绑定
	steamUserForGroup := SteamUserForGroup{
		GroupID: strconv.FormatInt(groupID, 10),
		SteamID: steamid,
	}
	return db.Create(&steamUserForGroup).Error
}

func unbindUserInGroup(groupID int64, steamid string) error {
	db := sqlite3.GetGormDB()
	result := db.Where("group_id = ? AND steamid = ?", strconv.FormatInt(groupID, 10), steamid).Delete(&SteamUserForGroup{})
	return result.Error
}

func unbindUserInAllGroup(steamid string) error {
	db := sqlite3.GetGormDB()
	result := db.Where("steamid = ?", steamid).Delete(&SteamUserForGroup{})
	return result.Error
}

func getSteamUser(qqid int64) (SteamUser, error) {
	db := sqlite3.GetGormDB()
	var steamUser SteamUser
	result := db.Where("qqid = ?", qqid).First(&steamUser)
	return steamUser, result.Error
}

func getSteamUsersInGroup(groupID int64) ([]SteamUserForGroup, error) {
	db := sqlite3.GetGormDB()
	var steamUsers []SteamUserForGroup
	result := db.Where("group_id = ?", strconv.FormatInt(groupID, 10)).Find(&steamUsers)
	return steamUsers, result.Error
}

func checkSteamGameStatus(steamID []string) (string, error) {
	if len(steamID) == 0 {
		return "疑似没人在玩游戏", nil
	}
	var glbErr error
	var writeMutex sync.Mutex
	var Players []PlayerSummary
	var wg sync.WaitGroup
	for step := 0; step < len(steamID)/100+1; step++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			url := "https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=%s&steamids=%s"
			fullSteamID := ""
			for i := step * 100; i < (step+1)*100 && i < len(steamID); i++ {
				fullSteamID += steamID[i] + ","
			}
			fullSteamID = fullSteamID[:len(fullSteamID)-1]
			url = fmt.Sprintf(url, SteamAPIKey, fullSteamID)

			dialer, _ := proxy.SOCKS5("tcp", ProxyAddr, nil, proxy.Direct)
			httpTransport := &http.Transport{
				Dial: func(network, addr string) (net.Conn, error) {
					return dialer.Dial(network, addr)
				},
			}
			client := &http.Client{
				Transport: httpTransport,
				Timeout:   10 * time.Second, // 设置请求超时时间
			}
			var resp *http.Response
			maxRetry := 5
			for i := 0; i < maxRetry; i++ {
				glbErr = nil
				var err error
				resp, err = client.Get(url)
				if err != nil {
					if i == maxRetry-1 {
						glbErr = errors.New("Get方法请求Steam API失败")
						return
					}
					continue
				}
				break
			}

			defer resp.Body.Close()
			body, err := io.ReadAll(resp.Body)
			if err != nil {
				glbErr = err
				return
			}
			var userResponse GetPlayerSummariesResponse
			if err := json.Unmarshal(body, &userResponse); err != nil {
				glbErr = err
				return
			}
			writeMutex.Lock()
			Players = append(Players, userResponse.Response.Players...)
			writeMutex.Unlock()
		}()
	}
	wg.Wait()
	if glbErr != nil {
		return "", glbErr
	}
	gameStatusList := ""
	for _, userState := range Players {
		if userState.ToGameStatus() != "" {
			gameStatusList += userState.ToGameStatus() + "\n"
		}
	}
	if gameStatusList != "" {
		gameStatusList = gameStatusList[:len(gameStatusList)-1]
	} else {
		gameStatusList = "疑似没有人在玩游戏"
	}
	return gameStatusList, nil
}

func checkDiffSteamGameStatus(steamID []string, lastTimeStat map[string]string) (map[string]string, []PlayerSummary, error) {
	if len(steamID) == 0 {
		return nil, nil, nil
	}
	var glbErr error
	var writeMutex sync.Mutex
	var Players []PlayerSummary
	var wg sync.WaitGroup
	for step := 0; step < len(steamID)/100+1; step++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			url := "https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=%s&steamids=%s"
			fullSteamID := ""
			for i := step * 100; i < (step+1)*100 && i < len(steamID); i++ {
				fullSteamID += steamID[i] + ","
			}
			fullSteamID = fullSteamID[:len(fullSteamID)-1]
			url = fmt.Sprintf(url, SteamAPIKey, fullSteamID)

			dialer, _ := proxy.SOCKS5("tcp", ProxyAddr, nil, proxy.Direct)
			httpTransport := &http.Transport{
				Dial: func(network, addr string) (net.Conn, error) {
					return dialer.Dial(network, addr)
				},
			}
			client := &http.Client{
				Transport: httpTransport,
				Timeout:   10 * time.Second, // 设置请求超时时间
			}
			var resp *http.Response
			maxRetry := 5
			for i := 0; i < maxRetry; i++ {
				glbErr = nil
				var err error
				resp, err = client.Get(url)
				if err != nil {
					if i == maxRetry-1 {
						glbErr = errors.New("Get方法请求Steam API失败")
						return
					}
					continue
				}
				break
			}

			defer resp.Body.Close()
			body, err := io.ReadAll(resp.Body)
			if err != nil {
				glbErr = err
				return
			}
			var userResponse GetPlayerSummariesResponse
			if err := json.Unmarshal(body, &userResponse); err != nil {
				glbErr = err
				return
			}
			writeMutex.Lock()
			Players = append(Players, userResponse.Response.Players...)
			writeMutex.Unlock()
		}()
	}
	wg.Wait()
	if glbErr != nil {
		return nil, nil, glbErr
	}
	gameStatusListStr := map[string]string{}
	currentGameStatus := map[string]string{} // 用于记录当前所有玩家的游戏状态

	for _, userState := range Players {
		if userState.GameID != "" {
			currentGameStatus[userState.SteamID] = userState.GameID
			// 只有当玩家的游戏状态发生变化时才添加到通知列表
			if lastGameID, exists := lastTimeStat[userState.SteamID]; !exists || lastGameID != userState.GameID {
				if userState.ToGameStatus() != "" {
					gameStatusListStr[userState.SteamID] = userState.ToGameStatus()
				}
			}
		}
	}
	return gameStatusListStr, Players, nil
}

func checkSteamIDValid(steamID string) (bool, error) {
	url := "https://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key=%s&steamids=%s"
	url = fmt.Sprintf(url, SteamAPIKey, steamID)
	dialer, _ := proxy.SOCKS5("tcp", ProxyAddr, nil, proxy.Direct)
	httpTransport := &http.Transport{
		Dial: func(network, addr string) (net.Conn, error) {
			return dialer.Dial(network, addr)
		},
	}
	client := &http.Client{
		Transport: httpTransport,
		Timeout:   10 * time.Second, // 设置请求超时时间
	}
	resp, err := client.Get(url)
	if err != nil {
		return false, err
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return false, err
	}
	var userResponse GetPlayerSummariesResponse
	if err := json.Unmarshal(body, &userResponse); err != nil {
		return false, err
	}
	if len(userResponse.Response.Players) == 0 {
		return false, nil
	}
	return true, nil
}

func getAllGroupID() ([]int64, error) {
	db := sqlite3.GetGormDB()
	var steamUsers []SteamUserForGroup
	result := db.Select("DISTINCT group_id").Find(&steamUsers)
	if result.Error != nil {
		return nil, result.Error
	}

	var groupIDs []int64
	for _, user := range steamUsers {
		if groupID, err := strconv.ParseInt(user.GroupID, 10, 64); err == nil {
			groupIDs = append(groupIDs, groupID)
		}
	}
	return groupIDs, nil
}

func getAllSteamID() ([]string, error) {
	db := sqlite3.GetGormDB()
	var steamUsers []SteamUser
	result := db.Select("steamid").Find(&steamUsers)
	if result.Error != nil {
		return nil, result.Error
	}

	var steamIDs []string
	for _, user := range steamUsers {
		steamIDs = append(steamIDs, user.SteamID)
	}
	return steamIDs, nil
}