package check

import (
	"context"
	"encoding/json"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-sdk/go/delivery"
)

type fakeState map[string][]byte

func (f fakeState) read() StateRead {
	return StateRead{
		Keys: func() ([]string, error) {
			var k []string
			for key := range f {
				k = append(k, key)
			}
			return k, nil
		},
		Get: func(key string) (json.RawMessage, error) {
			if v, ok := f[key]; ok {
				return json.RawMessage(v), nil
			}
			return nil, nil
		},
	}
}

// readerOf is a reader over a verdict the checker wrote through its own code and the candidate it judged.
func readerOf(t *testing.T) (Reader, string) {
	t.Helper()
	r := newRig(t, passJudge())
	cand := candidateOf(t, "feat/x", pullOf(repoA, 7, head1), pullOf(HQRepository, 3, head2))
	r.ch.Candidate(context.Background(), "feat%2Fx", cand)
	r.ch.Wait()
	ckey, _ := delivery.CandidatesKey("feat/x")
	verdicts, kept := fakeState{}, fakeState{}
	for k, v := range r.verdicts.vals {
		verdicts[k] = v
	}
	if _, err := (Kept{Store: r.verdicts}).Keep(context.Background(), "unit", digA, keptValue("m/a", 3)); err != nil {
		t.Fatal(err)
	}
	kept["unit."+digA] = r.verdicts.vals["unit."+digA]
	return Reader{VerdictState: verdicts.read(), KeptState: kept.read(), CandidateState: fakeState{ckey: cand}.read()}, keyOf(t, "feat/x", cand)
}

func TestTheVerdictToolsAnswerTheStoredVerdictWithTheFullReportOfEachPullRequest(t *testing.T) { // N9/AC1, 1686
	rd, key := readerOf(t)
	vs, err := rd.Verdicts("")
	if err != nil || len(vs) != 1 || vs[0].Key != key {
		t.Fatalf("verdicts = %+v, %v", vs, err)
	}
	if _, err := delivery.DecodeVerdict(vs[0].Verdict); err != nil {
		t.Errorf("the verdict is not as stored: %v", err)
	}
	if got := vs[0].Reports["novox/mesh-delivery#7"]; !strings.HasPrefix(got, "pass 111111111111 on aaaaaaaaaaaa") || !strings.Contains(got, "composition not yet run") {
		t.Errorf("reports = %v", vs[0].Reports)
	}
	if only, _ := rd.Verdicts("feat/other"); len(only) != 0 {
		t.Errorf("another group's verdicts = %+v", only)
	}
}

func TestAnHqPullRequestIsSaidToBeJudgedByMergeCheckUntilIssue1296(t *testing.T) { // ADR 0484 clause 8
	rd, _ := readerOf(t)
	hq, err := rd.Pull(HQRepository, 3)
	if err != nil || hq.Note != "hq: judged by merge-check.sh until issue 1296" || hq.Verdict != nil {
		t.Errorf("hq pull = %+v, %v", hq, err)
	}
	p, err := rd.Pull(repoA, 7)
	if err != nil || p.Note != "" || !strings.HasPrefix(p.Reports["novox/mesh-delivery#7"], "pass ") {
		t.Errorf("pull = %+v, %v", p, err)
	}
	if _, err := rd.Pull(repoA, 99); err == nil {
		t.Error("a pull request no candidate holds was answered")
	}
}

func TestTheKeptToolAnswersTheKeysAsStoredByLevelAndByDigest(t *testing.T) { // N9/AC1
	rd, _ := readerOf(t)
	all, err := rd.Kept("", "")
	if err != nil || len(all) != 1 {
		t.Fatalf("kept = %v, %v", all, err)
	}
	one, err := rd.Kept("unit", digA)
	if err != nil || len(one) != 1 {
		t.Fatalf("one kept = %v, %v", one, err)
	}
	for _, raw := range one {
		if k, err := delivery.DecodeKept(raw); err != nil || k.Package != "m/a" {
			t.Errorf("kept value = %+v, %v", k, err)
		}
	}
	if none, _ := rd.Kept("integration", ""); len(none) != 0 {
		t.Errorf("integration = %v", none)
	}
	if _, err := rd.Kept("unit", digB); err == nil {
		t.Error("a digest nothing kept was answered")
	}
}