package scheduler

import (
	"sync/atomic"
)

// BackpressureManager tracks system load and provides admission control.
// Level 1 (70%): accept but log warning
// Level 2 (85%): accept only high priority (P0-P1)
// Level 3 (95%): reject all new requests
type BackpressureManager struct {
	maxRunning  int64
	maxQueued   int64
	level1Threshold float64
	level2Threshold float64
	level3Threshold float64

	runningCount int64 // atomic
	queuedCount  int64 // atomic
}

// NewBackpressureManager creates a new backpressure manager.
func NewBackpressureManager(maxRunning, maxQueued int, l1, l2, l3 float64) *BackpressureManager {
	return &BackpressureManager{
		maxRunning:      int64(maxRunning),
		maxQueued:       int64(maxQueued),
		level1Threshold: l1,
		level2Threshold: l2,
		level3Threshold: l3,
	}
}

// Update sets the current running and queued counts.
func (bp *BackpressureManager) Update(running, queued int) {
	atomic.StoreInt64(&bp.runningCount, int64(running))
	atomic.StoreInt64(&bp.queuedCount, int64(queued))
}

// LoadRatio returns the current system load ratio (0.0 to 1.0).
func (bp *BackpressureManager) LoadRatio() float64 {
	running := atomic.LoadInt64(&bp.runningCount)
	queued := atomic.LoadInt64(&bp.queuedCount)
	total := running + queued
	capacity := bp.maxRunning + bp.maxQueued
	if capacity == 0 {
		return 0
	}
	return float64(total) / float64(capacity)
}

// Level returns the current backpressure level (0=normal, 1=warning, 2=restricted, 3=reject).
func (bp *BackpressureManager) Level() int {
	load := bp.LoadRatio()
	if load >= bp.level3Threshold {
		return 3
	}
	if load >= bp.level2Threshold {
		return 2
	}
	if load >= bp.level1Threshold {
		return 1
	}
	return 0
}

// ShouldAccept decides whether to accept a request based on priority and load.
// priority: 0=P0(highest) to 4=P4(lowest)
func (bp *BackpressureManager) ShouldAccept(priority int) bool {
	level := bp.Level()
	switch level {
	case 0, 1:
		return true
	case 2:
		// Only accept P0 and P1
		return priority <= 1
	case 3:
		return false
	}
	return true
}

// RejectReason returns a human-readable reason if the request should be rejected.
func (bp *BackpressureManager) RejectReason(priority int) string {
	level := bp.Level()
	if level == 3 {
		return "system overloaded, please retry later"
	}
	if level == 2 && priority > 1 {
		return "backpressure active, only high-priority requests accepted"
	}
	return ""
}