package worker

import (
	"context"
	"time"

	"go.uber.org/zap"

	"git.techease.ru/Smart-search/smart-search-back/internal/repository"
)

type SessionCleaner struct {
	sessionRepo repository.SessionRepository
	ctx         context.Context
	ticker      *time.Ticker
	done        chan bool
	logger      *zap.Logger
}

func NewSessionCleaner(ctx context.Context, sessionRepo repository.SessionRepository, logger *zap.Logger) *SessionCleaner {
	return &SessionCleaner{
		sessionRepo: sessionRepo,
		ctx:         ctx,
		done:        make(chan bool),
		logger:      logger,
	}
}

func (w *SessionCleaner) Start() {
	w.ticker = time.NewTicker(1 * time.Hour)

	w.cleanExpiredSessions()

	go func() {
		for {
			select {
			case <-w.ticker.C:
				w.cleanExpiredSessions()
			case <-w.done:
				return
			case <-w.ctx.Done():
				w.logger.Info("Session cleaner context cancelled, stopping worker")
				return
			}
		}
	}()

	w.logger.Info("Session cleaner worker started (runs every hour)")
}

func (w *SessionCleaner) Stop() {
	if w.ticker != nil {
		w.ticker.Stop()
	}
	select {
	case w.done <- true:
	default:
	}
	w.logger.Info("Session cleaner worker stopped")
}

func (w *SessionCleaner) cleanExpiredSessions() {
	count, err := w.sessionRepo.DeleteExpired(w.ctx)
	if err != nil {
		w.logger.Error("Error cleaning expired sessions", zap.Error(err))
		return
	}

	if count > 0 {
		w.logger.Info("Cleaned expired sessions", zap.Int("count", count))
	}
}