package domain

import (
	"testing"

	"git.cin.su/m/Assistant/contracts/capability"
)

func TestRateCognitiveBindingRequiresSupportedEvidence(t *testing.T) {
	rating := RateCognitiveBinding(capability.ResolvedCognitiveBinding{})
	if rating.Category != capability.ModelRatingUnrated || rating.OverallScoreMillis != 0 {
		t.Fatalf("rating=%+v", rating)
	}
}

func TestRateCognitiveBindingUsesEvidenceNotProviderName(t *testing.T) {
	quality, critical, latency := int64(900), int64(0), int64(400_000)
	base := capability.ResolvedCognitiveBinding{
		Provider:    capability.ProviderInstance{Kind: "openai-compatible-chat-v1"},
		Evaluation:  &capability.EvaluatedCapability{Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
		Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
	}
	other := base
	other.Provider.Kind = "ollama-v1"
	left, right := RateCognitiveBinding(base), RateCognitiveBinding(other)
	if left != right || left.Category != capability.ModelRatingQuality {
		t.Fatalf("provider changed rating: left=%+v right=%+v", left, right)
	}
}

func TestRateCognitiveBindingClassifiesSlowEvidenceAsBalanced(t *testing.T) {
	quality, critical, latency := int64(800), int64(0), int64(20_000_000)
	rating := RateCognitiveBinding(capability.ResolvedCognitiveBinding{
		Evaluation:  &capability.EvaluatedCapability{Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
		Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
	})
	if rating.Category != capability.ModelRatingBalanced || rating.LatencyScoreMillis != 200 {
		t.Fatalf("rating=%+v", rating)
	}
}

func TestSelectionExcludesFreshUnavailableQualificationButNotStaleEvidence(t *testing.T) {
	quality, critical := int64(900), int64(0)
	base := capability.ResolvedCognitiveBinding{
		Binding:       capability.CognitiveBinding{ID: "binding-qualification", Revision: 1, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: "provider", ProviderRevision: 1, ModelDescriptorID: "model", ModelRevision: 1, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits"},
		Provider:      capability.ProviderInstance{ID: "provider", Revision: 1, Kind: "local", EndpointRef: "endpoint", Enabled: true, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 20},
		Model:         capability.ModelDescriptor{ID: "model", Revision: 1, ProviderInstanceID: "provider", ProviderModelID: "model", MaxContextBytes: 1000, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 20},
		Evaluation:    &capability.EvaluatedCapability{ID: "evaluation", BindingID: "binding-qualification", BindingRevision: 1, CapabilityID: "creator-advisory", Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
		Qualification: &capability.ModelQualificationObservation{ID: "observation", ProviderInstanceID: "provider", ProviderModelID: "model", Status: capability.ModelQualificationUnavailable, FinishReason: "TIMEOUT", ObservedAtUnixMillis: 20, Category: capability.ModelRatingUnrated},
	}
	requirement := capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyLocalOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, MaxOutputBytes: 10}
	if _, err := SelectCognitiveBinding(requirement, []capability.ResolvedCognitiveBinding{base}); err == nil {
		t.Fatal("fresh unavailable qualification should exclude candidate")
	}
	base.Qualification.ObservedAtUnixMillis = 19
	if _, err := SelectCognitiveBinding(requirement, []capability.ResolvedCognitiveBinding{base}); err != nil {
		t.Fatalf("stale unavailable qualification should not exclude candidate: %v", err)
	}
}