package share

import (
	"context"
	"time"

	"blazing/cool"

	"github.com/gogf/gf/v2/os/gctx"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/grand"
)

// newSessionStore 创建会话缓存实例
func newSessionStore() *cacheStore[uint32] {
	return &cacheStore[uint32]{
		manager: cool.CacheManager,
		prefix:  "blazing:session:",
	}
}

// newUserOnlineStore 创建用户在线状态缓存实例
func newUserOnlineStore() *cacheStore[uint16] {
	return &cacheStore[uint16]{
		manager: cool.CacheManager,
		prefix:  "blazing:useronline:",
	}
}

// newEmailCodeStore 创建邮件注册码缓存实例
func newEmailCodeStore() *cacheStore[int] {
	return &cacheStore[int]{
		manager: cool.CacheManager,
		prefix:  "blazing:email:code:",
	}
}

// sessionManager 会话管理器
type sessionManager struct {
	sessionStore    *cacheStore[uint32] // 会话缓存
	userOnlineStore *cacheStore[uint16] // 用户在线状态缓存
	emailCodeStore  *cacheStore[int]    // 邮件注册码缓存
}

// newSessionManager 创建会话管理器
func newSessionManager() *sessionManager {
	return &sessionManager{
		sessionStore:    newSessionStore(),
		userOnlineStore: newUserOnlineStore(),
		emailCodeStore:  newEmailCodeStore(),
	}
}

// GetSession 通过会话ID获取用户ID
func (m *sessionManager) GetSession(sessionID string) (uint32, error) {
	return m.sessionStore.Get(context.Background(), sessionID)
}

// SaveSession 保存会话信息
func (m *sessionManager) SaveSession(sessionID string, userID uint32) error {
	return m.sessionStore.Set(gctx.New(), sessionID, userID, time.Hour*1)
}

// DeleteSession 删除会话
func (m *sessionManager) DeleteSession(sessionID string) error {
	return m.sessionStore.Del(gctx.New(), sessionID)
}

// SessionExists 检查会话是否存在
func (m *sessionManager) SessionExists(sessionID string) (bool, error) {
	return m.sessionStore.Contains(context.Background(), sessionID)
}

// SetUserOnline 设置用户在线状态
func (m *sessionManager) SetUserOnline(userID uint32, serverID uint16) error {
	return m.userOnlineStore.Set(gctx.New(), gconv.String(userID), serverID, 0)
}

// GetUserOnline 获取用户在线状态
func (m *sessionManager) GetUserOnline(userID uint32) (uint16, error) {
	return m.userOnlineStore.Get(context.Background(), gconv.String(userID))
}

// DeleteUserOnline 删除用户在线状态
func (m *sessionManager) DeleteUserOnline(userID uint32) error {
	return m.userOnlineStore.Del(gctx.New(), gconv.String(userID))
}

// UserOnlineExists 检查用户在线状态是否存在
func (m *sessionManager) UserOnlineExists(userID uint32) (bool, error) {
	return m.userOnlineStore.Contains(context.Background(), gconv.String(userID))
}

// generate6DigitCode 生成6位数字注册码（100000-999999）
func (m *sessionManager) generate6DigitCode() int {
	// 初始化随机数生成器（确保每次调用生成不同序列）

	return grand.Intn(900000) + 100000
}

// SaveEmailCode 生成并保存邮件注册码（返回生成的验证码，支持设置过期时间）
func (m *sessionManager) SaveEmailCode(email string, expire time.Duration) (int, error) {
	code := m.generate6DigitCode()
	return code, m.emailCodeStore.Set(gctx.New(), email, code, expire)
}

// GetEmailCode 获取指定邮箱的注册码
func (m *sessionManager) GetEmailCode(email string) (int, error) {
	return m.emailCodeStore.Get(context.Background(), email)
}

// DeleteEmailCode 删除指定邮箱的注册码（验证成功后调用）
func (m *sessionManager) DeleteEmailCode(email string) error {
	return m.emailCodeStore.Del(gctx.New(), email)
}

// EmailCodeExists 检查指定邮箱是否存在有效的注册码
func (m *sessionManager) EmailCodeExists(email string) (bool, error) {
	return m.emailCodeStore.Contains(context.Background(), email)
}

// VerifyEmailCode 验证用户输入的注册码是否正确
func (m *sessionManager) VerifyEmailCode(email string, inputCode int) (bool, error) {
	storedCode, err := m.GetEmailCode(email)
	if err != nil {
		return false, err
	}
	return storedCode == inputCode, nil
}