package service

import (
	"errors"

	"github.com/sirupsen/logrus"
	"golang.org/x/crypto/bcrypt"
	"myschools.me/heritage/heritage-api/model"
	"myschools.me/heritage/heritage-api/mysql"
)

// UserCreateRequest 创建用户请求
type UserCreateRequest struct {
	UserName string `json:"userName" binding:"required"`
	Password string `json:"password" binding:"required"`
	RoleID   string `json:"roleId" binding:"required"`
	OrgID    string `json:"orgId" binding:"required"`
}

// UserUpdateRequest 更新用户请求
type UserUpdateRequest struct {
	UserName string `json:"userName"`
	RoleID   string `json:"roleId"`
	OrgID    string `json:"orgId"`
}

// UserPasswordUpdateRequest 更新密码请求
type UserPasswordUpdateRequest struct {
	OldPassword string `json:"oldPassword" binding:"required"`
	NewPassword string `json:"newPassword" binding:"required"`
}

// UserResponse 用户响应
type UserResponse struct {
	User *model.User `json:"user"`
}

// UserListResponse 用户列表响应
type UserListResponse struct {
	Users []model.User `json:"users"`
	Total int64        `json:"total"`
}

// UserCreate 创建用户
func UserCreate(req UserCreateRequest) (*model.User, error) {
	// 检查用户名是否已存在
	existingUser, err := mysql.UserByUserName(&req.UserName)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserCreate",
		}).Warnf("mysql.UserByUserName: %v", err)
		return nil, err
	}
	if existingUser != nil && existingUser.ID != "" {
		return nil, errors.New("用户名已存在")
	}

	// 密码加密
	h, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserCreate",
		}).Warnf("bcrypt.GenerateFromPassword: %v", err)
		return nil, err
	}

	// 创建用户
	user := &model.User{
		ID:           newUserID(),
		UserName:     req.UserName,
		PasswordHash: string(h),
		RoleID:       req.RoleID,
		OrgID:        req.OrgID,
	}

	createdUser, err := mysql.UserCreate(user)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserCreate",
		}).Warnf("mysql.UserCreate: %v", err)
		return nil, err
	}

	return createdUser, nil
}

// UserUpdate 更新用户
func UserUpdate(userID string, req UserUpdateRequest) (*model.User, error) {
	// 检查用户是否存在
	existingUser, err := mysql.UserFirst(&userID)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserUpdate",
		}).Warnf("mysql.UserFirst: %v", err)
		return nil, err
	}
	if existingUser.ID == "" {
		return nil, errors.New("用户不存在")
	}

	// 检查用户名是否已被其他用户使用
	if req.UserName != "" && req.UserName != existingUser.UserName {
		otherUser, err := mysql.UserByUserName(&req.UserName)
		if err != nil {
			logrus.WithFields(logrus.Fields{
				"func": "UserUpdate",
			}).Warnf("mysql.UserByUserName: %v", err)
			return nil, err
		}
		if otherUser != nil && otherUser.ID != userID {
			return nil, errors.New("用户名已存在")
		}
	}

	// 构建更新数据
	updateData := make(map[string]any)
	if req.UserName != "" {
		updateData["user_name"] = req.UserName
	}
	if req.RoleID != "" {
		updateData["role_id"] = req.RoleID
	}
	if req.OrgID != "" {
		updateData["org_id"] = req.OrgID
	}

	// 更新用户
	if err := mysql.UserUpdate(&userID, updateData); err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserUpdate",
		}).Warnf("mysql.UserUpdate: %v", err)
		return nil, err
	}

	// 获取更新后的用户
	updatedUser, err := mysql.UserFirst(&userID)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserUpdate",
		}).Warnf("mysql.UserFirst: %v", err)
		return nil, err
	}
	if updatedUser.ID == "" {
		return nil, errors.New("用户不存在")
	}

	return updatedUser, nil
}

// UserDelete 删除用户
func UserDelete(userID string) (bool, error) {
	// 检查用户是否存在
	existingUser, err := mysql.UserFirst(&userID)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserDelete",
		}).Warnf("mysql.UserFirst: %v", err)
		return false, err
	}
	if existingUser.ID == "" {
		return false, errors.New("用户不存在")
	}

	// 这里可以添加删除用户的逻辑
	// 例如：软删除或硬删除
	// 由于当前 mysql 包中没有提供删除用户的函数，我们可以先返回一个错误
	return false, errors.New("删除用户功能暂未实现")
}

// UserGet 获取用户
func UserGet(userID string) (*model.User, error) {
	// 检查用户是否存在
	user, err := mysql.UserFirst(&userID)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserGet",
		}).Warnf("mysql.UserFirst: %v", err)
		return nil, err
	}
	if user.ID == "" {
		return nil, errors.New("用户不存在")
	}

	return user, nil
}

// UserList 获取用户列表
func UserList(page, pageSize int) ([]model.User, int64, error) {
	// 获取所有用户
	users, total, err := mysql.UserList(page, pageSize, nil)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserList",
		}).Warnf("mysql.UserList: %v", err)
		return nil, 0, err
	}

	return users, total, nil
}

// UserPasswordUpdate 更新用户密码
func UserPasswordUpdate(userID string, req UserPasswordUpdateRequest) error {
	// 检查用户是否存在
	user, err := mysql.UserFirst(&userID)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserPasswordUpdate",
		}).Warnf("mysql.UserFirst: %v", err)
		return err
	}
	if user.ID == "" {
		return errors.New("用户不存在")
	}

	// 验证旧密码
	err = bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(req.OldPassword))
	if err != nil {
		return errors.New("旧密码错误")
	}

	// 密码加密
	h, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserPasswordUpdate",
		}).Warnf("bcrypt.GenerateFromPassword: %v", err)
		return err
	}

	// 更新密码
	err = mysql.UserUpdate(&userID, map[string]any{"password_hash": string(h)})
	if err != nil {
		logrus.WithFields(logrus.Fields{
			"func": "UserPasswordUpdate",
		}).Warnf("mysql.UserUpdate: %v", err)
		return err
	}

	return nil
}