package config

import (
	"context"
	"fmt"
	"log"
	"sync"
	"time"

	"git.kundeng.us/phoenix/textsender-models/tx0/token"

	"git.kundeng.us/phoenix/catapult/internal/app"
	"git.kundeng.us/phoenix/catapult/internal/auth"
)

type Service struct {
	wg     sync.WaitGroup
	ctx    context.Context
	cancel context.CancelFunc
	App    *app.App
	token  *token.Login
}

func NewService(application *app.App) *Service {
	ctx, cancel := context.WithCancel(context.Background())
	return &Service{
		ctx:    ctx,
		cancel: cancel,
		App:    application,
	}
}

func (s *Service) Start() {
	log.Println("Starting service...")

	// Start multiple background workers
	s.wg.Add(3)
	go s.worker1()
	go s.worker2()
	go s.healthChecker()
}

func (s *Service) worker1() {
	defer s.wg.Done()

	ticker := time.NewTicker(5 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-s.ctx.Done():
			log.Println("Worker 1 shutting down...")
			return
		case <-ticker.C:
			// Do some work
			log.Println("Worker 1: Processing...")
			if s.token == nil {
				catapultAuth := auth.Auth{Application: s.App}
				if token, err := catapultAuth.GetToken(); err != nil {
					fmt.Println("Error:", err)
				} else {
					fmt.Println("Access token:", token.AccessToken)
					s.token = token
				}
			}
		}
	}
}

func (s *Service) worker2() {
	defer s.wg.Done()

	ticker := time.NewTicker(10 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-s.ctx.Done():
			log.Println("Worker 2 shutting down...")
			return
		case <-ticker.C:
			// Do some work
			log.Println("Worker 2: Processing...")
		}
	}
}

func (s *Service) healthChecker() {
	defer s.wg.Done()

	ticker := time.NewTicker(30 * time.Second)
	defer ticker.Stop()

	for {
		select {
		case <-s.ctx.Done():
			log.Println("Health checker shutting down...")
			return
		case <-ticker.C:
			log.Println("Health check: Service is healthy")
		}
	}
}

func (s *Service) Stop() {
	log.Println("Shutting down service...")
	s.cancel()
	s.wg.Wait()
	log.Println("Service stopped gracefully")
}