package instancectl

import (
	"context"
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"
)

// newClient serves a Server on a real unix socket with the given fake
// systemctl and returns the agent-side Client for it.
func newClient(t *testing.T, ctl *fakeCtl, configure ...func(*Server)) (*Server, *Client) {
	t.Helper()
	s, sock := serveOnSocket(t, ctl, configure...)
	return s, NewClient(sock)
}

func TestClientStartCarriesTierAndReturnsInvocation(t *testing.T) {
	ctl := &fakeCtl{answers: map[string]string{"show -p InvocationID --value": "inv1\n"}}
	_, c := newClient(t, ctl)
	inv, err := c.Start(context.Background(), "h.example.com", RoleRun, 536870912)
	if err != nil || inv != "inv1" {
		t.Fatalf("Start = %q, %v", inv, err)
	}
	if !strings.Contains(ctl.joined(), "MemoryMax=536870912") {
		t.Errorf("tier not sent: %s", ctl.joined())
	}
	if !strings.Contains(ctl.joined(), "start "+UnitName(RoleRun, "h.example.com")) {
		t.Errorf("run unit not started: %s", ctl.joined())
	}
}

func TestClientSeedStopResetSweep(t *testing.T) {
	ctl := &fakeCtl{answers: map[string]string{
		"show -p InvocationID,Result,ExecMainStatus,ExecMainCode": "InvocationID=s1\nResult=success\nExecMainStatus=0\nExecMainCode=exited\n",
	}}
	_, c := newClient(t, ctl)
	res, err := c.Seed(context.Background(), "h.example.com", 536870912)
	if err != nil || res.Result != "success" || res.InvocationID != "s1" || res.Status != "0" || res.Code != "exited" {
		t.Fatalf("Seed = %+v, %v", res, err)
	}
	if err := c.Stop(context.Background(), "h.example.com", RoleSidecar); err != nil {
		t.Fatalf("Stop: %v", err)
	}
	if !strings.Contains(ctl.joined(), "stop "+UnitName(RoleSidecar, "h.example.com")) {
		t.Errorf("sidecar unit not stopped: %s", ctl.joined())
	}
	if err := c.Reset(context.Background(), "h.example.com", RoleRun); err != nil {
		t.Fatalf("Reset: %v", err)
	}
	sw, err := c.Sweep(context.Background())
	if err != nil || len(sw.Units) != 0 || len(sw.Failed) != 0 {
		t.Fatalf("Sweep = %+v, %v", sw, err)
	}
}

func TestClientReadyIsNilOn204AndCarriesTheReportOn503(t *testing.T) {
	ctl := &fakeCtl{}
	s, c := newClient(t, ctl)
	// Before the first probe the server answers 503 with one line saying
	// so; the client surfaces it as a NotReadyError whose message names
	// the failing line.
	err := c.Ready(context.Background())
	var nr *NotReadyError
	if !errors.As(err, &nr) || len(nr.Report.Lines) != 1 || nr.Report.Lines[0].Check != "probe" {
		t.Fatalf("Ready before a probe = %v", err)
	}
	if !strings.Contains(err.Error(), "not yet run") {
		t.Errorf("message = %q", err.Error())
	}
	b, _ := json.Marshal(ProbeReport{Ready: true, Lines: []VerdictLine{{Check: "pid1", Verdict: "ok"}}})
	if err := os.WriteFile(s.ProbeOut, b, 0o644); err != nil {
		t.Fatal(err)
	}
	s.RunProbe(context.Background())
	if err := c.Ready(context.Background()); err != nil {
		t.Fatalf("Ready after a passing probe: %v", err)
	}
}

func TestClientSurfacesTheServersMessageOnA502(t *testing.T) {
	ctl := &fakeCtl{fail: map[string]error{"start": errors.New("boom")}}
	_, c := newClient(t, ctl)
	_, err := c.Start(context.Background(), "h.example.com", RoleRun, 536870912)
	if err == nil || !strings.Contains(err.Error(), "boom") || !strings.Contains(err.Error(), "/start") {
		t.Fatalf("Start error = %v, want the server's message and the verb", err)
	}
}

func TestClientSweepReturnsThePartialListWithTheError(t *testing.T) {
	// One unit is listed, its stop fails, and the server answers 502 with
	// the partial result; the client returns both.
	unit := UnitName(RoleRun, "h.example.com")
	ctl := &fakeCtl{
		answers: map[string]string{
			"list-units": unit + " loaded active running carlos instance\n",
		},
		fail: map[string]error{"stop": errors.New("would not stop")},
	}
	_, c := newClient(t, ctl)
	sw, err := c.Sweep(context.Background())
	if err == nil {
		t.Fatalf("Sweep = %+v, want an error", sw)
	}
	if _, listed := sw.Failed[unit]; !listed {
		t.Errorf("Failed = %+v, want %s", sw.Failed, unit)
	}
}

func TestClientRefusesWhenTheSocketIsAbsent(t *testing.T) {
	c := NewClient(filepath.Join(t.TempDir(), "absent.sock"))
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	if err := c.Ready(ctx); err == nil || !strings.Contains(err.Error(), "instance control socket") {
		t.Fatalf("absent socket: %v", err)
	}
}

// The agent side of #256: a 204 from a service that reports another build,
// or none at all (a release before the header), is not ready. Both are
// the service carlos system apply or the roll script left running across
// a binary change, and the error names the restart.
func TestClientReadyRefusesAControlServiceOfAnotherBuild(t *testing.T) {
	ctl := &fakeCtl{}
	s, c := newClient(t, ctl, func(s *Server) { s.Build = "" })
	b, _ := json.Marshal(ProbeReport{Ready: true, Lines: []VerdictLine{{Check: "pid1", Verdict: "ok"}}})
	if err := os.WriteFile(s.ProbeOut, b, 0o644); err != nil {
		t.Fatal(err)
	}
	s.RunProbe(context.Background())
	c.Build = "new1234"
	err := c.Ready(context.Background())
	var stale *StaleBuildError
	if !errors.As(err, &stale) || stale.Running != "" || !strings.Contains(err.Error(), "older build") || !strings.Contains(err.Error(), "restart carlos-instance-control.service") {
		t.Fatalf("no header: Ready = %v", err)
	}
	s.Build = "old5678"
	err = c.Ready(context.Background())
	if !errors.As(err, &stale) || stale.Running != "old5678" || !strings.Contains(err.Error(), "running build old5678, this agent is new1234") {
		t.Fatalf("other build: Ready = %v", err)
	}
	s.Build = "new1234"
	if err := c.Ready(context.Background()); err != nil {
		t.Fatalf("same build: Ready = %v", err)
	}
	// A client with no build of its own (a test's literal) does not judge.
	c.Build = ""
	s.Build = ""
	if err := c.Ready(context.Background()); err != nil {
		t.Fatalf("unjudged: Ready = %v", err)
	}
	// NewClient judges with this process's own build.
	if NewClient(c.Path).Build == "" {
		t.Fatal("NewClient left Build empty; production would never check")
	}
}