package domain_test

import (
	selfcontract "git.cin.su/m/Assistant/contracts/self"
	"git.cin.su/m/Assistant/modules/self/domain"
	"git.cin.su/m/Assistant/platform/ids"
	"testing"
)

func TestCompetenceCannotBeSelfDeclaredWithoutEvidence(t *testing.T) {
	v := selfcontract.CompetenceAssessment{ID: "a", PrincipalID: "p", SubjectRef: selfcontract.SemanticReference{OwnerNamespace: "capability", SemanticKind: "skill", StableID: "s"}, Revision: 1, ConfidenceMillis: 1000, AssessedAt: 1}
	if domain.ValidateCompetence(v) == nil {
		t.Fatal("unsupported competence accepted")
	}
	v.EvidenceRefs = []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "evaluation", StableID: "e"}}
	if err := domain.ValidateCompetence(v); err != nil {
		t.Fatal(err)
	}
}

func TestShadowDivergenceCreatesProposalNotPromotion(t *testing.T) {
	reflex := selfcontract.SemanticReference{OwnerNamespace: "capability", SemanticKind: "reflex", StableID: "r"}
	evidence := []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "experience", StableID: "e"}}
	need, ledger, err := domain.ImprovementForReflexDivergence("p", reflex, evidence, 1)
	if err != nil || need.State != "OPEN" || ledger.Decision != "PROPOSE_REVALIDATION" {
		t.Fatalf("need=%#v ledger=%#v err=%v", need, ledger, err)
	}
}

func signal(kind selfcontract.LearningSignalKind, id, scope string, at int64) selfcontract.LearningSignal {
	return selfcontract.LearningSignal{ID: id, PrincipalID: "p", Kind: kind, TaskPattern: "recall", ScopeKey: scope, SubjectRef: selfcontract.SemanticReference{OwnerNamespace: "interaction", SemanticKind: "assertion", StableID: ids.StableID("x")}, EvidenceRefs: []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "experience", StableID: ids.StableID(id)}}, ObservedAt: at, Severity: 2, UserImpact: 1}
}

func TestRepeatedSignalsCreateScopedWeaknessButSingleDoesNot(t *testing.T) {
	a, b := signal(selfcontract.SignalUserCorrection, "e1", "company-a", 1), signal(selfcontract.SignalUserCorrection, "e2", "company-a", 2)
	if _, created, err := domain.BuildWeaknessPattern("p", "recall", "company-a", "v1", []selfcontract.LearningSignal{a}, "context", "strategy"); err != nil || created {
		t.Fatalf("single incident created weakness: %v %v", created, err)
	}
	w, created, err := domain.BuildWeaknessPattern("p", "recall", "company-a", "v1", []selfcontract.LearningSignal{a, b}, "context", "strategy")
	if err != nil || !created || w.Frequency != 2 || w.ScopeKey != "company-a" {
		t.Fatalf("weakness=%#v created=%v err=%v", w, created, err)
	}
}

func TestDiagnosisCandidateAndMustNotWorsen(t *testing.T) {
	s := signal(selfcontract.SignalReflexDivergence, "e3", "company-a", 3)
	d := domain.AttributeFailure(s)
	if d.Class != selfcontract.DiagnosisReflexFailure || d.Status != selfcontract.EpistemicHypothesis {
		t.Fatalf("diagnosis=%#v", d)
	}
	n, err := domain.BuildImprovementNeed(s, d, "reflex")
	if err != nil {
		t.Fatal(err)
	}
	c, err := domain.BuildCandidate(n, "creator", "evaluator", s.EvidenceRefs, 3)
	if err != nil {
		t.Fatal(err)
	}
	decision, err := domain.EvaluateCandidate(c, selfcontract.ImprovementEvaluation{Evaluator: "evaluator", EvidenceRefs: s.EvidenceRefs, ExpectedQuality: 800, ActualQuality: 800, ExpectedLatency: 100, ActualLatency: 250, MustNotWorsenPass: true})
	if err != nil || decision != selfcontract.CandidateRejected {
		t.Fatalf("decision=%v err=%v", decision, err)
	}
}

func TestScopedEvidenceIsDeduplicatedAndBounded(t *testing.T) {
	s := signal(selfcontract.SignalSkillFallback, "e4", "company-a", 4)
	d := domain.AttributeFailure(s)
	n, err := domain.BuildImprovementNeed(s, d, "skill")
	if err != nil {
		t.Fatal(err)
	}
	if _, err = domain.BuildCandidate(n, "creator", "evaluator", append(s.EvidenceRefs, s.EvidenceRefs...), 4); err != nil {
		t.Fatal(err)
	}
	if got := domain.ClassifyDecisionRegret(selfcontract.LearningSignal{DecisionRegret: selfcontract.RegretIgnoredInContext}); got != selfcontract.RegretIgnoredInContext {
		t.Fatal(got)
	}
}

func TestBenchmarkAndLedgerReferenceEvidence(t *testing.T) {
	s := signal(selfcontract.SignalOutcomeMismatch, "e5", "company-a", 5)
	caseRef, err := domain.BuildBenchmarkCase("p", "memory-recall", s.EvidenceRefs, 5)
	if err != nil || !caseRef.Valid() {
		t.Fatalf("benchmark=%#v err=%v", caseRef, err)
	}
	d := domain.AttributeFailure(s)
	n, err := domain.BuildImprovementNeed(s, d, "verification")
	if err != nil {
		t.Fatal(err)
	}
	c, err := domain.BuildCandidate(n, "creator", "evaluator", s.EvidenceRefs, 5)
	if err != nil {
		t.Fatal(err)
	}
	l, err := domain.AppendLedgerOutcome(n, c, selfcontract.ImprovementEvaluation{Evaluator: "evaluator", EvidenceRefs: s.EvidenceRefs}, selfcontract.CandidateRejected, 6)
	if err != nil || l.Decision != string(selfcontract.CandidateRejected) || len(l.EvidenceRefs) == 0 {
		t.Fatalf("ledger=%#v err=%v", l, err)
	}
}