package com.dacrt.SBIABackend.service;

import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Service;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.Refill;

@Configuration
@Service
public class RateLimiterService  {
	
	 private int capacity;

	 private int refill;

	 private int intervalMinutes;
	    
	 private int cacheExpireMinutes;
	    
	 private int cacheMaxSize;
	    
	    
	public RateLimiterService(
            @Value("${rate.limit.capacity}") int capacity,
            @Value("${rate.limit.refill}") int refill,
            @Value("${rate.limit.interval.minutes}") int intervalMinutes,
            @Value("${rate.limit.cache.expire.minutes:10}") int cacheExpireMinutes,
            @Value("${rate.limit.cache.max.size:10000}") int cacheMaxSize) {

        this.capacity = capacity;
        this.refill = refill;
        this.intervalMinutes = intervalMinutes;
        this.cacheExpireMinutes = cacheExpireMinutes;
        this.cacheMaxSize=cacheMaxSize;
	}
	
	
   
	private final Cache<String, Bucket> cache = Caffeine.newBuilder()
            .expireAfterAccess(10, TimeUnit.MINUTES)   // IPs inactivas se borran tras 10 min
            .maximumSize(10_000)                       // Máximo 10.000 IPs en memoria
            .build();

    public Bucket resolveBucket(String key) {
        return cache.get(key, this::newBucket);
    }

    private Bucket newBucket(String key) {
        Bandwidth limit = Bandwidth.classic(this.capacity, Refill.intervally(this.refill, Duration.ofMinutes(this.intervalMinutes)));
        return Bucket.builder()
                .addLimit(limit)
                .build();
    }
}