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"
)

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

	schedule := []struct {
		spec string
		task func()
	}{
		// {
		// 	spec: "0 0 * * * *", // Every 1 hour
		// 	task: func() {
		// 		if err := eventService.FetchUpcomingEvents(context.Background()); err != nil {
		// 			log.Printf("FetchUpcomingEvents error: %v", err)
		// 		}
		// 	},
		// },
		// {
		// 	spec: "0 0 * * * *", // Every 1 hour (since its takes that long to fetch all the events)
		// 	task: func() {
		// 		if err := oddsService.FetchNonLiveOdds(context.Background()); err != nil {
		// 			log.Printf("FetchNonLiveOdds error: %v", err)
		// 		}
		// 	},
		// },
		{
			spec: "0 */5 * * * *", // Every 5 Minutes
			task: func() {
				log.Println("Updating expired events status...")

				if _, err := resultService.CheckAndUpdateExpiredEvents(context.Background()); err != nil {
					log.Printf("Failed to update events: %v", err)
				} else {
					log.Printf("Successfully updated expired events")
				}
			},
		},
		{
			spec: "0 */15 * * * *", // Every 15 Minutes
			task: func() {
				log.Println("Fetching results for upcoming events...")

				if err := resultService.FetchAndProcessResults(context.Background()); err != nil {
					log.Printf("Failed to process result: %v", err)
				} else {
					log.Printf("Successfully processed all outcomes")
				}
			},
		},
	}

	for _, job := range schedule {
		// job.task()
		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 event and odds services")
}

func StartTicketCrons(ticketService ticket.Service) {
	c := cron.New(cron.WithSeconds())

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

	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 ticket service")
}

func SetupReportCronJobs(ctx context.Context, reportService *report.Service) {
	c := cron.New(cron.WithSeconds()) // use WithSeconds for tighter intervals during testing

	schedule := []struct {
		spec   string
		period string
	}{
		// {
		// 	spec:   "*/300 * * * * *", // Every 5 minutes (300 seconds)
		// 	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() {
			log.Printf("Running %s report at %s", period, time.Now().Format(time.RFC3339))
			if err := reportService.GenerateReport(ctx, period); 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.Println("Cron jobs started for report generation service")
}

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")
}