package domain

import (
	"errors"
	"strings"
	"testing"

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

func TestReminderResolvesToSchedulingImplementation(t *testing.T) {
	requirement := resolutionRequirement(capability.CapabilityKindScheduleReminder)
	resolution, err := ResolveCapability(requirement, []capability.CapabilityImplementation{implementation("scheduler-b", capability.CapabilityKindScheduleReminder, 900, 50), implementation("scheduler-a", capability.CapabilityKindScheduleReminder, 950, 75)})
	if err != nil {
		t.Fatal(err)
	}
	if resolution.Status != capability.ResolutionAvailable || len(resolution.Eligible) != 2 || !resolution.Eligible[0].Selected || resolution.Eligible[0].Implementation.ID != "scheduler-a" {
		t.Fatalf("unexpected resolution: %#v", resolution)
	}
}

func TestUnavailableImplementationExcluded(t *testing.T) {
	candidate := implementation("scheduler", capability.CapabilityKindScheduleReminder, 900, 50)
	candidate.Health = capability.HealthUnavailable
	resolution, err := ResolveCapability(resolutionRequirement(capability.CapabilityKindScheduleReminder), []capability.CapabilityImplementation{candidate})
	if !errors.Is(err, ErrNoCapabilityImplementation) || resolution.Gap == nil || resolution.Gap.Reason != capability.GapUnhealthy {
		t.Fatalf("expected unhealthy gap, got resolution=%#v err=%v", resolution, err)
	}
}

func TestSelectionDoesNotDependOnProviderName(t *testing.T) {
	left := implementation("zzz-provider-name", capability.CapabilityKindScheduleReminder, 980, 20)
	right := implementation("aaa-provider-name", capability.CapabilityKindScheduleReminder, 900, 10)
	resolution, err := ResolveCapability(resolutionRequirement(capability.CapabilityKindScheduleReminder), []capability.CapabilityImplementation{left, right})
	if err != nil {
		t.Fatal(err)
	}
	if resolution.Eligible[0].Implementation.ID != left.ID {
		t.Fatalf("selection appears provider-name driven: %#v", resolution.Eligible)
	}
}

func TestCredentialRefDoesNotGrantAuthority(t *testing.T) {
	candidate := implementation("mail", capability.CapabilityKindSendEmail, 900, 50)
	candidate.CredentialRef = "credential://mail/token"
	candidate.AuthorityPolicyRef = "mail-send-approved-v1"
	resolution, err := ResolveCapability(resolutionRequirement(capability.CapabilityKindSendEmail), []capability.CapabilityImplementation{candidate})
	if !errors.Is(err, ErrNoCapabilityImplementation) || resolution.Gap == nil || resolution.Gap.Reason != capability.GapUnauthorized {
		t.Fatalf("credential ref must not grant authority: resolution=%#v err=%v", resolution, err)
	}
}

func TestCapabilityGapPreservesOriginalIntentCorrelation(t *testing.T) {
	requirement := resolutionRequirement(capability.CapabilityKindSendEmail)
	resolution, err := ResolveCapability(requirement, nil)
	if !errors.Is(err, ErrNoCapabilityImplementation) || resolution.Gap == nil {
		t.Fatalf("expected gap, got resolution=%#v err=%v", resolution, err)
	}
	if resolution.Gap.OriginalIntentID != requirement.OriginalIntentID || resolution.Gap.SourceUtteranceID != requirement.SourceUtteranceID || len(resolution.Gap.Strategies) == 0 {
		t.Fatalf("gap lost correlation/strategies: %#v", resolution.Gap)
	}
	if strings.Contains(strings.ToLower(resolution.Gap.Detail), "codex") {
		t.Fatalf("gap must not become codex-specific: %#v", resolution.Gap)
	}
}

func resolutionRequirement(kind capability.CapabilityKind) capability.CapabilityResolutionRequirement {
	return capability.CapabilityResolutionRequirement{
		CapabilityKind:       kind,
		OwnerPrincipalID:     "owner-1",
		ActorID:              "actor-1",
		OriginalIntentID:     "intent-1",
		SourceUtteranceID:    "utterance-1",
		RequiredConstraints:  []capability.DataConstraint{capability.DataConstraintLocalOnly},
		AuthorityContextRef:  capability.AuthorityPolicyCreatorDirectiveV1,
		ObservedAtUnixMillis: 1000,
	}
}

func implementation(id string, kind capability.CapabilityKind, reliability int64, latency int64) capability.CapabilityImplementation {
	return capability.CapabilityImplementation{
		ID:                   capability.CapabilityImplementationID(id),
		CapabilityID:         capability.CapabilityID(strings.ToLower(string(kind))),
		CapabilityKind:       kind,
		OwnerPrincipalID:     "owner-1",
		Revision:             1,
		Kind:                 capability.ImplementationInternalFunction,
		TargetRef:            capability.ImplementationTargetRef("internal://" + strings.ToLower(string(kind))),
		Qualification:        capability.QualificationValidated,
		Activation:           capability.ActivationActive,
		Health:               capability.HealthAvailable,
		AuthorityPolicyRef:   capability.AuthorityPolicyCreatorDirectiveV1,
		DataConstraints:      []capability.DataConstraint{capability.DataConstraintLocalOnly, capability.DataConstraintNoCredentialForward},
		ReliabilityMillis:    &reliability,
		LatencyScoreMillis:   &latency,
		ObservedAtUnixMillis: 1000,
	}
}