package user

import (
	"busniess-user-center/config"
	"busniess-user-center/internal/models"
	"busniess-user-center/internal/repo"
	"busniess-user-center/pkg/redis"
	contextUtil "busniess-user-center/pkg/utils/context"
	stringUtil "busniess-user-center/pkg/utils/string"
	"busniess-user-center/pkg/utils/token"
	"context"
	"fmt"

	"github.com/samber/do"
	"go.uber.org/zap"
	"gorm.io/gorm"
)

const (
	COOKIE_KEY_TOKEN   = "token"
	COOKIE_KEY_ACCOUNT = "account"
	COOKIE_KEY_ID      = "id"
	saltLen            = 8
)

func init() {
	do.Provide(nil, NewUserService)
}

type userService struct {
	logger         *zap.SugaredLogger
	repo           repo.UserRepo
	redis          *redis.Redis
	conf           *config.AppConfig
	tokenRefresher *token.TokenRefresher
}

func NewUserService(i *do.Injector) (UserService, error) {
	return &userService{
		logger:         do.MustInvoke[*zap.SugaredLogger](i),
		repo:           do.MustInvoke[repo.UserRepo](i),
		redis:          do.MustInvoke[*redis.Redis](i),
		conf:           do.MustInvoke[*config.AppConfig](i),
		tokenRefresher: do.MustInvoke[*token.TokenRefresher](i),
	}, nil
}

func (u *userService) Add(ctx context.Context, info *models.AddInfo) (id uint, err error) {
	session, err := contextUtil.GetSession(ctx)
	if err != nil {
		return
	}

	// 判断手机号
	_, err = u.repo.GetUserByAccount(ctx, info.Account)
	if err != nil && err != gorm.ErrRecordNotFound {
		return
	}

	if err == nil {
		err = fmt.Errorf("用户%s已经存在", info.Account)
		return
	}

	// 判断账号,手机号是否唯一
	mUser, err := u.repo.GetUserByMobile(ctx, info.Mobile)
	if err != nil && err != gorm.ErrRecordNotFound {
		return
	}

	if err == nil {
		err = fmt.Errorf("手机号:%s的用户%s已经存在", info.Mobile, mUser.Account)
		return
	}

	// 邮箱
	eUser, err := u.repo.GetUserByEmail(ctx, info.Email)
	if err != nil && err != gorm.ErrRecordNotFound {
		return
	}

	if err == nil {
		err = fmt.Errorf("邮箱:%s的用户%s已经存在", info.Mobile, eUser.Account)
	}

	salt := stringUtil.RandStringRunes(saltLen)
	pwd := u.sha256(info.Pwd, salt)
	user := repo.User{
		Account:   info.Account,
		Name:      info.Name,
		Mobile:    info.Mobile,
		Email:     info.Email,
		Pwd:       pwd,
		Sex:       info.Sex,
		CreatedBy: session.Account,
	}

	err = u.repo.CreateUser(ctx, &user)
	id = user.ID
	return
}

func (u *userService) Login(ctx context.Context, info models.LoginInfo) error {
	// 通过account获取用户信息
	user, err := u.repo.GetUserByAccount(ctx, info.Account)
	if err == gorm.ErrRecordNotFound {
		return fmt.Errorf("%s用户不存在", info.Account)
	}

	if err != nil {
		return err
	}

	//输入的密码和加盐后sha256的值跟数据库的值比较
	pwd := u.sha256(info.Pwd, user.Salt)
	if user.Pwd != pwd {
		return fmt.Errorf("%s密码错误", info.Account)
	}

	// 生成token,写入redis
	claims := creteLoginTokenClaims(&user, u.conf.Jwt.Expires)
	return u.setLoginStatus(ctx, user, claims)
}

func (u *userService) LoginOut() error {
	// 获取当前用户信息
	// 删除redis缓存
	// remome cookie
	return nil
}

func (u *userService) Modify() error {
	// 获取当前操作用户
	// 判断修改用户是否是同一个人
	return nil
}

func (u *userService) Disable() error {
	// 获取操作用户
	// 判断是否有权限
	// 修改对应用户状态
	return nil
}

func (u *userService) Able() error {
	// 获取操作用户
	// 判断是否有权限
	// 修改对应用户状态
	return nil
}

func (u *userService) Users() error {
	// 获取操作用户
	// 判断是否有权限
	// 返回用户列表
	return nil
}

func (u *userService) ResetPwd() error {
	// 获取操作用户
	// 判断是否本人操作
	// 判断当前密码是否正确
	// 生成新的密码并保存
	// 删除旧的缓存
	return nil
}