package cache

import (
	"context"
	"errors"
	"fmt"
	"net/url"
	"time"

	"github.com/go-redis/redis/v8"
	"github.com/loveuer/urbac/internal/tool"
)

func NewRedisCache(uri string) (Cache, error) {
	ins, err := url.Parse(uri)
	if err != nil {
		return nil, err
	}

	addr := ins.Host
	username := ins.User.Username()
	password, _ := ins.User.Password()

	var rc *redis.Client
	rc = redis.NewClient(&redis.Options{
		Addr:     addr,
		Username: username,
		Password: password,
	})

	if err = rc.Ping(tool.Timeout(5)).Err(); err != nil {
		return nil, fmt.Errorf("test redis failed: %w", err)
	}

	return &_redis{client: rc}, nil
}

type _redis struct {
	client *redis.Client
}

func (r *_redis) Get(ctx context.Context, key string) ([]byte, error) {
	result, err := r.client.Get(ctx, key).Result()
	if err != nil {
		if errors.Is(err, redis.Nil) {
			return nil, ErrorKeyNotFound
		}

		return nil, err
	}

	return []byte(result), nil
}

func (r *_redis) GetScan(ctx context.Context, key string) Scanner {
	return newScanner(r.Get(ctx, key))
}

func (r *_redis) GetEx(ctx context.Context, key string, duration time.Duration) ([]byte, error) {
	result, err := r.client.GetEx(ctx, key, duration).Result()
	if err != nil {
		if errors.Is(err, redis.Nil) {
			return nil, ErrorKeyNotFound
		}

		return nil, err
	}

	return []byte(result), nil
}

func (r *_redis) GetExScan(ctx context.Context, key string, duration time.Duration) Scanner {
	return newScanner(r.GetEx(ctx, key, duration))
}

func (r *_redis) Set(ctx context.Context, key string, value any) error {
	bs, err := handleValue(value)
	if err != nil {
		return err
	}

	_, err = r.client.Set(ctx, key, bs, redis.KeepTTL).Result()
	return err
}

func (r *_redis) SetEx(ctx context.Context, key string, value any, duration time.Duration) error {
	bs, err := handleValue(value)
	if err != nil {
		return err
	}

	_, err = r.client.SetEX(ctx, key, bs, duration).Result()

	return err
}

func (r *_redis) Del(ctx context.Context, keys ...string) error {
	return r.client.Del(ctx, keys...).Err()
}