package handlers

import (
	"github.com/gin-gonic/gin"
	"github.com/jackc/pgx/v5/pgxpool"
	"ticketing-backend/internal/services"
	"ticketing-backend/internal/utils"
)

type CronHandler struct {
	pool         *pgxpool.Pool
	orderService *services.OrderService
	queueService *services.QueueService
}

func NewCronHandler(pool *pgxpool.Pool, orderService *services.OrderService, queueService *services.QueueService) *CronHandler {
	return &CronHandler{pool: pool, orderService: orderService, queueService: queueService}
}

func (h *CronHandler) CleanupExpired(c *gin.Context) {
	// Release expired order locks
	rows, err := h.pool.Query(c.Request.Context(),
		`SELECT DISTINCT event_id FROM order_locks WHERE status = 'active' AND expires_at < NOW()`,
	)
	if err != nil {
		utils.InternalError(c, "Failed to find expired locks")
		return
	}
	defer rows.Close()

	var totalReleased int
	for rows.Next() {
		var eventID string
		rows.Scan(&eventID)
		released, _ := h.orderService.ReleaseExpiredLocks(eventID)
		totalReleased += released
	}

	// Process expired queue sessions
	var totalExpired int
	eventRows, err := h.pool.Query(c.Request.Context(),
		`SELECT DISTINCT event_id FROM queue_entries WHERE status = 'active' AND expires_at < NOW()`,
	)
	if err == nil {
		defer eventRows.Close()
		for eventRows.Next() {
			var eventID string
			eventRows.Scan(&eventID)
			expired, _ := h.queueService.ProcessExpiredSessions(eventID)
			totalExpired += expired
		}
	}

	// Cancel expired orders
	orderResult, _ := h.pool.Exec(c.Request.Context(),
		`UPDATE orders SET status = 'expired', updated_at = NOW()
		 WHERE status = 'pending' AND created_at < NOW() - INTERVAL '24 hours'`,
	)
	cancelledOrders := orderResult.RowsAffected()

	utils.Success(c, gin.H{
		"locksReleased":      totalReleased,
		"queueSessionsExpired": totalExpired,
		"ordersExpired":      cancelledOrders,
	})
}