package teen

import (
	"encoding/json"
	"fmt"
	"math/rand"
	"os"
	"server/common"
	redismgr "server/db/redis"
	"server/game/room"
	"server/msg"
	"slices"
	"time"

	"github.com/name5566/leaf/log"
)

type RobotNames struct {
	Names []string `json:"name"`
}

// 用于生成 10 位随机 ID 的函数
func generateRandomID() string {
	random := rand.New(rand.NewSource(time.Now().UnixNano()))
	randomID := random.Intn(10000000000)  // 生成一个 10 位的随机整数
	return fmt.Sprintf("%010d", randomID) // 返回格式化的 10 位 ID，不足的补零
}

// 创建人机的UserData
func createRobotUserData() *common.UserData {
	return &common.UserData{
		Id:     generateRandomID(),
		Status: 1,
		// Teen_Patti_Room: nil,
		Head_Image: randomIndianHeadImage(),
		Nickname:   randomIndianName(),
		Room_id:    "0",
		Points:     int32(1000),
	}
}

// 随即印度人名字
func randomIndianName() string {
	data, err := os.ReadFile("/home/zjh/teen_patti/bin/gamedata/robot_name.json")
	if err != nil {
		log.Fatal("%v", err)
	}
	var Names RobotNames
	err = json.Unmarshal(data, &Names)
	if err != nil {
		log.Fatal("%v", err)
	}
	return Names.Names[rand.Intn(len(Names.Names))]
}

type RobotHeadImages struct {
	HeadImages []string `json:"head_image"`
}

// 随即印度人头像
func randomIndianHeadImage() string {
	data, err := os.ReadFile("/home/zjh/teen_patti/bin/gamedata/robot_head_image.json")
	if err != nil {
		log.Fatal("%v", err)
	}

	var images RobotHeadImages
	err = json.Unmarshal(data, &images)
	if err != nil {
		log.Fatal("%v", err)
	}
	return images.HeadImages[rand.Intn(len(images.HeadImages))]
}

// 获取空闲机器人或创建新机器人
func getOrCreateTeenPattiRobot(teenPattiRoom *room.Room) (*common.UserData, error) {
	robotUserData, err := getTeenPattiRobot(teenPattiRoom)
	if err != nil {
		log.Debug("Error getting robot info: %v", err)
		return nil, err
	}

	if robotUserData == nil {
		// 如果没有空闲机器人，创建新的机器人
		log.Debug("No free robot available. Creating a new robot.")
		robotUserData = createRobotUserData()
		robotUserData.Room_id = teenPattiRoom.Id
		err := redismgr.SaveRobotInfoToRedis(robotUserData.Id, robotUserData)
		if err != nil {
			log.Debug("Error saving new robot to Redis: %v", err)
			return nil, err
		}
		log.Debug("Successfully created and saved robot info: %+v", robotUserData)
	}

	return robotUserData, nil
}

// 为房间加入新机器人
func addNewRobot(teenPattiRoom *room.Room, availableSitPos []int32) {
	// 初始化随机数生成器
	random := rand.New(rand.NewSource(time.Now().UnixNano()))

	// 随机选择一个座位
	randomIndex := random.Intn(len(availableSitPos))
	selectedSitPos := availableSitPos[randomIndex]
	log.Debug("Selected seat position: %v", selectedSitPos)

	// 获取或创建新的机器人
	robotUserData, err := getOrCreateTeenPattiRobot(teenPattiRoom)
	if err != nil {
		log.Debug("Error getting or creating robot: %v", err)
		return
	}

	// 创建新的 Player 对象并加入房间
	newRobot := &room.Player{
		Id:        robotUserData.Id,      // 使用生成的机器人ID
		Agent:     nil,                   // 代理为空
		IsRobot:   true,                  // 标记为机器人
		UserData:  robotUserData,         // 设置机器人用户数据
		SitPos:    int32(selectedSitPos), // 分配随机座位
		HandCards: []*msg.ReqCard{},      // 初始手牌为空
		IsPacked:  false,
		IsSeen:    false,
		IsShow:    false,
		IsDealer:  false,
		CanShow:   false,
	}
	// 将新机器人加入房间
	teenPattiRoom.Players = append(teenPattiRoom.Players, newRobot)
	log.Debug("Added new robot to room %v at position %v", teenPattiRoom.Id, selectedSitPos)
}

// 随机去除一个机器人，排除座位号为 4
func removeRandomRobot(teenPattiRoom *room.Room) {
	if len(teenPattiRoom.Players) > 1 { // 至少有 2 个玩家，才能删除一个机器人
		var randomIndex int
		var removedRobotID string

		// 随机选择一个机器人位置，排除座位号为 4 并且确保选择的是机器人
		for {
			randomIndex = rand.Intn(len(teenPattiRoom.Players)) // 随机选择一个玩家位置
			// 确保选中的是机器人
			if teenPattiRoom.Players[randomIndex].IsRobot {
				removedRobotID = teenPattiRoom.Players[randomIndex].Id
				break
			}
		}

		// 删除该位置的机器人
		if randomIndex < len(teenPattiRoom.Players) {
			teenPattiRoom.Players = slices.Delete(teenPattiRoom.Players, randomIndex, randomIndex+1)
			log.Debug("Robot removed from room %v at position %d", teenPattiRoom.Id, randomIndex)

			// 机器人退出房间，重置其 Room_id
			redismgr.ResetRobotRoomID(removedRobotID)

			// 将机器人重新放回 Redis 空闲队列
			redismgr.AddRobotToFreeQueue(teenPattiRoom.ConfId, removedRobotID)
		}
	}
}

// 获取空闲机器人的信息
func getTeenPattiRobot(r *room.Room) (*common.UserData, error) {
	// 获取空闲机器人的信息
	robotID, err := redismgr.GetFreeRobot(r.ConfId) // 获取空闲机器人的ID
	if err != nil {
		log.Debug("Error getting free robots: %v", err)
		return nil, err
	}

	// 如果没有空闲机器人，返回nil
	if robotID == "0" {
		log.Debug("No free robots available.")
		return nil, nil
	}

	// 获取机器人的详细信息
	robotInfo, err := redismgr.GetRobotInfoFromRedis(robotID)
	if err != nil {
		log.Debug("Error fetching robot info for robotID %s: %v", robotID, err)
		return nil, err
	}

	if robotInfo == nil {
		log.Debug("Robot info for robotID %s is nil", robotID)
		return nil, fmt.Errorf("robot info is nil for robotID %s", robotID)
	}

	// 输出机器人的详细信息
	log.Debug("Robot Info: %+v", robotInfo)
	// 返回机器人信息
	return robotInfo, nil
}
func updateRobotPoints(robotID string, points int32, isAdd bool) {
	// 获取机器人当前信息
	robotInfo, err := redismgr.GetRobotInfoFromRedis(robotID)
	if err != nil {
		log.Debug("Robot %s not found in Redis", robotID)
		return
	}

	currentPoints := robotInfo.Points
	// 计算新积分
	newPoints := int32(currentPoints)
	if isAdd {
		newPoints += points
	} else {
		newPoints -= points
	}

	// 更新 Redis
	redismgr.UpdateRobotPointsInRedis(robotID, newPoints)
}
