//go:build integration

package main

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

	"github.com/novox/mesh-controller/internal/inventory"
	"github.com/novox/mesh-controller/internal/link"
	"github.com/novox/mesh-controller/internal/secrets"
)

func TestAnIssuedValueIsTakenSealedFromTheProviderAndSent(t *testing.T) {
	var r issuedRecorder
	words, err := r.taker(t, issuedSealed(t, "the-servers-own-token")).take("plex-api")
	if err != nil {
		t.Fatal(err)
	}
	if len(r.kept) != 1 || r.kept[0] != "the-servers-own-token" {
		t.Fatalf("the provider's value was not kept: %d kept", len(r.kept))
	}
	if len(r.sent) != 1 || strings.Join(r.sent[0], ",") != "ace" {
		t.Fatalf("the holders' machines were not sent: %v", r.sent)
	}
	if len(r.acts) != 1 || r.acts[0].Verb != handActIssued {
		t.Fatalf("the change was not recorded in the hand-act log: %+v", r.acts)
	}
	for _, said := range []string{words, r.acts[0].Why, strings.Join(r.acts[0].Args, " ")} {
		if strings.Contains(said, "the-servers-own-token") || strings.Contains(said, inventory.IssuedStamp("the-servers-own-token")) {
			t.Fatalf("the value or its fingerprint was said: %q", said)
		}
	}
	if !strings.Contains(words, "kometa on ace") || !strings.Contains(words, "tautulli on ace") {
		t.Fatalf("the answer does not name the holders: %q", words)
	}
}

func TestAnIssuedValueEveryHolderHoldsSendsNobody(t *testing.T) {
	r := issuedRecorder{again: true}
	words, err := r.taker(t, issuedSealed(t, "the-servers-own-token")).take("plex-api")
	if err != nil {
		t.Fatal(err)
	}
	if len(r.sent) != 0 || len(r.acts) != 0 {
		t.Fatalf("an unchanged value was sent or recorded: %v %v", r.sent, r.acts)
	}
	if !strings.Contains(words, "nothing was sent") {
		t.Fatalf("the answer does not say nothing was sent: %q", words)
	}
}

func TestOnlyAValueSealedToTheCallIsTaken(t *testing.T) {
	other, _, _ := secrets.Keypair()
	elsewhere, _ := secrets.Seal(other, []byte("somebody's value"))
	raw, _ := json.Marshal(map[string]string{"sealed": elsewhere})
	plain, _ := json.Marshal(map[string]string{"value": "the-servers-own-token"})
	for name, ask := range map[string]func(issuedProvider, map[string]any) (link.Answer, error){
		"sealed to another key": func(issuedProvider, map[string]any) (link.Answer, error) { return link.Answer{Result: raw}, nil },
		"answered in the clear": func(issuedProvider, map[string]any) (link.Answer, error) { return link.Answer{Result: plain}, nil },
		"refused": func(issuedProvider, map[string]any) (link.Answer, error) {
			return link.Answer{Error: "the controller alone"}, nil
		},
		"not reached": func(issuedProvider, map[string]any) (link.Answer, error) {
			return link.Answer{}, errors.New("503 no responders")
		},
		"sealed empty": issuedSealed(t, "  "),
	} {
		var r issuedRecorder
		if _, err := r.taker(t, ask).take("plex-api"); err == nil {
			t.Errorf("%s: taken", name)
		}
		if len(r.kept) != 0 || len(r.sent) != 0 {
			t.Errorf("%s: something was kept or sent", name)
		}
	}
}

func TestAProvisionNoOfferSaysIsIssuedIsRefused(t *testing.T) {
	asked := false
	taker := issuedTaker{
		providers: func(string) ([]issuedProvider, bool, error) { return nil, false, nil },
		ask: func(issuedProvider, map[string]any) (link.Answer, error) {
			asked = true
			return link.Answer{}, nil
		},
	}
	if _, err := taker.take("postgres-database"); err == nil || !strings.Contains(err.Error(), "ADR 0305") {
		t.Fatalf("expected a refusal naming the record, got %v", err)
	}
	if asked {
		t.Fatal("a provider was asked for a provision no offer says its software issues")
	}
}