package check

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

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

// 1930/AC3: given a check ask whose stored end keeps the digest's packages as a list of {package, digest} (issue 1930),
// or one stored before it with the packages a map keyed by package path, when the same heads are checked a second time,
// then the kept verdicts the first check wrote are read from it: every package it passed is kept, none run again.
func TestKeptVerdictsAreReadFromTheDigestsListForm(t *testing.T) {
	for _, tc := range []struct {
		name string
		old  bool
	}{{"the list form", false}, {"a map stored before issue 1930", true}} {
		t.Run(tc.name, func(t *testing.T) {
			b := newBench(t)
			var stored []string
			b.asks.Answer = func(a delivery.StepAsk) delivery.Step {
				s := b.answer(a)
				if tc.old && s.State == delivery.StepPassed {
					s.Result = oldDigestForm(t, s.Result)
				}
				stored = append(stored, string(s.Result))
				return s
			}
			first := b.judge(t, caseOf(t, pullOf(repoA, 7, head1))).Verdict
			u := first.Levels[delivery.LevelUnit]
			if first.State != delivery.VerdictPass || u.Run == 0 || u.Kept != 0 {
				t.Fatalf("the first check = %+v", first)
			}
			if len(stored) == 0 {
				t.Fatal("no ask's end was stored")
			}
			list := strings.Contains(stored[0], `"packages":[{"package":"fixture/slow"`)
			if list == tc.old || strings.Contains(stored[0], `"fixture/slow":"`) != tc.old {
				t.Fatalf("the stored end is not in the form under test: %s", stored[0])
			}
			b.steps.calls = nil
			second := b.judge(t, caseOf(t, pullOf(repoA, 7, head1))).Verdict
			if s := second.Levels[delivery.LevelUnit]; second.State != delivery.VerdictPass || s.Kept != u.Run || s.Run != 0 {
				t.Fatalf("the second check's unit level = %+v, want %d kept and none run", s, u.Run)
			}
			if n := len(b.steps.tool("test")); n != 0 {
				t.Errorf("%d test steps ran on the second check", n)
			}
		})
	}
}

// oldDigestForm rewrites a check answer's level digests to the form stored before issue 1930: packages as a map keyed by
// package path.
func oldDigestForm(t *testing.T, result json.RawMessage) json.RawMessage {
	t.Helper()
	var a struct {
		Fetch  json.RawMessage  `json:"fetch"`
		Levels []map[string]any `json:"levels"`
	}
	if err := json.Unmarshal(result, &a); err != nil {
		t.Fatal(err)
	}
	for _, l := range a.Levels {
		d, ok := l["digest"].(map[string]any)
		if !ok {
			continue
		}
		m := map[string]any{}
		list, _ := d["packages"].([]any)
		for _, p := range list {
			pd := p.(map[string]any)
			m[pd["package"].(string)] = pd["digest"]
		}
		d["packages"] = m
	}
	raw, err := json.Marshal(a)
	if err != nil {
		t.Fatal(err)
	}
	return raw
}