package bridge

import (
	"reflect"
	"strings"
	"testing"

	"git.novox.be/novox/mesh-delivery/contracts/go/clients/meshdeliveryclient"
	seat "git.novox.be/novox/mesh-delivery/contracts/go/seats/meshdelivery"
	"git.novox.be/novox/mesh-delivery/modules/mesh-delivery-forge-bridge/forgemsg"
	"git.novox.be/novox/mesh-sdk/go/keys"
)

const (
	headA = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
	headB = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
)

// owedValue is an owed value as the SDK writes it (mesh-sdk go/delivery EncodeOwed), and its key as OwedKey spells it.
func owedValue(t *testing.T, repository string, number int, act string, o seat.OwedByRepositoryNumberHeadActValue) (string, []byte) {
	t.Helper()
	key, err := meshdeliveryclient.OwedKey(repository, number, headA, act)
	if err != nil {
		t.Fatal(err)
	}
	b, err := meshdeliveryclient.EncodeOwed(o)
	if err != nil {
		t.Fatal(err)
	}
	return key, b
}

func TestOwedStatusIsACommitStatusCall(t *testing.T) { // 1341/AC1, K1
	key, v := owedValue(t, "novox/mesh-delivery", 12, "status=mesh/merge-gate",
		seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: "mesh/merge-gate", State: "pending", Text: "waiting", Target: "https://forge.example/novox/mesh-delivery/pulls/12"})
	a, err := OwedAct(key, v)
	if err != nil {
		t.Fatal(err)
	}
	want := Call{Tool: "gitea.gitea_commit_status", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "sha": headA,
		"context": "mesh/merge-gate", "state": "pending", "description": "waiting", "target_url": "https://forge.example/novox/mesh-delivery/pulls/12"}}
	if !reflect.DeepEqual(a.Call, want) {
		t.Errorf("call = %+v, want %+v", a.Call, want)
	}
	if a.Repository != "novox/mesh-delivery" || a.Number != 12 || a.Head != headA || a.Name != "status=mesh/merge-gate" {
		t.Errorf("act = %+v", a)
	}
	// R4e findings K1 and R2-1 (issue 1301 S4; ADR 0503 §3, ADR 0521): no tool writes mesh/check, since a tool is told no
	// caller and node-tools invokes every tool; the forge module writes it from the checker's owed state, and the bridge
	// performs no mesh/check act.
	ck, cv := checkerKV(t, seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: meshdeliveryclient.StatusContextCheck, State: "success", Text: "pass", Target: "https://view.example/checks/g.1"})
	if a, err := OwedAct(ck, cv); err == nil || !strings.Contains(err.Error(), "mesh-delivery-checker.owed") {
		t.Fatalf("OwedAct(mesh/check) = %+v, %v; want refused, naming where the forge module reads it", a, err)
	}
	// Nor through the gate's own owed bucket: the context is refused whichever key carries it.
	gk, gv := owedValue(t, "novox/mesh-delivery", 12, "status=mesh/check",
		seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedStatus, Context: meshdeliveryclient.StatusContextCheck, State: "success", Text: "pass", Target: "https://x.example"})
	if a, err := OwedAct(gk, gv); err == nil || !strings.Contains(err.Error(), "mesh-delivery-checker.owed") {
		t.Fatalf("OwedAct(gate's mesh/check) = %+v, %v; want refused", a, err)
	}
}

// checkerKV is the status the checker owes, as it writes it (the gate's owed key with the act status=mesh/check).
func checkerKV(t *testing.T, o seat.OwedByRepositoryNumberHeadActValue) (string, []byte) {
	t.Helper()
	key, err := meshdeliveryclient.OwedKey("novox/mesh-delivery", 12, headA, "status=mesh/check")
	if err != nil {
		t.Fatal(err)
	}
	v, err := meshdeliveryclient.EncodeOwed(o)
	if err != nil {
		t.Fatal(err)
	}
	return key, v
}

func TestOwedViewNoteAndCommentCalls(t *testing.T) { // 1341/AC2
	cases := []struct {
		act  string
		o    seat.OwedByRepositoryNumberHeadActValue
		want Call
	}{
		{"view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "the view"},
			Call{Tool: "gitea.gitea_delivery_view", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "body": "the view"}}},
		{"note", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedNote, Text: "a line", Ref: "mesh-plan"},
			Call{Tool: "gitea.gitea_note_append", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "sha": headA, "ref": "mesh-plan", "line": "a line"}}},
		{"comment.2", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "hello"},
			Call{Tool: "gitea.gitea_add_comment", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "body": "hello"}}},
	}
	for _, c := range cases {
		key, v := owedValue(t, "novox/mesh-delivery", 12, c.act, c.o)
		a, err := OwedAct(key, v)
		if err != nil {
			t.Fatalf("%s: %v", c.act, err)
		}
		if !reflect.DeepEqual(a.Call, c.want) {
			t.Errorf("%s: call = %+v, want %+v", c.act, a.Call, c.want)
		}
	}
}

func TestOwedActWithoutAPullRequestNeedsOneOnlyWhereTheToolDoes(t *testing.T) {
	key, v := owedValue(t, "novox/mesh-delivery", 0, "note", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedNote, Text: "l", Ref: "mesh-plan"})
	if _, err := OwedAct(key, v); err != nil {
		t.Errorf("a note on a commit no pull request names: %v", err)
	}
	key, v = owedValue(t, "novox/mesh-delivery", 0, "view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "v"})
	if _, err := OwedAct(key, v); err == nil {
		t.Error("a view of no pull request was taken")
	}
}

func TestOwedActThatDisagreesWithItsKeyIsRefused(t *testing.T) {
	// A dotted repository's key is unescaped, and its act names the repository whole.
	dk, dv := owedValue(t, "novox/my.repo", 3, "comment.1", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "x"})
	if a, err := OwedAct(dk, dv); err != nil || a.Call.Args["repo"] != "my.repo" || a.Repository != "novox/my.repo" {
		t.Errorf("a dotted repository's act = %+v, %v", a, err)
	}
	key, _ := owedValue(t, "novox/mesh-delivery", 12, "view", seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedView, Text: "v"})
	v, _ := meshdeliveryclient.EncodeOwed(seat.OwedByRepositoryNumberHeadActValue{Act: meshdeliveryclient.OwedComment, Text: "v"})
	if _, err := OwedAct(key, v); err == nil {
		t.Error("a comment under a view's key was taken")
	}
	if _, err := OwedAct("nonsense", v); err == nil {
		t.Error("a key that is no owed key was taken")
	}
	if _, err := OwedAct(key, []byte(`{"v":1`)); err == nil {
		t.Error("a value that is not json was taken")
	}
}

func mergeValue(t *testing.T, m seat.MergesByGroupValue) []byte {
	t.Helper()
	b, err := meshdeliveryclient.EncodeMerge(m)
	if err != nil {
		t.Fatal(err)
	}
	return b
}

func TestMergeActsHandOnlyTheMemberHandedWithEveryApprovedHead(t *testing.T) { // 1342/AC1
	approved := map[string]string{meshdeliveryclient.ApprovedKey("novox/mesh-sdk", 4): headB, meshdeliveryclient.ApprovedKey("novox/mesh-delivery", 12): headA}
	v := mergeValue(t, seat.MergesByGroupValue{Group: "g", Ask: "merge.g.0123456789ab", Approved: approved, Pulls: []seat.MergesByGroupValuePullsItem{
		{Repository: "novox/mesh-sdk", Number: 4, Head: headB, State: string(meshdeliveryclient.MergeMerged), Commit: "c0"},
		{Repository: "novox/mesh-delivery", Number: 12, Head: headA, State: string(meshdeliveryclient.MergeMerging)},
	}})
	acts, err := MergeActs(v)
	if err != nil {
		t.Fatal(err)
	}
	if len(acts) != 1 {
		t.Fatalf("%d acts, want 1 (the merged member is not merged again)", len(acts))
	}
	want := Call{Tool: "gitea.gitea_merge_pull_request", Args: map[string]any{"owner": "novox", "repo": "mesh-delivery", "number": 12, "head": headA,
		"approved_heads": []string{"novox/mesh-delivery@" + headA, "novox/mesh-sdk@" + headB}}}
	if !reflect.DeepEqual(acts[0].Call, want) {
		t.Errorf("call = %+v, want %+v", acts[0].Call, want)
	}
	if acts[0].Name != "merge" || acts[0].Number != 12 || acts[0].Head != headA {
		t.Errorf("act = %+v", acts[0])
	}
	// A merge with no approved heads is refused: the forge's tool would refuse it with nothing to say which.
	v = mergeValue(t, seat.MergesByGroupValue{Group: "g", Ask: "a", Pulls: []seat.MergesByGroupValuePullsItem{
		{Repository: "novox/mesh-delivery", Number: 12, Head: headA, State: string(meshdeliveryclient.MergeMerging)}}})
	if _, err := MergeActs(v); err == nil {
		t.Error("a merge with no approved heads was taken")
	}
}

func TestRefusedMessageNamesTheActAndTheForgesWords(t *testing.T) { // 1341/AC3, 1342/AC2
	a := Act{Name: "merge", Repository: "novox/mesh-delivery", Number: 12, Head: headA}
	m, err := RefusedMessage(a, "novox/mesh-delivery#12 is not merged: its head moved")
	if err != nil {
		t.Fatal(err)
	}
	if m.Event != "forge.novox.mesh-delivery.refused" {
		t.Errorf("event = %q", m.Event)
	}
	f, err := forgemsg.DecodeForge(m.Data)
	if err != nil {
		t.Fatal(err)
	}
	want := forgemsg.Forge{V: keys.Version, Kind: forgemsg.ForgeRefused, Repository: "novox/mesh-delivery", Number: 12, Head: headA,
		Act: "merge", Words: "novox/mesh-delivery#12 is not merged: its head moved"}
	if !forgemsg.SameForge(f, want) {
		t.Errorf("message = %+v", f)
	}
}