package main

import (
	"encoding/json"
	"go/ast"
	"go/parser"
	"go/token"
	"path/filepath"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"testing"

	"github.com/novox/mesh-controller/internal/catalogue"
)

// The schemas the controller serves, verb by verb, as the console receives them: from the
// announcement, not the table — what is checked is what a caller is shown (novox/hq issue 244).
func servedSchemas(t *testing.T) map[string]catalogue.Verb {
	t.Helper()
	handlers, behind, err := seatToolHandlers()
	if err != nil {
		t.Fatal(err)
	}
	if len(behind) != 0 {
		t.Fatalf("this build cannot run %v of its own seat's verbs", behind)
	}
	served := map[string]catalogue.Verb{}
	for _, e := range seatAnnouncement(handlers).Endpoints {
		var input map[string]any
		if err := json.Unmarshal([]byte(e.Metadata["schema"]), &input); err != nil {
			t.Fatalf("%s announces a schema that is not JSON: %v", e.Name, err)
		}
		served[e.Metadata["tool"]] = catalogue.Verb{Name: e.Metadata["tool"], Input: input}
	}
	if len(served) != len(catalogue.ControllerVerbs) {
		t.Fatalf("%d verbs served for %d in the table", len(served), len(catalogue.ControllerVerbs))
	}
	return served
}

// subsetsOf is every subset of the names, the empty one included.
func subsetsOf(names []string) [][]string {
	var out [][]string
	for mask := 0; mask < 1<<len(names); mask++ {
		var s []string
		for i, n := range names {
			if mask&(1<<i) != 0 {
				s = append(s, n)
			}
		}
		out = append(out, s)
	}
	return out
}

func argumentsFor(subset []string, switches map[string]bool) map[string]any {
	args := map[string]any{}
	for _, n := range subset {
		if switches[n] {
			args[n] = "true"
		} else {
			args[n] = "x-" + n
		}
	}
	return args
}

// saidOutright are the switches that say the default aloud, so the line is the same without them —
// on purpose, and only these.
var saidOutright = map[string]string{
	"push": "behind", // the whole mesh is what no machine means; behind lets a caller say they meant it
}

// **No argument a caller gives is passed over** (novox/hq issue 244). For every verb served and
// every combination of the arguments its schema declares, the verb either refuses the call, or
// composes a command line that each given argument changed: taking any one away changes the line
// or makes it refused. An argument the line is the same without is one the verb ignored — the
// shape of the push that named a machine and pushed every machine behind.
func TestNoArgumentAVerbIsGivenIsPassedOver(t *testing.T) {
	for name, v := range servedSchemas(t) {
		if inProcess[name] {
			continue
		}
		names, switches := declaredArguments(v)
		for _, subset := range subsetsOf(names) {
			args := argumentsFor(subset, switches)
			argv, err := argvFor(name, args)
			if err != nil {
				if strings.Contains(err.Error(), "does not declare") {
					t.Errorf("%s %v: %v", name, args, err)
				}
				continue
			}
			for _, dropped := range subset {
				fewer := map[string]any{}
				for k, val := range args {
					if k != dropped {
						fewer[k] = val
					}
				}
				without, err := argvFor(name, fewer)
				if err == nil && reflect.DeepEqual(argv, without) && saidOutright[name] != dropped {
					t.Errorf("%s ignores %q given with %v: %v either way", name, dropped, subset, argv)
				}
			}
		}
	}
}

// **An argument a verb does not declare is refused, naming it — never dropped.** Every verb, with
// what it requires and one argument more; and `node` in particular, for every verb whose schema
// does not take a machine.
func TestAnArgumentAVerbDoesNotDeclareIsRefused(t *testing.T) {
	for name, v := range servedSchemas(t) {
		names, _ := declaredArguments(v)
		strangers := []string{"no-such-argument"}
		if !contains(names, "node") {
			strangers = append(strangers, "node")
		}
		for _, stranger := range strangers {
			args := sampleArguments(v)
			args[stranger] = "x"
			_, err := argvFor(name, args)
			if inProcess[name] {
				_, err = readArguments(name, args)
			}
			if err == nil || !strings.Contains(err.Error(), strconv.Quote(stranger)) {
				t.Errorf("%s took %q, which it does not declare: %v", name, stranger, err)
			}
		}
	}
	if _, err := argvFor("clear", map[string]any{"dead": "yes"}); err == nil {
		t.Error("a switch took a word that is neither true nor false, and would have read it as false")
	}
	if _, err := argvFor("node", map[string]any{"node": 7}); err == nil {
		t.Error("a number was taken as a machine's name, or as no machine")
	}
	if argv, err := argvFor("clear", map[string]any{"dead": true}); err != nil || strings.Join(argv, " ") != "clear --dead" {
		t.Errorf("a switch given as JSON true: %v %v", argv, err)
	}
}

// The push that was the cause: a machine named is that machine; none named is the whole mesh, and
// naming one beside behind is refused rather than one of the two guessed.
func TestAPushIsOneMachineOrSaysItIsTheWholeMesh(t *testing.T) {
	argv, err := argvFor("push", map[string]any{"node": "g1", "why": "w"})
	if err != nil || strings.Join(argv, " ") != "push g1 --wait 0 --why w" {
		t.Fatalf("a named push: %v %v", argv, err)
	}
	for _, args := range []map[string]any{{"why": "w"}, {"behind": "true", "why": "w"}} {
		argv, err := argvFor("push", args)
		if err != nil || strings.Join(argv, " ") != "push --behind --wait 0 --why w" {
			t.Fatalf("a push of the whole mesh %v: %v %v", args, argv, err)
		}
	}
	if _, err := argvFor("push", map[string]any{"node": "g1", "behind": "true", "why": "w"}); err == nil ||
		!strings.Contains(err.Error(), `"behind"`) {
		t.Fatalf("a named push with behind was taken: %v", err)
	}
	if _, err := argvFor("push", map[string]any{"machine": "g1"}); err == nil || !strings.Contains(err.Error(), `"machine"`) {
		t.Fatalf("a push given the machine under another name ran as a push of every machine: %v", err)
	}
}

// commandFlags is every flag set this package's commands parse, by the name the set is made with,
// and the flags defined on it — read from the source, so a flag added to a command is seen here
// without anyone remembering to.
func commandFlags(t *testing.T) map[string][]string {
	t.Helper()
	files, err := filepath.Glob("*.go")
	if err != nil {
		t.Fatal(err)
	}
	fset := token.NewFileSet()
	out := map[string][]string{}
	for _, f := range files {
		if strings.HasSuffix(f, "_test.go") {
			continue
		}
		file, err := parser.ParseFile(fset, f, nil, 0)
		if err != nil {
			t.Fatal(err)
		}
		for _, decl := range file.Decls {
			fn, ok := decl.(*ast.FuncDecl)
			if !ok || fn.Body == nil {
				continue
			}
			sets := map[string]string{} // variable → the set's name
			ast.Inspect(fn.Body, func(n ast.Node) bool {
				if assign, ok := n.(*ast.AssignStmt); ok && len(assign.Lhs) == 1 && len(assign.Rhs) == 1 {
					if call, ok := assign.Rhs[0].(*ast.CallExpr); ok && isSelector(call.Fun, "flag", "NewFlagSet") {
						if id, ok := assign.Lhs[0].(*ast.Ident); ok {
							if name, ok := stringLit(call.Args[0]); ok {
								sets[id.Name] = name
								out[name] = append(out[name], []string{}...)
							}
						}
					}
				}
				call, ok := n.(*ast.CallExpr)
				if !ok {
					return true
				}
				sel, ok := call.Fun.(*ast.SelectorExpr)
				if !ok {
					return true
				}
				recv, ok := sel.X.(*ast.Ident)
				if !ok || sets[recv.Name] == "" {
					return true
				}
				arg := 0
				switch sel.Sel.Name {
				case "Bool", "String", "Int", "Int64", "Uint", "Uint64", "Float64", "Duration", "Func", "BoolFunc", "TextVar":
				case "BoolVar", "StringVar", "IntVar", "Int64Var", "UintVar", "Uint64Var", "Float64Var", "DurationVar", "Var":
					arg = 1
				default:
					return true
				}
				if arg < len(call.Args) {
					if flagName, ok := stringLit(call.Args[arg]); ok {
						out[sets[recv.Name]] = append(out[sets[recv.Name]], flagName)
					}
				}
				return true
			})
		}
	}
	return out
}

func isSelector(e ast.Expr, pkg, name string) bool {
	sel, ok := e.(*ast.SelectorExpr)
	if !ok {
		return false
	}
	id, ok := sel.X.(*ast.Ident)
	return ok && id.Name == pkg && sel.Sel.Name == name
}

func stringLit(e ast.Expr) (string, bool) {
	lit, ok := e.(*ast.BasicLit)
	if !ok || lit.Kind != token.STRING {
		return "", false
	}
	s, err := strconv.Unquote(lit.Value)
	return s, err == nil
}

// accountedFlags are the flags of a verb's command that are not an argument of the same name:
// carried by an argument named otherwise ("=argument"), or set by the verb itself, or withheld from
// the named verb on purpose — each with why. `command` reaches every flag of the binary regardless.
var accountedFlags = map[string]map[string]string{
	"status": {"json": "set by the verb: the answer is data"},
	"seats":  {"json": "set by the verb: the answer is data"},
	"queue":  {"json": "not set: the verb answers the table a person reads"},
	"plan":   {"json": "set by the verb unless files is asked"},
	"push": {
		"wait": "set by the verb to 0: a tool call cannot hold a connection for a whole apply",
		"all": "withheld: the verb naming no machine is --behind, and a push of every machine is said at a " +
			"shell (novox/hq ADR 0217); `command` reaches it",
	},
	"build": {
		"wait":    "set by the verb to 0: the id follows the build (issue 176)",
		"self":    "set by the verb from the repository's form: a path on the forge, or a URL",
		"dry-run": "withheld: a dry run answers only when the build ends, which a call cannot wait for; `command` reaches it",
		"behind":  "withheld: the named verb builds one named repository; `command` reaches the rest",
		"on":      "withheld: the named verb builds one named repository; `command` reaches the rest",
	},
	"builds": {"n": "=limit"},
	"plans":  {"n": "=limit", "what-if": "=repository"},
	"durations": {
		"json": "set by the verb: the answer is data",
		"all":  "withheld: every measurement of a fortnight is more than a call should carry; `command` reaches it",
	},
	"hand-acts":          {"json": "set by the verb: the answer is data"},
	"conditions":         {"json": "set by the verb: the answer is data"},
	"retire":             {"json": "set by the verb: the answer is data"},
	"cleanup":            {"json": "set by the verb: the answer is data"},
	"data":               {"json": "set by the verb: the answer is data"},
	"conditions history": {"json": "set by the verb: the answer is data"},
	"conditions show":    {"json": "set by the verb: the answer is data"},
	"healers":            {"json": "set by the verb: the answer is data"},
}

// **Every flag of the command a verb runs is in the verb's schema, or accounted for here.** Derived
// from the source, so a flag added to a command — or a verb added whose command takes flags —
// fails this until somebody decides, in writing, how a caller reaches it (novox/hq issue 244). And
// a flag accounted for that no longer exists fails too, so the table cannot rot into a list nobody
// reads.
func TestEveryFlagOfAVerbsCommandIsAnArgumentOrAccountedFor(t *testing.T) {
	flags := commandFlags(t)
	if len(flags["push"]) == 0 || len(flags["plan"]) == 0 {
		t.Fatalf("reading the commands' flags found nothing for push or plan: %v", flags)
	}
	reached := map[string]map[string]bool{} // verb → flag sets its command lines reach
	served := servedSchemas(t)
	for name, v := range served {
		if inProcess[name] || name == "command" {
			continue
		}
		names, switches := declaredArguments(v)
		for _, subset := range subsetsOf(names) {
			argv, err := argvFor(name, argumentsFor(subset, switches))
			if err != nil {
				continue
			}
			// The flag set is named by the longest run of leading words that names one.
			var words []string
			for _, w := range argv {
				if strings.HasPrefix(w, "-") {
					break
				}
				words = append(words, w)
			}
			for n := len(words); n > 0; n-- {
				if _, has := flags[strings.Join(words[:n], " ")]; has {
					if reached[name] == nil {
						reached[name] = map[string]bool{}
					}
					reached[name][strings.Join(words[:n], " ")] = true
					break
				}
			}
		}
	}
	used := map[string]map[string]bool{}
	verbs := make([]string, 0, len(reached))
	for verb := range reached {
		verbs = append(verbs, verb)
	}
	sort.Strings(verbs)
	for _, verb := range verbs {
		declared, _ := declaredArguments(served[verb])
		for set := range reached[verb] {
			if used[set] == nil {
				used[set] = map[string]bool{}
			}
			for _, flagName := range flags[set] {
				why, accounted := accountedFlags[set][flagName]
				switch {
				case accounted && strings.HasPrefix(why, "="):
					used[set][flagName] = true
					if !contains(declared, strings.TrimPrefix(why, "=")) {
						t.Errorf("%s: --%s of `%s` is said to be carried by %q, which the schema does not declare",
							verb, flagName, set, strings.TrimPrefix(why, "="))
					}
				case accounted:
					used[set][flagName] = true
				case contains(declared, flagName):
				default:
					t.Errorf("%s runs `%s`, which takes --%s, and the verb's schema has no %q: declare it, "+
						"or say in accountedFlags why a caller does not reach it", verb, set, flagName, flagName)
				}
			}
		}
	}
	for set, fs := range accountedFlags {
		for flagName := range fs {
			if !used[set][flagName] {
				t.Errorf("accountedFlags names --%s of `%s`, which no verb's command takes any more", flagName, set)
			}
		}
	}
}

// Every verb's required arguments are properties of its schema: a schema that requires what it
// does not describe is the uncallable verb of issue 244 from the other side.
func TestEveryRequiredArgumentIsDescribed(t *testing.T) {
	for name, v := range servedSchemas(t) {
		names, _ := declaredArguments(v)
		for k := range sampleArguments(v) {
			if !contains(names, k) {
				t.Errorf("%s requires %q and does not describe it", name, k)
			}
		}
	}
}