package usercenter

import (
	"database/sql"
	"encoding/json"
	"fmt"
	mysqlmgr "server/db/mysql"
	"strings"
	"time"
)

type User struct {
	ID           int             `json:"id" db:"id"`
	CreateTime   time.Time       `json:"create_time" db:"create_time"`
	UserID       string          `json:"user_id" db:"user_id"`
	FriendIDs    json.RawMessage `json:"friend_ids" db:"friend_ids"` // 使用json.RawMessage处理JSON数据
	Head         string          `json:"head" db:"head"`
	Coin         int             `json:"coin" db:"coin"`
	Name         string          `json:"name" db:"name"`
	Account      string          `json:"account" db:"account"`
	Password     string          `json:"-" db:"password"` // json:"-" 表示不序列化密码
	OnlineStatus int             `json:"online_status" db:"online_status"`
}

// GetUsersByIDs 根据用户ID数组批量获取用户信息
func GetUsersByIDs(ids []string) ([]*User, error) {
	// 处理空数组情况
	if len(ids) == 0 {
		return []*User{}, nil
	}

	// 构建IN查询参数
	query, args := buildInQuery("SELECT id, user_id, friend_ids, name, head, coin, create_time,online_status FROM users WHERE user_id IN", ids)

	// 执行查询
	rows, err := mysqlmgr.Query(query, args...)
	if err != nil {
		return nil, fmt.Errorf("批量查询用户失败: %v", err)
	}
	defer rows.Close()

	// 处理结果集
	var users []*User
	for rows.Next() {
		var user User
		var friendData []byte
		var createTime sql.NullTime

		err := rows.Scan(
			&user.ID,
			&user.UserID,
			&friendData,
			&user.Name,
			&user.Head,
			&user.Coin,
			&createTime,
			&user.OnlineStatus,
		)
		if err != nil {
			return nil, fmt.Errorf("解析用户数据失败: %v", err)
		}

		// 处理JSON和NULL字段
		user.FriendIDs = json.RawMessage(friendData)
		if createTime.Valid {
			user.CreateTime = createTime.Time
		}

		users = append(users, &user)
	}

	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("遍历结果集失败: %v", err)
	}

	return users, nil
}

// buildInQuery 构建安全的IN查询语句
func buildInQuery(baseQuery string, ids []string) (string, []interface{}) {
	placeholders := make([]string, len(ids))
	args := make([]interface{}, len(ids))

	for i, id := range ids {
		placeholders[i] = "?"
		args[i] = id
	}

	return fmt.Sprintf("%s (%s)", baseQuery, strings.Join(placeholders, ",")), args
}

func GetUserByID(userID string) (*User, error) {
	var user User
	var friendData []byte // 接收数据库中的JSON原始数据

	// SQL查询（实际执行数据库操作）
	err := mysqlmgr.QueryRow(`
        SELECT id, user_id, friend_ids, name ,head FROM users WHERE user_id = ?`,
		userID,
	).Scan(
		&user.ID,
		&user.UserID,
		&friendData, // 扫描JSON数据到[]byte
		&user.Name,
		&user.Head,
	)

	if err != nil {
		return nil, err
	}

	// 将原始JSON数据存入结构体
	user.FriendIDs = json.RawMessage(friendData)
	return &user, nil
}

func GetUserByAccountAndPassword(Account string, Password string) (*User, error) {
	var user User
	var friendData []byte // 接收数据库中的JSON原始数据

	// SQL查询（实际执行数据库操作）
	err := mysqlmgr.QueryRow(`
        SELECT id, user_id, friend_ids, name 
        FROM users WHERE account = ? AND password = ? LIMIT 1`,
		Account, Password,
	).Scan(
		&user.ID,
		&user.UserID,
		&friendData, // 扫描JSON数据到[]byte
		&user.Name,
		&user.Head,
	)

	if err != nil {
		return nil, err
	}

	// 将原始JSON数据存入结构体
	user.FriendIDs = json.RawMessage(friendData)
	return &user, nil
}

func CreateUser(user *User) (int64, error) {
	result, err := mysqlmgr.Insert(`
		INSERT INTO users 
		(create_time, user_id, friend_ids, head, coin, name, account, password)
		VALUES (NOW(), ?, ?, ?, ?, ?, ?, ?)`,
		user.UserID,
		user.FriendIDs, // 直接传入json.RawMessage
		user.Head,
		user.Coin,
		user.Name,
		user.Account,
		user.Password,
	)

	if err != nil {
		return 0, fmt.Errorf("创建用户失败: %v", err)
	}
	return result, err
}

func (u *User) SetFriendIDs(friendIDs []string) error {
	jsonData, err := json.Marshal(friendIDs)
	if err != nil {
		return err
	}
	u.FriendIDs = jsonData
	return nil
}

// 获取好友ID列表
func (u *User) GetFriendIDs() ([]string, error) {
	var friends []string
	if len(u.FriendIDs) == 0 {
		return friends, nil
	}
	err := json.Unmarshal(u.FriendIDs, &friends)
	return friends, err
}

// 添加好友
func (u *User) AddFriend(friendID string) error {
	friends, err := u.GetFriendIDs()
	if err != nil {
		return fmt.Errorf("获取好友列表失败: %v", err)
	}

	// 检查是否已是好友
	for _, id := range friends {
		if id == friendID {
			return fmt.Errorf("该用户已是好友")
		}
	}

	// 添加新好友
	friends = append(friends, friendID)
	u.SetFriendIDs(friends)
	return u.UpdateFriends(friends)
}

// 删除好友
func (u *User) RemoveFriend(friendID string) error {
	friends, err := u.GetFriendIDs()
	if err != nil {
		return fmt.Errorf("获取好友列表失败: %v", err)
	}

	// 查找并删除
	newFriends := make([]string, 0, len(friends))
	found := false
	for _, id := range friends {
		if id == friendID {
			found = true
			continue
		}
		newFriends = append(newFriends, id)
	}

	if !found {
		return fmt.Errorf("该用户不是好友")
	}
	u.SetFriendIDs(newFriends)
	return u.UpdateFriends(newFriends)
}

// 更新好友列表(内部方法)
func (u *User) UpdateFriends(friends []string) error {
	// 1. 转换为JSON
	jsonData, err := json.Marshal(friends)
	if err != nil {
		return fmt.Errorf("JSON编码失败: %v", err)
	}

	// 2. 更新数据库
	_, err = mysqlmgr.Update(`
        UPDATE users 
        SET friend_ids = ? 
        WHERE user_id = ?`,
		jsonData,
		u.UserID,
	)
	if err != nil {
		return fmt.Errorf("数据库更新失败: %v", err)
	}

	// 3. 更新内存数据
	u.FriendIDs = jsonData
	return nil
}
func (u *User) UpdateFriendsToDB() error {
	_, err := mysqlmgr.Update(`
        UPDATE users 
        SET friend_ids = ? 
        WHERE user_id = ?`,
		u.FriendIDs, // 使用已转换的JSON数据
		u.UserID,
	)
	if err != nil {
		return fmt.Errorf("数据库更新失败: %v", err)
	}
	return nil
}

func GetUserCount() (int, error) {
	var count int
	// 使用QueryRow查询COUNT(*)
	err := mysqlmgr.QueryRow("SELECT COUNT(*) FROM users").Scan(&count)
	if err != nil {
		return 0, fmt.Errorf("查询用户总数失败: %v", err)
	}
	return count, nil
}

func InitOnlineStatus() error {
	_, err := mysqlmgr.Update(`
        UPDATE users 
        SET online_status = ? 
        WHERE online_status = ?`,
		0,
		1,
	)
	if err != nil {
		return fmt.Errorf("数据库更新失败: %v", err)
	}
	return nil
}
func UpdateCoinToDB(user_id string, coin int) error {
	_, err := mysqlmgr.Update(`
        UPDATE users 
        SET coin = ? 
        WHERE user_id = ?`,
		coin,
		user_id,
	)
	if err != nil {
		return fmt.Errorf("数据库更新失败: %v", err)
	}
	return nil
}

func UpdateOnlineStatusToDB(user_id string, online_status int32) error {
	_, err := mysqlmgr.Update(`
        UPDATE users 
        SET online_status = ? 
        WHERE user_id = ?`,
		online_status,
		user_id,
	)
	if err != nil {
		return fmt.Errorf("数据库更新失败: %v", err)
	}
	return nil
}

// GetAllFriend 获取用户的所有好友信息
func (u *User) GetAllFriend() ([]*User, error) {
	// 1. 获取好友ID列表
	friendIDs, err := u.GetFriendIDs()
	if err != nil {
		return nil, fmt.Errorf("获取好友ID列表失败: %v", err)
	}

	// 如果没有好友，直接返回空列表
	if len(friendIDs) == 0 {
		return []*User{}, nil
	}

	// 2. 构建查询参数 (?,?,?...)
	placeholders := strings.Repeat("?,", len(friendIDs)-1) + "?"
	args := make([]interface{}, len(friendIDs))
	for i, id := range friendIDs {
		args[i] = id
	}

	// 3. 执行查询
	query := fmt.Sprintf(`
        SELECT id, create_time, user_id, friend_ids, head, coin, name, account ,online_status
        FROM users 
        WHERE user_id IN (%s)`, placeholders)

	rows, err := mysqlmgr.Query(query, args...)
	if err != nil {
		return nil, fmt.Errorf("查询好友信息失败: %v", err)
	}
	defer rows.Close()

	// 4. 解析结果
	var friends []*User
	for rows.Next() {
		var friend User
		var nullTime sql.NullTime
		var friendData []byte
		err := rows.Scan(
			&friend.ID,
			&nullTime,
			&friend.UserID,
			&friendData,
			&friend.Head,
			&friend.Coin,
			&friend.Name,
			&friend.Account,
			&friend.OnlineStatus,
		)
		if err != nil {
			return nil, fmt.Errorf("解析好友数据失败: %v", err)
		}

		// 处理可能的NULL时间
		if nullTime.Valid {
			friend.CreateTime = nullTime.Time
		}
		// 处理 NULL 值
		if friendData != nil {
			friend.FriendIDs = json.RawMessage(friendData)
		} else {
			friend.FriendIDs = json.RawMessage("[]") // 默认空数组
		}
		friends = append(friends, &friend)
	}

	// 5. 检查遍历过程中是否出错
	if err = rows.Err(); err != nil {
		return nil, fmt.Errorf("结果遍历失败: %v", err)
	}

	return friends, nil
}
