package main

import (
	"strings"
	"testing"
	"time"

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

// A directory the node-engine uses as found (novox/hq issue 339) waits for a person to hand it over at the
// machine. Found before this send, it is no fault of the build: the gate passes with the wait carried, so an
// urgent fix of that module still goes through. Found by this send, the send brought it, and the gate holds.
func foundDirectory(module string, since time.Time) inventory.ResourceHealth {
	return inventory.ResourceHealth{Module: module, Resource: module + ".data", Kind: link.KindDirectory,
		Target: "/srv/" + module, State: link.StateUnhealthy, Since: since,
		Reason: link.ReasonUsedAsFound + " owned by 1000:1000, mode 700, as found; root, mode 755 was declared and " +
			"not given it — `nox node hand-over laptop <directory>` on the control-node, with its path, hands it to the mesh"}
}

func TestADirectoryFoundBeforeTheSendIsAWaitForAPerson(t *testing.T) {
	withTheGate(t) // the first-machine gate\'s own path (novox/hq ADR 0360 keeps it for earlier walks)
	now := time.Now()
	sent := now.Add(-time.Minute)
	f := gateFacts{now: now, health: map[string]inventory.NodeHealth{"laptop": {Node: "laptop", HeardAt: now,
		Resources: []inventory.ResourceHealth{foundDirectory("notes", sent.Add(-24*time.Hour))}}}}
	h, why := moduleHealthWord("notes", "laptop", sent, f)
	if h != healthPerson || !strings.Contains(why, "notes.data") || !strings.Contains(why, "hand-over") {
		t.Fatalf("a directory found before the send reads %v %q; want a wait for a person", h, why)
	}
	// Found by this very send: the send brought it, and it is not passed.
	f.health["laptop"] = inventory.NodeHealth{Node: "laptop", HeardAt: now,
		Resources: []inventory.ResourceHealth{foundDirectory("notes", sent.Add(time.Second))}}
	if h, why := moduleHealthWord("notes", "laptop", sent, f); h != healthNotYet {
		t.Fatalf("a directory this send found reads %v %q; want not yet", h, why)
	}
	// A container down beside the old wait is a fault, as before.
	f.health["laptop"] = inventory.NodeHealth{Node: "laptop", HeardAt: now, Resources: []inventory.ResourceHealth{
		foundDirectory("notes", sent.Add(-time.Hour)),
		{Module: "notes", Resource: "notes.web", Kind: "container", Target: "notes", State: link.StateUnhealthy, Reason: "down"}}}
	if h, why := moduleHealthWord("notes", "laptop", sent, f); h != healthNotYet {
		t.Fatalf("a container down beside the wait reads %v %q; want not yet", h, why)
	}
}

// The whole walk: a module whose directory was used as found long before still gets its fix to every machine,
// its pass kept and the wait said; a directory this very send found holds it and puts it back.

// The condition says the wait in its own kind: the operator's, never urgent, and cleared once handed over.