package cli

import (
	"bytes"
	"context"
	"path/filepath"
	"strings"
	"testing"
)

func TestAgentFlags(t *testing.T) {
	cfg, err := parseAgentFlags(nil, &bytes.Buffer{}, noEnv)
	if err != nil {
		t.Fatal(err)
	}
	if cfg.DataDir != "./suldata" || cfg.DockerSocket != "/var/run/docker.sock" || cfg.ServerURL != "" || cfg.Token != "" ||
		cfg.ConfigDir != "/etc/sultan.d" {
		t.Errorf("Defaults: %+v", cfg)
	}
	cfg, err = parseAgentFlags([]string{
		"--server=https://ingress:8443", "--token", "sltn_enroll_x.y", "--data-dir=/srv/sul",
		"--node-id=pi", "--docker-socket=none", "--backend-host=100.64.0.42", "--backend-interface=wt0",
		"--config-dir=/srv/sultan.d", "--fqdn=webdocker11.lan.r25dc.de",
	}, &bytes.Buffer{}, noEnv)
	if err != nil {
		t.Fatal(err)
	}
	if cfg.ServerURL != "https://ingress:8443" || cfg.Token != "sltn_enroll_x.y" || cfg.DataDir != "/srv/sul" ||
		cfg.NodeID != "pi" || cfg.DockerSocket != "none" || cfg.BackendHost != "100.64.0.42" || cfg.BackendInterface != "wt0" ||
		cfg.ConfigDir != "/srv/sultan.d" || cfg.FQDN != "webdocker11.lan.r25dc.de" {
		t.Errorf("Overrides: %+v", cfg)
	}
	if _, err := parseAgentFlags([]string{"--gibts-nicht"}, &bytes.Buffer{}, noEnv); err == nil {
		t.Error("unbekanntes Flag akzeptiert")
	}
}

func TestRun_AgentNotEnrolled(t *testing.T) {
	dir := filepath.Join(t.TempDir(), "suldata")
	code, _, stderr := run(context.Background(), "agent", "--data-dir="+dir, "--docker-socket=none")
	if code != 1 || !strings.Contains(stderr, "--token") {
		t.Errorf("code=%d stderr=%q", code, stderr)
	}
}

func TestRun_AgentBadConfig(t *testing.T) {
	code, _, stderr := run(context.Background(), "agent", "--server=http://ingress:8443", "--token=x")
	if code != 2 || !strings.Contains(stderr, "https") {
		t.Errorf("http-URL: code=%d stderr=%q", code, stderr)
	}
	if code, _, _ := run(context.Background(), "agent", "--help"); code != 0 {
		t.Errorf("--help: code=%d", code)
	}
}

func noEnv(string) string { return "" }

// Token und Server auch per Umgebung (curl | sh, Compose) – Flags gewinnen.
func TestAgentFlags_Environment(t *testing.T) {
	env := map[string]string{"SULTAN_TOKEN": "sltn_enroll_env", "SULTAN_SERVER": "https://env:8443"}
	getenv := func(k string) string { return env[k] }

	cfg, err := parseAgentFlags(nil, &bytes.Buffer{}, getenv)
	if err != nil || cfg.Token != "sltn_enroll_env" || cfg.ServerURL != "https://env:8443" {
		t.Errorf("aus Umgebung: %+v %v", cfg, err)
	}
	cfg, _ = parseAgentFlags([]string{"--token=flag", "--server=https://flag:8443"}, &bytes.Buffer{}, getenv)
	if cfg.Token != "flag" || cfg.ServerURL != "https://flag:8443" {
		t.Errorf("Flags müssen gewinnen: %+v", cfg)
	}
}

func TestRun_AgentMaintenanceCommand(t *testing.T) {
	dir := filepath.Join(t.TempDir(), "suldata")
	code, _, stderr := run(context.Background(), "agent", "maintenance", "on", "--data-dir="+dir)
	if code != 1 || !strings.Contains(stderr, "registriert") {
		t.Errorf("nicht registriert: code=%d stderr=%q", code, stderr)
	}
	for _, args := range [][]string{
		{"agent", "maintenance"},
		{"agent", "maintenance", "vielleicht"},
		{"agent", "maintenance", "on", "--for=bald"},
	} {
		if code, _, _ := run(context.Background(), args...); code != 2 {
			t.Errorf("%v: code=%d", args, code)
		}
	}
}

func TestAgentFlags_EnvironmentAll(t *testing.T) {
	cfg, err := parseAgentFlags(nil, &bytes.Buffer{}, envMap(map[string]string{
		"SULTAN_DATA_DIR": "/srv/agent", "SULTAN_NODE_ID": "pi", "SULTAN_CONFIG_DIR": "none", "SULTAN_BACKEND_INTERFACE": "wt0",
	}))
	if err != nil || cfg.DataDir != "/srv/agent" || cfg.NodeID != "pi" || cfg.ConfigDir != "none" || cfg.BackendInterface != "wt0" {
		t.Errorf("aus Umgebung: %+v %v", cfg, err)
	}
}