package cache

import (
	"backend/internal/domain"
	"backend/pkg/cache"
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/redis/go-redis/v9"
)

type ChallengeRepository struct {
	redis *cache.Redis
}

func NewChallengeRepository(redis *cache.Redis) domain.ChallengeRepo {
	return &ChallengeRepository{
		redis: redis,
	}
}

func (r *ChallengeRepository) Create(ctx context.Context, pubKey string, challenge *domain.Challenge) error {
	key := r.getChallengeKey(pubKey)

	challengeData, err := json.Marshal(challenge)
	if err != nil {
		return fmt.Errorf("failed to marshal challenge: %w", err)
	}

	ttl := time.Until(challenge.ExpiresAt)
	if ttl <= 0 {
		return fmt.Errorf("challenge already expired")
	}

	if err := r.redis.Client().Set(ctx, key, challengeData, ttl).Err(); err != nil {
		return fmt.Errorf("failed to store challenge in Redis: %w", err)
	}

	return nil
}

func (r *ChallengeRepository) GetByPubKey(ctx context.Context, pubKey string) (*domain.Challenge, error) {
	key := r.getChallengeKey(pubKey)

	result, err := r.redis.Client().Get(ctx, key).Result()
	if err != nil {
		if err == redis.Nil {
			return nil, fmt.Errorf("challenge not found")
		}
		return nil, fmt.Errorf("failed to get challenge from Redis: %w", err)
	}

	var challenge domain.Challenge
	if err := json.Unmarshal([]byte(result), &challenge); err != nil {
		return nil, fmt.Errorf("failed to unmarshal challenge: %w", err)
	}

	if challenge.IsExpired() {
		r.Delete(ctx, pubKey)
		return nil, fmt.Errorf("challenge expired")
	}

	return &challenge, nil
}

func (r *ChallengeRepository) Delete(ctx context.Context, pubKey string) error {
	key := r.getChallengeKey(pubKey)

	if err := r.redis.Client().Del(ctx, key).Err(); err != nil {
		return fmt.Errorf("failed to delete challenge from Redis: %w", err)
	}

	return nil
}

func (r *ChallengeRepository) getChallengeKey(pubKey string) string {
	return fmt.Sprintf("challenge:%s", pubKey)
}