package app

import (
	"sync"
	"time"

	"git.alecodes.page/alecodes/miniflux-archiver/internal/logger"
	"git.alecodes.page/alecodes/miniflux-archiver/internal/miniflux"
	"git.alecodes.page/alecodes/miniflux-archiver/internal/service"
)

// NewRateLimiter creates a rate limiter that emits time events at a specified rate.
// request_per specifies the number of requests allowed per time_scale duration.
// time_scale specifies the duration over which the requests are allowed.
func newRateLimiter(request_per int, time_scale time.Duration) <-chan time.Time {
	rate_limit := make(chan time.Time, request_per)
	tickrate := time_scale / time.Duration(request_per)

	for range request_per {
		rate_limit <- time.Now()
	}

	go func() {
		for t := range time.Tick(tickrate) {
			rate_limit <- t
		}
	}()

	return rate_limit
}

func Archive(minifluxConfig miniflux.MinifluxConfig, serviceConfig service.ServiceConfig) {
	mf, err := miniflux.NewMiniflux(minifluxConfig)
	if err != nil {
		logger.Fatal("Could not connect to the miniflux server: %v", err)
	}

	externalService, err := service.ResolveService(serviceConfig)
	if err != nil {
		logger.Fatal(err.Error())
	}

	result, err := mf.GetEntries()
	if err != nil {
		logger.Fatal("Could not retrieve entries from the miniflux feed: %v", err)
	}

	var wg sync.WaitGroup
	ticker := newRateLimiter(5, 10*time.Second)

	for _, entry := range result.Entries {
		wg.Add(1)

		go func() {
			defer wg.Done()
			<-ticker

			// logger.Debug("Sending url \"%v\" to be marked as read", entry.URL)
			err := externalService.Archive(entry.URL)
			if err != nil {
				logger.Fatal("Could not archive url \"%v\" from the service: %v", entry.URL, err)
			}

			logger.Info("Url \"%v\" has been marked as read", entry.URL)
		}()
	}

	wg.Wait()
}