package resolution

import (
	"errors"
	"fmt"
	"strings"
	"testing"

	mcat "git.novox.be/novox/mesh-sdk/go/catalogue"
)

// A config value reaches a resource from the assignment's layers, the node's over the mesh's (novox/hq ADR 0112,
// ADR 0155), and a value nothing set is refused by name; and a resource under `if-config` is declared only while a
// config value holds (design 42 zfs-owns-zfs §2, ADR 0679 §16 (b)). One table of the two, each row its layers, what it
// does to a resource and what comes of it.
func TestAConfigValueReachesAResourceAndDecidesWhetherItIsDeclared(t *testing.T) {
	filled := func(content string) func([]mcat.Layer) (string, error) {
		return func(layers []mcat.Layer) (string, error) {
			file := map[string]any{"id": "env", "type": "file", "path": "/x/mail.env", "content": content}
			err := settingInto(file, layers, "mail")
			return file["content"].(string), err
		}
	}
	// declared is the ids of what is left of a resource under each condition, and whether the key is gone from it.
	declared := func(conditions ...any) func([]mcat.Layer) (string, error) {
		return func(layers []mcat.Layer) (string, error) {
			kept := withoutUnconfigured([]map[string]any{
				{"id": "plain", "type": "file"}, {"id": "cond", "type": "file", mcat.IfConfigField: conditions}}, layers)
			var ids []string
			for _, r := range kept {
				if _, has := r[mcat.IfConfigField]; has {
					return "", errKeyKept
				}
				ids = append(ids, r["id"].(string))
			}
			return strings.Join(ids, ","), nil
		}
	}
	values := func(kv map[string]any) []mcat.Layer { return []mcat.Layer{{From: "the mesh", Values: kv}} }
	for _, row := range []struct {
		name   string
		layers []mcat.Layer
		do     func([]mcat.Layer) (string, error)
		want   string   // what comes of it
		errs   []string // or what the refusal says
	}{
		{"the node's layer over the mesh's", []mcat.Layer{
			{From: "the mesh", Values: map[string]any{"domain": "example.tld", "sitename": "Mesh", "workers": float64(4)}},
			{From: "this node", Values: map[string]any{"sitename": "This one"}}},
			filled("DOMAIN=${setting:domain}\nSITENAME=${setting:sitename}\nWORKERS=${setting:workers}\n"),
			"DOMAIN=example.tld\nSITENAME=This one\nWORKERS=4\n", nil},
		{"a value nothing set is refused, the file left as it was", values(map[string]any{"other": "x"}),
			filled("DOMAIN=${setting:domain}\n"), "DOMAIN=${setting:domain}\n",
			[]string{"${setting:domain}", "settings set mail", "set today: other"}},
		{"config-lines: a list of two writes two lines in order", values(map[string]any{"k": []any{"a", "b"}}),
			filled("h\n${config-lines:k:options zfs x=}\nt\n"), "h\noptions zfs x=a\noptions zfs x=b\nt\n", nil},
		{"config-lines: an empty list writes nothing", values(map[string]any{"k": []any{}}),
			filled("h\n${config-lines:k:p=}\nt\n"), "h\nt\n", nil},
		{"config-lines: an unset value writes nothing", nil, filled("h\n${config-lines:k:p=}\nt\n"), "h\nt\n", nil},
		{"config-lines: a set scalar writes one line", values(map[string]any{"k": "v"}),
			filled("${config-lines:k:p=}\n"), "p=v\n", nil},
		{"config-lines: mib-bytes writes MiB in bytes", values(map[string]any{"k": float64(64)}),
			filled("${config-lines:k:zfs_arc_max=:mib-bytes}\n"), "zfs_arc_max=67108864\n", nil},
		{"config-lines: an entry with a newline is refused, the file left as it was", values(map[string]any{"k": []any{"a\nb"}}),
			filled("${config-lines:k:p=}\n"), "${config-lines:k:p=}\n", []string{"newline"}},
		{"config-json: the set values only, each as its own type", values(map[string]any{"n": float64(64), "b": true, "s": "x",
			"l": []any{"a"}, "o": map[string]any{"f": float64(1)}}), filled("${config-json}\n"),
			"{\n  \"b\": true,\n  \"l\": [\n    \"a\"\n  ],\n  \"n\": 64,\n  \"o\": {\n    \"f\": 1\n  },\n  \"s\": \"x\"\n}\n", nil},
		{"config-json: nothing set is an empty object, not a refusal", nil, filled("${config-json}\n"), "{}\n", nil},
		{"if-config: a key never set leaves it out", nil, declared("k"), "plain", nil},
		{"if-config: a key set to text declares it", values(map[string]any{"k": "x"}), declared("k"), "plain,cond", nil},
		{"if-config: a key set to false, off, none, empty or an empty list leaves it out", values(map[string]any{"k": false}),
			declared("k"), "plain", nil},
		{"if-config: off", values(map[string]any{"k": "off"}), declared("k"), "plain", nil},
		{"if-config: none", values(map[string]any{"k": "none"}), declared("k"), "plain", nil},
		{"if-config: empty text", values(map[string]any{"k": ""}), declared("k"), "plain", nil},
		{"if-config: an empty list", values(map[string]any{"k": []any{}}), declared("k"), "plain", nil},
		{"if-config: a list of entries", values(map[string]any{"k": []any{"a"}}), declared("k"), "plain,cond", nil},
		{"if-config: a value equal to the condition", values(map[string]any{"k": "on"}), declared("k=on"), "plain,cond", nil},
		{"if-config: a value other than the condition", values(map[string]any{"k": "off"}), declared("k=on"), "plain", nil},
		{"if-config: a list holding the entry", values(map[string]any{"k": []any{"a", "b"}}), declared("k=b"), "plain,cond", nil},
		{"if-config: a list without the entry", values(map[string]any{"k": []any{"a"}}), declared("k=b"), "plain", nil},
		{"if-config: any of the conditions", values(map[string]any{"j": "x"}), declared("k", "j"), "plain,cond", nil},
		{"if-config: a value from a default layer", []mcat.Layer{{Default: true, Values: map[string]any{"k": "on"}}},
			declared("k=on"), "plain,cond", nil},
		{"if-config: a number equal to the condition", values(map[string]any{"k": float64(64)}), declared("k=64"), "plain,cond", nil},
	} {
		t.Run(row.name, func(t *testing.T) {
			got, err := row.do(row.layers)
			if len(row.errs) == 0 && err != nil {
				t.Fatal(err)
			}
			if len(row.errs) > 0 && err == nil {
				t.Fatalf("a refusal was expected, got %q", got)
			}
			for _, want := range row.errs {
				if !strings.Contains(err.Error(), want) {
					t.Fatalf("the refusal lacks %q: %v", want, err)
				}
			}
			if got != row.want {
				t.Fatalf("got %q, want %q", got, row.want)
			}
		})
	}
}

// errKeyKept is what a row of the table above says when `if-config` reached the node-engine, which parses strictly.
var errKeyKept = errors.New("the if-config key was kept in a declared resource")

// The composition takes a resource out while its condition does not hold, and a value going from set to unset takes it
// out of the next composition, which the node-engine removes as it removes any resource that left (design 42 §2).
func TestAConfigConditionedResourceIsComposedWhileItsValueHolds(t *testing.T) {
	m := mustParse(t, `{"module":"zfs","version":"1","config":{"zed":{"type":"string","default":"off"},"mods":{"type":"list"}},"resources":[
		{"id":"opts","type":"file","path":"/etc/modprobe.d/zfs.conf","content":"${config-lines:mods:options zfs }\n${config-json}\n"},
		{"id":"conf","type":"file","path":"/etc/zfs/mesh.conf","content":"x\n"},
		{"id":"zed","type":"file","path":"/etc/zfs/zed.rc","content":"y\n","if-config":["zed=on"]}]}`)
	for _, row := range []struct {
		layers []mcat.Layer
		zed    bool
	}{{nil, false}, {[]mcat.Layer{{From: "this node", Values: map[string]any{"zed": "on", "mods": []any{"a=1"}}}}, true}} {
		out, err := Declaration(mcat.Resolution{Node: "workstation", Modules: []mcat.Manifest{m}},
			mcat.Rendering{Settings: mcat.SettingsBy{"zfs": row.layers}})
		if err != nil {
			t.Fatal(err)
		}
		if fileNamed(out, "zfs.conf") == nil {
			t.Error("the unconditioned file was left out")
		}
		if opts := fileNamed(out, "zfs.opts"); opts == nil || (row.zed != strings.HasPrefix(fmt.Sprint(opts["content"]), "options zfs a=1\n")) {
			t.Errorf("the template's lines do not follow the list: %v", opts)
		}
		zed := fileNamed(out, "zfs.zed")
		if (zed != nil) != row.zed {
			t.Errorf("with %v the conditioned file is declared: %v, want %v", row.layers, zed != nil, row.zed)
		}
		if _, has := zed[mcat.IfConfigField]; has {
			t.Errorf("%s reached the node-engine, which parses strictly", mcat.IfConfigField)
		}
	}
}