package domain

import (
	"testing"

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

func TestBuildDiscoveryRegistrationCarriesObservedHealthToCanaryPrecondition(t *testing.T) {
	inputCost := int64(2)
	intelligence := int64(820)
	registration, err := BuildDiscoveryRegistration(capability.CognitiveDiscoverySnapshot{
		ProviderInstanceID:   "local-lifeboat",
		ProviderKind:         "openai-compatible-chat-v1",
		EndpointRef:          "local-lifeboat-v1",
		OwnerPrincipalID:     "domovoy-creator-principal",
		CapabilityID:         "creator-advisory",
		DataPolicy:           capability.DataPolicyLocalOnly,
		LimitPolicyRef:       "creator-advisory-local-v1",
		Health:               capability.HealthAvailable,
		ObservedAtUnixMillis: 1000,
		BillingMode:          capability.BillingPerInput,
		AuthMode:             capability.AuthKey,
		InputCostMicros:      &inputCost,
		Models: []capability.DiscoveredModelSnapshot{{
			ProviderModelID:         "domovoy-lifeboat",
			Fingerprint:             "fingerprint",
			MaxContextBytes:         32768,
			Modalities:              []capability.ModelModality{capability.ModalityText},
			Capabilities:            []capability.ModelCapability{capability.CapabilityAdvisory},
			Installed:               capability.OperationalYes,
			Loaded:                  capability.OperationalNotObserved,
			Invokable:               capability.OperationalYes,
			IntelligenceScoreMillis: &intelligence,
		}},
	})
	if err != nil {
		t.Fatal(err)
	}
	if registration.Provider.Health != capability.HealthAvailable || len(registration.Models) != 1 || len(registration.Bindings) != 1 {
		t.Fatalf("unexpected registration: %+v", registration)
	}
	if registration.Models[0].Health != capability.HealthAvailable || registration.Bindings[0].Health != capability.HealthAvailable {
		t.Fatalf("discovery health was not carried into canary candidates: model=%s binding=%s", registration.Models[0].Health, registration.Bindings[0].Health)
	}
	if registration.Provider.AuthMode != capability.AuthKey || registration.Provider.InputCostMicros == nil || *registration.Provider.InputCostMicros != inputCost || registration.Models[0].IntelligenceScoreMillis == nil || *registration.Models[0].IntelligenceScoreMillis != intelligence {
		t.Fatalf("discovery profile was not carried into registry: provider=%+v model=%+v", registration.Provider, registration.Models[0])
	}
	inputCostChanged := int64(3)
	changed, err := BuildDiscoveryRegistration(capability.CognitiveDiscoverySnapshot{
		ProviderInstanceID: "local-lifeboat", ProviderKind: "openai-compatible-chat-v1", EndpointRef: "local-lifeboat-v1", OwnerPrincipalID: "domovoy-creator-principal", CapabilityID: "creator-advisory", DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "creator-advisory-local-v1", Health: capability.HealthAvailable, ObservedAtUnixMillis: 1001, BillingMode: capability.BillingPerInput, AuthMode: capability.AuthKey, InputCostMicros: &inputCostChanged,
		Models: []capability.DiscoveredModelSnapshot{{ProviderModelID: "domovoy-lifeboat", Fingerprint: "fingerprint", MaxContextBytes: 32768, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Installed: capability.OperationalYes, Loaded: capability.OperationalNotObserved, Invokable: capability.OperationalYes, IntelligenceScoreMillis: &intelligence}},
	})
	if err != nil || changed.Provider.Revision == registration.Provider.Revision {
		t.Fatalf("provider profile change did not create a new revision: first=%d changed=%d err=%v", registration.Provider.Revision, changed.Provider.Revision, err)
	}
}

func TestBuildActivationPromotionRequiresHealthyCanary(t *testing.T) {
	quality := int64(750)
	critical := int64(0)
	current := capability.ResolvedCognitiveBinding{
		Binding:    capability.CognitiveBinding{ID: "binding-1", Revision: 2, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: "provider-1", ProviderRevision: 3, ModelDescriptorID: "model-1", ModelRevision: 4, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationCanary, Health: capability.HealthAvailable, LimitPolicyRef: "limits"},
		Provider:   capability.ProviderInstance{ID: "provider-1", Revision: 3, Health: capability.HealthAvailable},
		Model:      capability.ModelDescriptor{ID: "model-1", Revision: 4, ProviderInstanceID: "provider-1", Health: capability.HealthAvailable},
		Evaluation: &capability.EvaluatedCapability{ID: "eval-1", Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
	}
	promotion, err := BuildActivationPromotion(capability.CognitiveActivationPromotionRequest{PromotionID: "promotion-1", RequestedByPrincipalID: "owner", CapabilityID: "creator-advisory", BindingID: "binding-1", ExpectedBindingRevision: 2, EvaluationID: "eval-1", ObservedAtUnixMillis: 3}, current)
	if err != nil || promotion.Binding.Activation != capability.ActivationActive || promotion.Binding.Revision == current.Binding.Revision {
		t.Fatalf("promotion=%+v err=%v", promotion, err)
	}
	current.Binding.Activation = capability.ActivationInactive
	if _, err = BuildActivationPromotion(capability.CognitiveActivationPromotionRequest{PromotionID: "promotion-2", RequestedByPrincipalID: "owner", CapabilityID: "creator-advisory", BindingID: "binding-1", ExpectedBindingRevision: 2, EvaluationID: "eval-1", ObservedAtUnixMillis: 3}, current); err == nil {
		t.Fatal("expected inactive binding to be rejected")
	}
}

func TestSelectCognitiveBindingUsesObjectiveAndCost(t *testing.T) {
	quality := int64(800)
	critical := int64(0)
	fast := int64(100)
	slow := int64(900)
	cheap := int64(1)
	expensive := int64(10)
	candidate := func(id string, intelligence, latency, cost int64) capability.ResolvedCognitiveBinding {
		return capability.ResolvedCognitiveBinding{
			Binding:     capability.CognitiveBinding{ID: capability.CapabilityBindingID(id), Revision: 1, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: capability.ProviderInstanceID(id), ProviderRevision: 1, ModelDescriptorID: capability.ModelDescriptorID(id), ModelRevision: 1, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits"},
			Provider:    capability.ProviderInstance{ID: capability.ProviderInstanceID(id), Revision: 1, Kind: "builtin", EndpointRef: capability.EndpointBindingRef(id), Enabled: true, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, BillingMode: capability.BillingPerRequest, RequestCostMicros: &cost},
			Model:       capability.ModelDescriptor{ID: capability.ModelDescriptorID(id), Revision: 1, ProviderInstanceID: capability.ProviderInstanceID(id), ProviderModelID: capability.ProviderModelID(id), MaxContextBytes: 10000, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, IntelligenceScoreMillis: &intelligence},
			Evaluation:  &capability.EvaluatedCapability{ID: capability.EvaluationID("eval-" + id), Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
			Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
		}
	}
	qualityCandidate := candidate("quality", slow, slow, expensive)
	fastCandidate := candidate("fast", fast, fast, cheap)
	selected, err := SelectCognitiveBinding(capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyLocalOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, MaxOutputBytes: 10, Objective: capability.SelectionQuality}, []capability.ResolvedCognitiveBinding{qualityCandidate, fastCandidate})
	if err != nil || selected.Binding.ID != "quality" {
		t.Fatalf("quality selection=%+v err=%v", selected, err)
	}
	selected, err = SelectCognitiveBinding(capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyLocalOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, MaxOutputBytes: 10, Objective: capability.SelectionEconomy, MaxCostMicros: &cheap}, []capability.ResolvedCognitiveBinding{qualityCandidate, fastCandidate})
	if err != nil || selected.Binding.ID != "fast" {
		t.Fatalf("economy selection=%+v err=%v", selected, err)
	}
}