Yimaru-BackEnd/internal/web_server/cron.go

package httpserver

import (
	"context"
	"time"

	"log"

	// "time"

	betSvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/bet"
	eventsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/event"
	oddssvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/odds"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/report"
	resultsvc "github.com/SamuelTariku/FortuneBet-Backend/internal/services/result"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/ticket"
	"github.com/robfig/cron/v3"
	"go.uber.org/zap"
)

func StartDataFetchingCrons(eventService eventsvc.Service, oddsService oddssvc.ServiceImpl, resultService *resultsvc.Service, mongoLogger *zap.Logger) {
	c := cron.New(cron.WithSeconds())

	schedule := []struct {
		spec string
		task func()
	}{
		// {
		// 	spec: "0 0 * * * *", // Every 1 hour
		// 	task: func() {
		// 		mongoLogger.Info("Began fetching upcoming events")
		// 		if err := eventService.FetchUpcomingEvents(context.Background()); err != nil {
		// 			mongoLogger.Error("Failed to fetch upcoming events",
		// 				zap.Error(err),
		// 			)
		// 		} else {
		// 			mongoLogger.Info("Successfully fetched upcoming events")
		// 		}
		// 	},
		// },
		// {
		// 	spec: "0 0 * * * *", // Every 1 hour (since its takes that long to fetch all the events)
		// 	task: func() {
		// 		mongoLogger.Info("Began fetching non live odds")
		// 		if err := oddsService.FetchNonLiveOdds(context.Background()); err != nil {
		// 			mongoLogger.Error("Failed to fetch non live odds",
		// 				zap.Error(err),
		// 			)
		// 		} else {
		// 			mongoLogger.Info("Successfully fetched non live odds")
		// 		}
		// 	},
		// },
		// {
		// 	spec: "0 */5 * * * *", // Every 5 Minutes
		// 	task: func() {
		// 		mongoLogger.Info("Began updating all expired events status")
		// 		if _, err := resultService.CheckAndUpdateExpiredEvents(context.Background()); err != nil {
		// 			mongoLogger.Error("Failed to update expired events status",
		// 				zap.Error(err),
		// 			)
		// 		} else {
		// 			mongoLogger.Info("Successfully updated expired events")
		// 		}
		// 	},
		// },
		// {
		// 	spec: "0 */15 * * * *", // Every 15 Minutes
		// 	task: func() {
		// 		mongoLogger.Info("Fetching results for upcoming events")
		// 		if err := resultService.FetchAndProcessResults(context.Background()); err != nil {
		// 			mongoLogger.Error("Failed to process result",
		// 				zap.Error(err),
		// 			)
		// 		} else {
		// 			mongoLogger.Info("Successfully processed all event result outcomes")
		// 		}
		// 	},
		// },
	}

	for _, job := range schedule {
		// job.task()
		if _, err := c.AddFunc(job.spec, job.task); err != nil {
			mongoLogger.Error("Failed to schedule data fetching cron job",
				zap.Error(err),
			)
		}
	}

	c.Start()
	log.Println("Cron jobs started for event and odds services")
	mongoLogger.Info("Cron jobs started for event and odds services")
}

func StartTicketCrons(ticketService ticket.Service, mongoLogger *zap.Logger) {
	c := cron.New(cron.WithSeconds())

	schedule := []struct {
		spec string
		task func()
	}{
		{
			spec: "0 0 * * * *", // Every hour
			task: func() {
				mongoLogger.Info("Deleting old tickets")
				if err := ticketService.DeleteOldTickets(context.Background()); err != nil {
					mongoLogger.Error("Failed to remove old ticket",
						zap.Error(err),
					)
				} else {
					mongoLogger.Info("Successfully deleted old tickets")
				}
			},
		},
	}

	for _, job := range schedule {
		if _, err := c.AddFunc(job.spec, job.task); err != nil {
			mongoLogger.Error("Failed to schedule ticket cron job",
				zap.Error(err),
			)
		}
	}

	c.Start()
	mongoLogger.Info("Cron jobs started for ticket service")
}

// SetupReportCronJobs schedules periodic report generation
func SetupReportCronJobs(ctx context.Context, reportService *report.Service, outputDir string) {
	c := cron.New(cron.WithSeconds()) // use WithSeconds for testing

	schedule := []struct {
		spec   string
		period string
	}{
		// {
		// 	spec:   "*/60 * * * * *", // Every 5 minutes
		// 	period: "5min",
		// },
		{
			spec:   "0 0 0 * * *", // Daily at midnight
			period: "daily",
		},
		{
			spec:   "0 0 1 * * 0", // Weekly: Sunday at 1 AM
			period: "weekly",
		},
		{
			spec:   "0 0 2 1 * *", // Monthly: 1st day of month at 2 AM
			period: "monthly",
		},
	}

	for _, job := range schedule {
		period := job.period

		if _, err := c.AddFunc(job.spec, func() {
			now := time.Now()
			var from, to time.Time

			switch period {
			// case "5min":
			// 	from = now.Add(-5 * time.Minute)
			// 	to = now
			case "daily":
				from = time.Date(now.Year(), now.Month(), now.Day()-1, 0, 0, 0, 0, now.Location())
				to = time.Date(now.Year(), now.Month(), now.Day()-1, 23, 59, 59, 0, now.Location())
			case "weekly":
				// last Sunday -> Saturday
				weekday := int(now.Weekday())
				daysSinceSunday := (weekday + 7) % 7
				from = time.Date(now.Year(), now.Month(), now.Day()-daysSinceSunday-7, 0, 0, 0, 0, now.Location())
				to = from.AddDate(0, 0, 6).Add(time.Hour*23 + time.Minute*59 + time.Second*59)
			case "monthly":
				firstOfMonth := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
				from = firstOfMonth.AddDate(0, -1, 0)
				to = firstOfMonth.Add(-time.Second)
			default:
				log.Printf("Unknown period: %s", period)
				return
			}

			log.Printf("Running %s report for period %s -> %s", period, from.Format(time.RFC3339), to.Format(time.RFC3339))

			if err := reportService.GenerateReport(ctx, from, to); err != nil {
				log.Printf("Error generating %s report: %v", period, err)
			} else {
				log.Printf("Successfully generated %s report", period)
			}
		}); err != nil {
			log.Fatalf("Failed to schedule %s report cron job: %v", period, err)
		}
	}

	c.Start()
	log.Printf("Cron jobs started. Reports will be saved to: %s", outputDir)
}

func ProcessBetCashback(ctx context.Context, betService *betSvc.Service) {
	c := cron.New(cron.WithSeconds())

	schedule := []struct {
		spec string
		task func()
	}{
		{
			spec: "0 0 0 * * *", // Daily at midnight
			task: func() {
				log.Println("process bet cashbacks...")
				if err := betService.ProcessBetCashback(ctx); err != nil {
					log.Printf("Failed to process bet cashbacks: %v", err)
				} else {
					log.Printf("Successfully processed bet cashbacks")
				}
			},
		},
	}

	for _, job := range schedule {
		if _, err := c.AddFunc(job.spec, job.task); err != nil {
			log.Fatalf("Failed to schedule cron job: %v", err)
		}
	}

	c.Start()
	log.Println("Cron jobs started for bet cashbacks")
}