package capability

type IntelligencePath string

const (
	PathRule        IntelligencePath = "RULE"
	PathReflex      IntelligencePath = "REFLEX"
	PathSkill       IntelligencePath = "SKILL"
	PathSmallLocal  IntelligencePath = "SMALL_LOCAL"
	PathStrongLocal IntelligencePath = "STRONG_LOCAL"
	PathExternal    IntelligencePath = "EXTERNAL"
	PathResearch    IntelligencePath = "RESEARCH"
	PathTeam        IntelligencePath = "TEAM"
)

type StrategyRequest struct {
	RequiredQuality   int64
	PreferLowLatency  bool
	CostBudgetMicros  int64
	RiskClass         string
	FreshnessRequired bool
	CostOfError       int64
}
type StrategyDecision struct {
	Path     IntelligencePath
	Reason   string
	Escalate bool
}

// StrategyEligibility is supplied by Capability lifecycle resolution. It keeps
// a requested cheap route from becoming an entitlement to use stale evidence.
type StrategyEligibility struct {
	RuleEligible   bool
	ReflexEligible bool
	SkillEligible  bool
}

func (r StrategyRequest) Select() StrategyDecision {
	return r.SelectEligible(StrategyEligibility{RuleEligible: true, ReflexEligible: true, SkillEligible: true})
}

func (r StrategyRequest) SelectEligible(eligible StrategyEligibility) StrategyDecision {
	if r.RiskClass == "HIGH" || r.CostOfError >= 800 {
		return StrategyDecision{Path: PathStrongLocal, Reason: "high consequence requires deeper reasoning", Escalate: true}
	}
	if eligible.RuleEligible && r.RequiredQuality <= 500 && r.CostBudgetMicros > 0 {
		return StrategyDecision{Path: PathRule, Reason: "bounded low-risk path"}
	}
	if eligible.ReflexEligible && r.PreferLowLatency {
		return StrategyDecision{Path: PathReflex, Reason: "latency preference with later escalation"}
	}
	if eligible.SkillEligible {
		return StrategyDecision{Path: PathSkill, Reason: "validated reusable strategy"}
	}
	return StrategyDecision{Path: PathSmallLocal, Reason: "no eligible reflex or skill; escalate to reasoning", Escalate: true}
}