package cli

import (
	"errors"
	"strings"
	"testing"
	"time"

	"reasonix/internal/agent"
	"reasonix/internal/boot"
	"reasonix/internal/command"
	"reasonix/internal/control"
	"reasonix/internal/event"
	"reasonix/internal/provider"
	"reasonix/internal/skill"
)

func TestRenderWorkModesShowsAllOptionsAndCurrent(t *testing.T) {
	out := renderWorkModes(100, boot.TokenModeFull)
	for _, want := range []string{"economy", "balanced", "delivery", "current"} {
		if !strings.Contains(out, want) {
			t.Fatalf("renderWorkModes missing %q:\n%s", want, out)
		}
	}
}

func TestParseWorkModeKeepsBalancedAsFullInternally(t *testing.T) {
	for input, want := range map[string]string{
		"economy":  boot.TokenModeEconomy,
		"balanced": boot.TokenModeFull,
		"full":     boot.TokenModeFull,
		"delivery": boot.TokenModeDelivery,
	} {
		got, ok := parseWorkMode(input)
		if !ok || got != want {
			t.Errorf("parseWorkMode(%q) = %q, %v; want %q, true", input, got, ok, want)
		}
	}
}

func TestWorkModeCompletionPublishesPrimaryCommandAndAliasArguments(t *testing.T) {
	m := newTestChatTUI()
	m.runtimeProfile = boot.TokenModeFull
	if !hasLabel(m.slashItems(), "/work-mode") {
		t.Fatal("slash completion missing /work-mode")
	}
	if hasLabel(m.slashItems(), "/profile") {
		t.Fatal("technical /profile alias should not duplicate the primary command in the slash menu")
	}
	for _, input := range []string{"/work-mode ", "/profile "} {
		items, _, ok := m.slashArgItems(input)
		if !ok {
			t.Fatalf("%q did not activate work-mode argument completion", input)
		}
		for _, want := range []string{"economy", "balanced", "delivery"} {
			if !hasLabel(items, want) {
				t.Errorf("%q completion missing %q: %v", input, want, labels(items))
			}
		}
	}
}

func TestWorkModeHelpAndStatusUseUserFacingName(t *testing.T) {
	if !hasLabel(builtinHelpItems(), "/work-mode") {
		t.Fatal("built-in help missing /work-mode")
	}
	if hasLabel(builtinHelpItems(), "/profile") {
		t.Fatal("built-in help should not duplicate the technical /profile alias")
	}
	m := newChatTUI(control.New(control.Options{Label: "model"}), "", make(chan event.Event, 1), 80)
	m.runtimeProfile = boot.TokenModeDelivery
	if got := m.workModeTag(); !strings.Contains(got, "delivery") {
		t.Fatalf("work-mode status tag = %q, want delivery", got)
	}
	m.width = 30
	if got := m.computeStatusLineCount(m.width); got < 2 {
		t.Fatalf("status-line count with work-mode tag = %d, want at least 2", got)
	}
}

func TestWorkModeSwitchBuildsTargetProfileAndSwapsAtomically(t *testing.T) {
	oldCtrl := control.New(control.Options{Label: "old"})
	oldCtrl.SetToolApprovalMode(control.ToolApprovalAuto)
	oldCtrl.SetPlanMode(true)
	newCtrl := control.New(control.Options{
		Label:    "new",
		Commands: []command.Command{{Name: "fresh-command"}},
		Skills:   []skill.Skill{{Name: "Fresh Skill"}},
	})
	m := newChatTUI(oldCtrl, "", make(chan event.Event, 1), 100)
	m.modelRef = "provider/model"
	m.runtimeProfile = boot.TokenModeFull
	var gotSpec controllerBuildSpec
	var gotCarry []provider.Message
	m.buildController = func(spec controllerBuildSpec, carry []provider.Message, _ string) (*control.Controller, error) {
		gotSpec = spec
		gotCarry = carry
		return newCtrl, nil
	}

	cmd := m.runWorkModeCommand("/work-mode delivery")
	if cmd == nil {
		t.Fatal("work-mode switch did not schedule a controller build")
	}
	if m.ctrl != oldCtrl || m.runtimeProfile != boot.TokenModeFull {
		t.Fatal("controller or profile changed before the replacement build completed")
	}
	next, _ := m.Update(cmd())
	m = next.(chatTUI)

	if gotSpec.ModelRef != "provider/model" || gotSpec.RuntimeProfile != boot.TokenModeDelivery {
		t.Fatalf("build spec = %+v, want current model and delivery profile", gotSpec)
	}
	if gotSpec.ToolApprovalMode != control.ToolApprovalAuto {
		t.Fatalf("build spec approval mode = %q, want auto", gotSpec.ToolApprovalMode)
	}
	if !gotSpec.PlanMode {
		t.Fatal("build spec did not preserve plan mode")
	}
	if len(gotCarry) != len(oldCtrl.History()) {
		t.Fatalf("carried history length = %d, want %d", len(gotCarry), len(oldCtrl.History()))
	}
	if m.ctrl != newCtrl || m.runtimeProfile != boot.TokenModeDelivery {
		t.Fatalf("successful switch did not install replacement controller/profile: ctrl=%p profile=%q", m.ctrl, m.runtimeProfile)
	}
	if m.label != newCtrl.Label() || len(m.commands) != 1 || len(m.skills) != 1 || m.host != newCtrl.Host() {
		t.Fatalf("successful switch did not refresh controller metadata: label=%q commands=%d skills=%d", m.label, len(m.commands), len(m.skills))
	}
	if len(m.oldControllers) != 1 || m.oldControllers[0] != oldCtrl {
		t.Fatal("successful switch did not retain the old controller for exit-time cleanup")
	}
}

func TestWorkModeSwitchFailureKeepsOldControllerAndProfile(t *testing.T) {
	session := agent.NewSession("system")
	session.Add(provider.Message{Role: provider.RoleUser, Content: "keep this history"})
	exec := agent.New(nil, nil, session, agent.Options{}, event.Discard)
	oldCtrl := control.New(control.Options{Label: "old", Executor: exec})
	m := newChatTUI(oldCtrl, "", make(chan event.Event, 1), 100)
	m.modelRef = "provider/model"
	m.runtimeProfile = boot.TokenModeEconomy
	m.buildController = func(controllerBuildSpec, []provider.Message, string) (*control.Controller, error) {
		return nil, errors.New("build failed")
	}

	cmd := m.runSlashCommand("/profile delivery")
	if cmd == nil {
		t.Fatal("/profile alias did not schedule a controller build")
	}
	next, _ := m.Update(cmd())
	m = next.(chatTUI)

	if m.ctrl != oldCtrl || m.runtimeProfile != boot.TokenModeEconomy {
		t.Fatalf("failed switch changed live runtime: ctrl=%p profile=%q", m.ctrl, m.runtimeProfile)
	}
	if history := m.ctrl.History(); len(history) != 2 || history[1].Content != "keep this history" {
		t.Fatalf("failed switch lost history: %#v", history)
	}
	if m.modelSwitchPending || m.pendingModelSwitch != nil {
		t.Fatal("failed switch left the runtime-switch gate pending")
	}
	if len(m.oldControllers) != 0 {
		t.Fatal("failed switch retired the still-live old controller")
	}
}

func TestWorkModeSwitchRejectsInvalidSameAndBusyRequests(t *testing.T) {
	m := newTestChatTUI()
	m.ctrl = control.New(control.Options{Label: "model"})
	m.modelRef = "provider/model"
	m.runtimeProfile = boot.TokenModeFull
	builds := 0
	m.buildController = func(controllerBuildSpec, []provider.Message, string) (*control.Controller, error) {
		builds++
		return control.New(control.Options{Label: "new"}), nil
	}

	for _, input := range []string{
		"/work-mode unknown",
		"/work-mode balanced",
		"/work-mode economy extra",
	} {
		if cmd := m.runWorkModeCommand(input); cmd != nil {
			t.Fatalf("%q unexpectedly scheduled a build", input)
		}
	}
	m.pendingApproval = &event.Approval{ID: "approval", Tool: "bash"}
	if cmd := m.runWorkModeCommand("/work-mode economy"); cmd != nil {
		t.Fatal("pending approval should block work-mode switching")
	}
	if builds != 0 {
		t.Fatalf("rejected work-mode requests triggered %d builds", builds)
	}
}

func TestWorkModeSwitchRejectsRunningTurn(t *testing.T) {
	runner := &blockingTurnRunner{started: make(chan struct{})}
	ctrl := control.New(control.Options{Runner: runner, Sink: event.Discard, SessionDir: t.TempDir(), Label: "model"})
	ctrl.Send("keep running")
	<-runner.started
	t.Cleanup(func() {
		ctrl.Cancel()
		deadline := time.Now().Add(2 * time.Second)
		for ctrl.Running() && time.Now().Before(deadline) {
			time.Sleep(time.Millisecond)
		}
	})

	m := newTestChatTUI()
	m.ctrl = ctrl
	m.modelRef = "provider/model"
	m.runtimeProfile = boot.TokenModeFull
	builds := 0
	m.buildController = func(controllerBuildSpec, []provider.Message, string) (*control.Controller, error) {
		builds++
		return control.New(control.Options{}), nil
	}
	if cmd := m.runWorkModeCommand("/work-mode delivery"); cmd != nil {
		t.Fatal("running turn should block work-mode switching")
	}
	if builds != 0 {
		t.Fatalf("running-turn guard triggered %d builds", builds)
	}
}

func TestRuntimeRebuildCommandsCarryCurrentWorkMode(t *testing.T) {
	isolateUserConfig(t)
	m := newTestChatTUI()
	m.ctrl = control.New(control.Options{Label: "deepseek-flash"})
	m.modelRef = "deepseek-flash/deepseek-v4-flash"
	m.runtimeProfile = boot.TokenModeDelivery
	var specs []controllerBuildSpec
	m.buildController = func(spec controllerBuildSpec, _ []provider.Message, _ string) (*control.Controller, error) {
		specs = append(specs, spec)
		return control.New(control.Options{Label: "deepseek-flash"}), nil
	}

	cmd := m.runEffortCommand("/effort max")
	if cmd == nil {
		t.Fatal("effort switch did not schedule a rebuild")
	}
	next, _ := m.Update(cmd())
	m = next.(chatTUI)

	m.runModelSubcommand("/model deepseek-flash/another-model")
	if m.pendingModelSwitch == nil {
		t.Fatal("model switch did not schedule a rebuild")
	}
	next, _ = m.Update(m.pendingModelSwitch())
	m = next.(chatTUI)

	if !m.scheduleSkillSessionRefresh("test", "") {
		t.Fatal("skill refresh did not schedule a rebuild")
	}
	next, _ = m.Update(m.pendingModelSwitch())
	m = next.(chatTUI)

	if len(specs) != 3 {
		t.Fatalf("runtime rebuild count = %d, want 3", len(specs))
	}
	for i, spec := range specs {
		if spec.RuntimeProfile != boot.TokenModeDelivery {
			t.Errorf("rebuild %d lost delivery profile: %+v", i, spec)
		}
	}
}