package cache

import (
	"context"
	"crypto/sha1"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"time"

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

	"secunda-test/internal/domain"
)

type TaskCache struct {
	client *redis.Client
	ttl    time.Duration
}

func NewTaskCache(client *redis.Client, ttl time.Duration) *TaskCache {
	return &TaskCache{client: client, ttl: ttl}
}

func (c *TaskCache) GetTasks(ctx context.Context, filter domain.TaskFilter) ([]domain.Task, bool, error) {
	data, err := c.client.Get(ctx, c.key(filter)).Bytes()
	if err == redis.Nil {
		return nil, false, nil
	}
	if err != nil {
		return nil, false, err
	}
	var tasks []domain.Task
	if err := json.Unmarshal(data, &tasks); err != nil {
		return nil, false, err
	}
	return tasks, true, nil
}

func (c *TaskCache) SetTasks(ctx context.Context, filter domain.TaskFilter, tasks []domain.Task) error {
	data, err := json.Marshal(tasks)
	if err != nil {
		return err
	}
	return c.client.Set(ctx, c.key(filter), data, c.ttl).Err()
}

func (c *TaskCache) DeleteTeam(ctx context.Context, teamID int64) error {
	iter := c.client.Scan(ctx, 0, fmt.Sprintf("tasks:team:%d:*", teamID), 100).Iterator()
	for iter.Next(ctx) {
		_ = c.client.Del(ctx, iter.Val()).Err()
	}
	return iter.Err()
}

func (c *TaskCache) key(filter domain.TaskFilter) string {
	raw, _ := json.Marshal(filter)
	sum := sha1.Sum(raw)
	return fmt.Sprintf("tasks:team:%d:%s", filter.TeamID, hex.EncodeToString(sum[:]))
}