package build

// The fakes of the build modules the builder tests run against: a caller answering a long tool at once with the step and its key,
// and the steps watch. The caller, the steps watch and the runner themselves are the SDK's (mesh-sdk go/delivery/buildrun, issue 1671).

import (
	"context"
	"encoding/json"
	"sync"
	"testing"
	"time"

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

type call struct {
	node, key string
	body      any
}

// fakeCaller answers a long tool as the build modules do: at once, with the step and its key.
type fakeCaller struct {
	calls  []call
	answer string
	err    error
}

func (f *fakeCaller) CallOn(node, key string, body any) (json.RawMessage, error) {
	f.calls = append(f.calls, call{node, key, body})
	if f.err != nil {
		return nil, f.err
	}
	return json.RawMessage(f.answer), nil
}

// fakeSteps holds the steps values by `<module>/<key>`; Wait on a key it does not hold blocks until the context ends.
type fakeSteps struct {
	mu    sync.Mutex
	steps map[string]delivery.Step
	// during, when set, is called as a wait starts and the function it answers as the wait ends.
	during func(key string) func()
}

func (f *fakeSteps) Wait(ctx context.Context, module, key string) (delivery.Step, error) {
	f.mu.Lock()
	s, ok := f.steps[module+"/"+key]
	during := f.during
	f.mu.Unlock()
	if ok {
		if during != nil {
			defer during(key)()
		}
		return s, nil
	}
	<-ctx.Done()
	return delivery.Step{}, context.Cause(ctx)
}

func stepAt(node, id, state, reason string, result string) delivery.Step {
	s := delivery.Step{ID: id, Tool: "build_go_fetch", Node: node, State: state, Reason: reason}
	if result != "" {
		s.Result = json.RawMessage(result)
	}
	return s
}

// presenceValue is a watchman presence value, as its writer encodes it (mesh-sdk go/delivery EncodePresence).
func presenceValue(t *testing.T, online bool) []byte {
	t.Helper()
	b, err := delivery.EncodePresence(delivery.Presence{Online: online})
	if err != nil {
		t.Fatal(err)
	}
	return b
}

// tcValue is a toolchains value, as the build module's writer encodes it (mesh-sdk go/delivery EncodeToolchain).
func tcValue(t *testing.T, language, version string) []byte {
	t.Helper()
	b, err := delivery.EncodeToolchain(delivery.Toolchain{Language: language, Version: version, Recipe: "1", At: time.Now()})
	if err != nil {
		t.Fatal(err)
	}
	return b
}

// tcs are the toolchain entries of a language on nodes, as the toolchains set gives them.
func tcs(language, version string, nodes ...string) []delivery.NodeToolchain {
	var out []delivery.NodeToolchain
	for _, n := range nodes {
		out = append(out, delivery.NodeToolchain{Node: n, Toolchain: delivery.Toolchain{Language: language, Version: version, Recipe: "1"}})
	}
	return out
}