package diagram

import (
	"context"
	"fmt"

	locker "modelRT/distributedlock"
	"modelRT/logger"

	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
)

// RedisSet defines the encapsulation struct of redis hash type
type RedisSet struct {
	ctx           context.Context
	rwLocker      *locker.RedissionRWLocker
	storageClient *redis.Client
	logger        *zap.Logger
}

// NewRedisSet define func of new redis set instance
func NewRedisSet(ctx context.Context, hashKey string, token string, lockLeaseTime uint64, needRefresh bool) *RedisSet {
	return &RedisSet{
		ctx:           ctx,
		rwLocker:      locker.InitRWLocker(hashKey, token, lockLeaseTime, needRefresh),
		storageClient: GetRedisClientInstance(),
		logger:        logger.GetLoggerInstance(),
	}
}

// SADD define func of add redis set by members
func (rs *RedisSet) SADD(setKey string, members ...interface{}) error {
	err := rs.rwLocker.WLock(rs.ctx)
	if err != nil {
		rs.logger.Error("lock wLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
		return err
	}
	defer rs.rwLocker.UnWLock(rs.ctx)

	err = rs.storageClient.SAdd(rs.ctx, setKey, members).Err()
	if err != nil {
		rs.logger.Error("add set by memebers failed", zap.String("setKey", setKey), zap.Any("members", members), zap.Error(err))
		return err
	}
	return nil
}

// SREM define func of remove the specified members from redis set by key
func (rs *RedisSet) SREM(setKey string, members ...interface{}) error {
	err := rs.rwLocker.WLock(rs.ctx)
	if err != nil {
		rs.logger.Error("lock wLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
		return err
	}
	defer rs.rwLocker.UnWLock(rs.ctx)

	count, err := rs.storageClient.SRem(rs.ctx, setKey, members).Result()
	if err != nil || count != int64(len(members)) {
		rs.logger.Error("rem members from set failed", zap.String("setKey", setKey), zap.Any("members", members), zap.Error(err))

		return fmt.Errorf("rem members from set failed:%w", err)
	}
	return nil
}

// SMembers define func of get all memebers from redis set by key
func (rs *RedisSet) SMembers(setKey string) ([]string, error) {
	err := rs.rwLocker.RLock(rs.ctx)
	if err != nil {
		rs.logger.Error("lock rLock by setKey failed", zap.String("setKey", setKey), zap.Error(err))
		return nil, err
	}
	defer rs.rwLocker.UnRLock(rs.ctx)

	result, err := rs.storageClient.SMembers(rs.ctx, setKey).Result()
	if err != nil {
		rs.logger.Error("get all hash field by hash key failed", zap.String("setKey", setKey), zap.Error(err))
		return nil, err
	}
	return result, nil
}

// SIsMember define func of determine whether an member is in set by key
func (rh *RedisHash) SIsMember(setKey string, member interface{}) (bool, error) {
	result, err := rh.storageClient.SIsMember(rh.ctx, setKey, member).Result()
	if err != nil {
		rh.logger.Error("get all hash field by hash key failed", zap.String("setKey", setKey), zap.Error(err))
		return false, err
	}
	return result, nil
}