package capability

type AdmissionComplexity string
type AdmissionDecisionState string
type AdmissionReason string

const (
	AdmissionSimple             AdmissionComplexity    = "SIMPLE"
	AdmissionNormal             AdmissionComplexity    = "NORMAL"
	AdmissionHeavy              AdmissionComplexity    = "HEAVY"
	AdmissionAdmitted           AdmissionDecisionState = "ADMITTED"
	AdmissionRejected           AdmissionDecisionState = "REJECTED"
	AdmissionReasonNone         AdmissionReason        = "NONE"
	AdmissionReasonConcurrency  AdmissionReason        = "CONCURRENCY_LIMIT"
	AdmissionReasonAcceptedHour AdmissionReason        = "ACCEPTED_PER_HOUR_LIMIT"
	AdmissionReasonDeadline     AdmissionReason        = "DEADLINE"
	AdmissionReasonInputBudget  AdmissionReason        = "INPUT_BUDGET"
	AdmissionReasonOutputBudget AdmissionReason        = "OUTPUT_BUDGET"
)

type AdmissionPolicy struct {
	ID                 string
	MaxConcurrent      int
	MaxAcceptedPerHour int
	MaxInputBytes      int
	MaxOutputBytes     int
}

type AdmissionRequest struct {
	Complexity     AdmissionComplexity `json:"complexity"`
	InputBytes     int                 `json:"input_bytes"`
	MaxOutputBytes int                 `json:"max_output_bytes"`
	DeadlineMillis int64               `json:"deadline_millis"`
}

type AdmissionCounters struct {
	Concurrent       int
	AcceptedLastHour int
}

type AdmissionDecision struct {
	State    AdmissionDecisionState `json:"state"`
	Reason   AdmissionReason        `json:"reason"`
	PolicyID string                 `json:"policy_id"`
}

type AdmissionLease struct {
	ID       string `json:"id"`
	PolicyID string `json:"policy_id"`
}

func Admit(request AdmissionRequest, policy AdmissionPolicy, counters AdmissionCounters, nowMillis int64) AdmissionDecision {
	decision := AdmissionDecision{State: AdmissionAdmitted, Reason: AdmissionReasonNone, PolicyID: policy.ID}
	if policy.ID == "" || policy.MaxConcurrent < 1 || policy.MaxAcceptedPerHour < 1 || policy.MaxInputBytes < 1 || policy.MaxOutputBytes < 1 {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonInputBudget, PolicyID: policy.ID}
	}
	if counters.Concurrent >= policy.MaxConcurrent {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonConcurrency, PolicyID: policy.ID}
	}
	if counters.AcceptedLastHour >= policy.MaxAcceptedPerHour {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonAcceptedHour, PolicyID: policy.ID}
	}
	if request.InputBytes < 0 || request.InputBytes > policy.MaxInputBytes {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonInputBudget, PolicyID: policy.ID}
	}
	if request.MaxOutputBytes < 1 || request.MaxOutputBytes > policy.MaxOutputBytes {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonOutputBudget, PolicyID: policy.ID}
	}
	if request.DeadlineMillis > 0 && request.DeadlineMillis <= nowMillis {
		return AdmissionDecision{State: AdmissionRejected, Reason: AdmissionReasonDeadline, PolicyID: policy.ID}
	}
	return decision
}