package session

import (
	"context"
	"time"

	"management/internal/pkg/redis"
)

var (
	storePrefix       = "scs:session:"
	ctx               = context.Background()
	DefaultRedisStore = newRedisStore()
)

type redisStore struct{}

func newRedisStore() *redisStore {
	return &redisStore{}
}

// Delete should remove the session token and corresponding data from the
// session store. If the token does not exist then Delete should be a no-op
// and return nil (not an error).
func (s *redisStore) Delete(token string) error {
	return redis.Del(ctx, storePrefix+token)
}

// Find should return the data for a session token from the store. If the
// session token is not found or is expired, the found return value should
// be false (and the err return value should be nil). Similarly, tampered
// or malformed tokens should result in a found return value of false and a
// nil err value. The err return value should be used for system errors only.
func (s *redisStore) Find(token string) (b []byte, found bool, err error) {
	val, err := redis.GetBytes(ctx, storePrefix+token)
	if err != nil {
		return nil, false, err
	} else {
		return val, true, nil
	}
}

// Commit should add the session token and data to the store, with the given
// expiry time. If the session token already exists, then the data and
// expiry time should be overwritten.
func (s *redisStore) Commit(token string, b []byte, expiry time.Time) error {
	// TODO: 这边可以调整时间
	exp, err := time.ParseInLocation(time.DateTime, time.Now().Format("2006-01-02")+" 23:59:59", time.Local)
	if err != nil {
		return err
	}

	t := time.Now()
	expired := exp.Sub(t)
	return redis.Set(ctx, storePrefix+token, b, expired)
}

// All should return a map containing data for all active sessions (i.e.
// sessions which have not expired). The map key should be the session
// token and the map value should be the session data. If no active
// sessions exist this should return an empty (not nil) map.
func (s *redisStore) All() (map[string][]byte, error) {
	sessions := make(map[string][]byte)

	iter := redis.Scan(ctx, 0, storePrefix+"*", 0).Iterator()
	for iter.Next(ctx) {
		key := iter.Val()
		token := key[len(storePrefix):]
		data, exists, err := s.Find(token)
		if err != nil {
			return nil, err
		}

		if exists {
			sessions[token] = data
		}
	}
	if err := iter.Err(); err != nil {
		return nil, err
	}

	return sessions, nil
}