cli

func listCommands(node *parser.CommandNode, prefix string) string

{
	names := make([]string, 0, len(node.Children))
	for name, child := range node.Children {
		if child.Name == name {
			fullName := prefix + name
			names = append(names, fullName)
		}
	}
	sort.Strings(names)
	return strings.Join(names, " ")
}

func writeFishCompletions(w io.Writer, node *parser.CommandNode, name string, parentPrefix string) error

{
	for flagName, meta := range node.Flags {
		desc := meta.Description
		if desc == "" {
			desc = flagName
		}
		short := ""
		if meta.Short != "" {
			short = fmt.Sprintf("-s %s", meta.Short)
		}
		_, err := fmt.Fprintf(w, "complete -c %s -n '__fish_seen_subcommand_from %s' -l %s %s -d '%s'\n",
			name, parentPrefix, flagName, short, desc)
		if err != nil {
			return err
		}
	}

	for childName, child := range node.Children {
		if child.Name != childName {
			continue
		}
		newPrefix := parentPrefix
		if newPrefix != "" {
			newPrefix += " "
		}
		newPrefix += childName

		_, err := fmt.Fprintf(w, "complete -c %s -n '__fish_seen_subcommand_from %s' -a %s -d '%s'\n",
			name, parentPrefix, childName, child.Description)
		if err != nil {
			return err
		}

		if err := writeFishCompletions(w, child, name, newPrefix); err != nil {
			return err
		}
	}
	return nil
}

func applyBindings(node *parser.CommandNode, flags map[string]string, args []string, effectiveFlags map[string]*parser.FlagMetadata) error

{
	val := node.Value
	if val.Kind() != reflect.Ptr && val.CanAddr() {
		val = val.Addr()
	}

	b, err := binder.NewBinder(val.Interface())
	if err != nil {
		return err
	}

	for name, meta := range effectiveFlags {
		m := meta

		switch m.Field.Kind() {
		case reflect.Bool:
			b.AddBool(name, func(v bool) error {
				m.Field.SetBool(v)
				return nil
			})
		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
			if m.Field.Type() == reflect.TypeOf(time.Duration(0)) {
				b.AddDuration(name, func(v time.Duration) error {
					m.Field.SetInt(int64(v))
					return nil
				})
			} else {
				b.AddInt(name, func(v int64) error {
					m.Field.SetInt(v)
					return nil
				})
			}
		case reflect.String:
			b.AddStrings(name, func(v []string) error {
				if len(v) > 0 {
					m.Field.SetString(v[0])
				}
				return nil
			})
		default:
			if m.Field.Kind() == reflect.Slice && m.Field.Type().Elem().Kind() == reflect.String {
				b.AddStrings(name, func(v []string) error {
					s := reflect.MakeSlice(m.Field.Type(), len(v), len(v))
					for i, val := range v {
						s.Index(i).SetString(val)
					}
					m.Field.Set(s)
					return nil
				})
			}
		}
	}

	for name, meta := range effectiveFlags {
		var passedVal *string
		if v, ok := flags[name]; ok {
			passedVal = &v
		}

		valToBind, err := resolver.GetValue(passedVal, meta.Env, meta.Default, meta.Field.Kind() == reflect.Bool)
		if err != nil {
			return err
		}

		if meta.Required && valToBind == "" && meta.Field.Kind() != reflect.Bool {
			return fmt.Errorf("missing required flag: --%s", name)
		}

		if valToBind != "" {
			if err := b.Run(name, []string{valToBind}); err != nil {
				return fmt.Errorf("invalid value for flag --%s: %w", name, err)
			}
		}
	}

	return bindArgs(node, args)
}

func resolveCommand(root *parser.CommandNode, args []string) (*parser.CommandNode, []string, error)

{
	current := root
	remaining := []string{}
	parsingCmds := true

	for i := range args {
		arg := args[i]

		if parsingCmds {
			if strings.HasPrefix(arg, "-") {
				remaining = append(remaining, arg)
			} else {
				if child, ok := current.Children[arg]; ok {
					current = child
				} else {
					// A command group (has subcommands, takes no positional
					// args of its own) cannot accept this token: it is an
					// unknown command, not a positional argument.
					if len(current.Children) > 0 && len(current.Args) == 0 {
						return current, remaining, fmt.Errorf("unknown command: %q", arg)
					}
					parsingCmds = false
					remaining = append(remaining, arg)
				}
			}
		} else {
			remaining = append(remaining, arg)
		}
	}

	return current, remaining, nil
}

func getPathToNode(root, target *parser.CommandNode) []*parser.CommandNode

{
	if root == target {
		return []*parser.CommandNode{root}
	}
	for _, child := range root.Children {
		path := getPathToNode(child, target)
		if path != nil {
			return append([]*parser.CommandNode{root}, path...)
		}
	}
	return nil
}

func parseArgs(args []string, effectiveFlags map[string]*parser.FlagMetadata) (map[string]string, []string, error)

{
	flags := make(map[string]string)
	positionals := []string{}

	shortMap := make(map[string]string)
	for name, meta := range effectiveFlags {
		if meta.Short != "" {
			shortMap[meta.Short] = name
		}
	}

	i := 0
	for i < len(args) {
		arg := args[i]

		if strings.HasPrefix(arg, "--") {
			name := arg[2:]
			value := ""
			hasValue := false

			if strings.Contains(name, "=") {
				parts := strings.SplitN(name, "=", 2)
				name = parts[0]
				value = parts[1]
				hasValue = true
			}

			meta, ok := effectiveFlags[name]
			if !ok {
				return nil, nil, fmt.Errorf("unknown flag: --%s", name)
			}

			if hasValue {
				flags[name] = value
			} else {
				if meta.Field.Kind() == reflect.Bool {
					flags[name] = "true"
				} else {
					if i+1 < len(args) {
						flags[name] = args[i+1]
						i++
					} else {
						return nil, nil, fmt.Errorf("flag needs an argument: --%s", name)
					}
				}
			}

		} else if strings.HasPrefix(arg, "-") {
			shorthand := arg[1:]
			name := shorthand
			value := ""
			hasValue := false

			if strings.Contains(name, "=") {
				parts := strings.SplitN(name, "=", 2)
				sName := parts[0]
				value = parts[1]
				hasValue = true

				if lName, ok := shortMap[sName]; ok {
					name = lName
				} else {
					return nil, nil, fmt.Errorf("unknown shorthand flag: -%s", sName)
				}
			} else {
				if lName, ok := shortMap[name]; ok {
					name = lName
				} else {
					if _, ok := effectiveFlags[name]; !ok {
						return nil, nil, fmt.Errorf("unknown shorthand flag: -%s", shorthand)
					}
				}
			}

			meta := effectiveFlags[name]

			if hasValue {
				flags[name] = value
			} else {
				if meta.Field.Kind() == reflect.Bool {
					flags[name] = "true"
				} else {
					if i+1 < len(args) {
						flags[name] = args[i+1]
						i++
					} else {
						return nil, nil, fmt.Errorf("flag needs an argument: -%s", shorthand)
					}
				}
			}

		} else {
			positionals = append(positionals, arg)
		}
		i++
	}

	return flags, positionals, nil
}

func bindArgs(node *parser.CommandNode, args []string) error

{
	argIdx := 0
	for _, meta := range node.Args {
		if meta.IsGreedy {
			if len(args) > argIdx {
				for _, v := range args[argIdx:] {
					if err := reflectutil.Bind(meta.Field, v); err != nil {
						return err
					}
				}
			} else if meta.Required {
				return fmt.Errorf("missing required positional arguments: %s", meta.Description)
			}
			break
		} else {
			if argIdx < len(args) {
				if err := reflectutil.Bind(meta.Field, args[argIdx]); err != nil {
					return err
				}
				argIdx++
			} else if meta.Required {
				return fmt.Errorf("missing required argument: %s", meta.Description)
			}
		}
	}
	return nil
}

func injectDependencies(node *parser.CommandNode, ctx context.Context, container *di.Container)

{
	logger := log.New()

	val := node.Value
	if val.Kind() == reflect.Ptr {
		val = val.Elem()
	}

	for i := 0; i < val.NumField(); i++ {
		field := val.Field(i)
		fieldType := val.Type().Field(i)

		if fieldType.Type == reflect.TypeFor[Base]() {
			if field.CanSet() {
				base := Base{
					Logger:    logger,
					Ctx:       ctx,
					Container: container,
				}
				field.Set(reflect.ValueOf(base))
			}
		}
	}

	if container != nil {
		injectDIFields(val, container)
	}
}

func makeNode(name, desc string, v any, opts ...func(*parser.CommandNode)) *parser.CommandNode

{
	rv := reflect.ValueOf(v)
	rv2 := rv
	for rv2.Kind() == reflect.Ptr {
		rv2 = rv2.Elem()
	}
	node := parser.NewCommandNode(name, desc, rv)
	for _, o := range opts {
		o(node)
	}
	return node
}

func TestNew_ValidRoot(t *testing.T)

{
	app, err := New(&testRootCmd{})
	if err != nil {
		t.Fatalf("New failed: %v", err)
	}
	if app.RootNode == nil {
		t.Fatal("expected non-nil RootNode")
	}
	if app.RootNode.Name != "root" {
		t.Errorf("got name %q, want %q", app.RootNode.Name, "root")
	}
	if len(app.RootNode.Children) != 2 {
		t.Errorf("expected 2 children, got %d", len(app.RootNode.Children))
	}
}

func TestAddCommand(t *testing.T)

{
	app, err := New(&testRootCmd{})
	if err != nil {
		t.Fatalf("New failed: %v", err)
	}
	child := makeNode("list", "List items", &testSimpleCmd{})
	app.AddCommand("list", child)
	if _, ok := app.RootNode.Children["list"]; !ok {
		t.Fatal("expected 'list' in children")
	}
}

func TestResolveCommand_Direct(t *testing.T)

{
	app, _ := New(&testRootCmd{})
	args := []string{"add", "myitem"}
	node, remaining, err := resolveCommand(app.RootNode, args)
	if err != nil {
		t.Fatalf("resolveCommand failed: %v", err)
	}
	if node.Name != "add" {
		t.Errorf("got node %q, want %q", node.Name, "add")
	}
	if len(remaining) != 1 || remaining[0] != "myitem" {
		t.Errorf("got remaining %v, want [myitem]", remaining)
	}
}

func TestResolveCommand_Nested(t *testing.T)

{
	type nested struct {
		Inner struct {
			AddCmd testAddCmd `cmd:"add" help:"Add command"`
		} `cmd:"inner" help:"Inner commands"`
	}
	app, _ := New(&nested{})
	args := []string{"inner", "add", "val"}
	node, _, err := resolveCommand(app.RootNode, args)
	if err != nil {
		t.Fatalf("resolveCommand failed: %v", err)
	}
	if node.Name != "add" {
		t.Errorf("got node %q, want %q", node.Name, "add")
	}
}

func TestResolveCommand_FlagsFirst(t *testing.T)

{
	app, _ := New(&testRootCmd{})
	args := []string{"--verbose", "add", "myitem"}
	node, remaining, err := resolveCommand(app.RootNode, args)
	if err != nil {
		t.Fatalf("resolveCommand failed: %v", err)
	}
	if node.Name != "add" {
		t.Errorf("got node %q, want %q", node.Name, "add")
	}
	if len(remaining) < 2 {
		t.Errorf("expected at least 2 remaining (flag+arg), got %v", remaining)
	}
}

func TestParseArgs_LongFlag(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"name": {
			Name:  "name",
			Field: reflect.ValueOf(""),
		},
	}
	parsed, pos, err := parseArgs([]string{"--name", "hello"}, flags)
	if err != nil {
		t.Fatalf("parseArgs failed: %v", err)
	}
	if parsed["name"] != "hello" {
		t.Errorf("got %q, want %q", parsed["name"], "hello")
	}
	if len(pos) != 0 {
		t.Errorf("expected no positional args, got %v", pos)
	}
}

func TestParseArgs_LongFlagWithEquals(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"name": {
			Name:  "name",
			Field: reflect.ValueOf(""),
		},
	}
	parsed, _, err := parseArgs([]string{"--name=hello"}, flags)
	if err != nil {
		t.Fatalf("parseArgs failed: %v", err)
	}
	if parsed["name"] != "hello" {
		t.Errorf("got %q, want %q", parsed["name"], "hello")
	}
}

func TestParseArgs_ShortFlag(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"verbose": {
			Name:  "verbose",
			Short: "v",
			Field: reflect.ValueOf(true),
		},
	}
	node := makeNode("root", "", &testSimpleCmd{})
	node.Flags = flags
	node.ShortFlags["v"] = "verbose"

	parsed, _, err := parseArgs([]string{"-v", "true"}, flags)
	if err != nil {
		t.Fatalf("parseArgs failed: %v", err)
	}
	if parsed["verbose"] != "true" {
		t.Errorf("got %q, want %q", parsed["verbose"], "true")
	}
}

func TestParseArgs_BoolFlag(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"verbose": {
			Name:  "verbose",
			Field: reflect.ValueOf(true),
		},
	}
	parsed, _, err := parseArgs([]string{"--verbose"}, flags)
	if err != nil {
		t.Fatalf("parseArgs failed: %v", err)
	}
	if parsed["verbose"] != "true" {
		t.Errorf("got %q, want 'true' for bool flag", parsed["verbose"])
	}
}

func TestParseArgs_MissingValue(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"name": {
			Name:  "name",
			Field: reflect.ValueOf(""),
		},
	}
	_, _, err := parseArgs([]string{"--name"}, flags)
	if err == nil {
		t.Error("expected error for missing flag value")
	}
}

func TestParseArgs_PositionalArgs(t *testing.T)

{
	flags := map[string]*parser.FlagMetadata{
		"verbose": {
			Name:  "verbose",
			Field: reflect.ValueOf(true),
		},
	}
	parsed, pos, err := parseArgs([]string{"--verbose", "file1", "file2"}, flags)
	if err != nil {
		t.Fatalf("parseArgs failed: %v", err)
	}
	if parsed["verbose"] != "true" {
		t.Errorf("expected verbose=true, got %v", parsed["verbose"])
	}
	if len(pos) != 2 || pos[0] != "file1" || pos[1] != "file2" {
		t.Errorf("expected [file1 file2], got %v", pos)
	}
}

func TestBindArgs_Required(t *testing.T)

{
	var val string
	node := parser.NewCommandNode("add", "", reflect.ValueOf(&struct {
		Item string
	}{}))
	node.Args = append(node.Args, &parser.ArgMetadata{
		Description: "item",
		Required:    true,
		Field:       reflect.ValueOf(&val).Elem(),
	})

	if err := bindArgs(node, []string{"myitem"}); err != nil {
		t.Fatalf("bindArgs failed: %v", err)
	}
	if val != "myitem" {
		t.Errorf("got %q, want %q", val, "myitem")
	}
}

func TestBindArgs_MissingRequired(t *testing.T)

{
	var val string
	node := parser.NewCommandNode("add", "", reflect.ValueOf(&struct {
		Item string
	}{}))
	node.Args = append(node.Args, &parser.ArgMetadata{
		Description: "item",
		Required:    true,
		Field:       reflect.ValueOf(&val).Elem(),
	})

	if err := bindArgs(node, []string{}); err == nil {
		t.Error("expected error for missing required arg")
	}
}

func TestBindArgs_GreedySlice(t *testing.T)

{
	var val []string
	node := parser.NewCommandNode("add", "", reflect.ValueOf(&struct {
		Items []string
	}{}))
	sliceField := reflect.ValueOf(&val).Elem()
	node.Args = append(node.Args, &parser.ArgMetadata{
		Description: "files",
		Required:    true,
		IsGreedy:    true,
		Field:       sliceField,
	})

	if err := bindArgs(node, []string{"a", "b", "c"}); err != nil {
		t.Fatalf("bindArgs failed: %v", err)
	}
	if len(val) != 3 || val[0] != "a" || val[1] != "b" || val[2] != "c" {
		t.Errorf("got %v, want [a b c]", val)
	}
}

func TestBindArgs_MultiplePositional(t *testing.T)

{
	type args struct {
		From string
		To   string
	}
	a := args{}
	node := parser.NewCommandNode("copy", "", reflect.ValueOf(&a))
	node.Args = append(node.Args,
		&parser.ArgMetadata{Description: "from", Required: true, Field: reflect.ValueOf(&a.From).Elem()},
		&parser.ArgMetadata{Description: "to", Required: true, Field: reflect.ValueOf(&a.To).Elem()},
	)

	if err := bindArgs(node, []string{"src", "dst"}); err != nil {
		t.Fatalf("bindArgs failed: %v", err)
	}
	if a.From != "src" || a.To != "dst" {
		t.Errorf("got %+v, want {From:src To:dst}", a)
	}
}

func TestGetPathToNode(t *testing.T)

{
	app, _ := New(&testRootCmd{})
	addNode := app.RootNode.Children["add"]
	if addNode == nil {
		t.Fatal("expected add child node")
	}
	path := getPathToNode(app.RootNode, addNode)
	if len(path) != 2 {
		t.Fatalf("expected path length 2, got %d", len(path))
	}
	if path[0] != app.RootNode {
		t.Error("path[0] should be root")
	}
	if path[1] != addNode {
		t.Error("path[1] should be add")
	}
}

func TestInjectDependencies(t *testing.T)

{
	type cmdWithBase struct {
		Base
	}
	v := &cmdWithBase{}
	ctx := context.Background()
	node := parser.NewCommandNode("test", "", reflect.ValueOf(v))
	injectDependencies(node, ctx, nil)
	if v.Ctx == nil {
		t.Error("expected non-nil Ctx after injectDependencies")
	}
}

func TestInjectDependencies_NoBase(t *testing.T)

{
	type cmdWithoutBase struct {
		Name string
	}
	v := &cmdWithoutBase{Name: "test"}
	ctx := context.Background()
	node := parser.NewCommandNode("test", "", reflect.ValueOf(v))
	originalName := v.Name
	injectDependencies(node, ctx, nil)
	if v.Name != originalName {
		t.Errorf("Name should not change: got %q, want %q", v.Name, originalName)
	}
}

func TestRun_LifecycleOrder(t *testing.T)

{
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	cmd := &lifecycleCmd{}
	os.Args = []string{"app", "sub"}
	if err := Run(cmd); err != nil {
		t.Fatalf("Run failed: %v", err)
	}
	if !cmd.BeforeRan {
		t.Error("expected root Before to be called")
	}
	if !cmd.Sub.BeforeRan {
		t.Error("expected sub Before to be called")
	}
	if !cmd.Sub.Ran {
		t.Error("expected sub Run to be called")
	}
	if !cmd.Sub.AfterRan {
		t.Error("expected sub After to be called")
	}
	if !cmd.AfterRan {
		t.Error("expected root After to be called")
	}
}

func TestRun_RootLifecycle(t *testing.T)

{
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	cmd := &rootWithBeforeAndAfter{}
	os.Args = []string{"app"}
	if err := Run(cmd); err != nil {
		t.Fatalf("Run failed: %v", err)
	}
	if !cmd.BeforeCalled {
		t.Error("expected Before to be called")
	}
	if !cmd.RunCalled {
		t.Error("expected Run to be called")
	}
	if !cmd.AfterCalled {
		t.Error("expected After to be called")
	}
}

func TestNew_WithOptions(t *testing.T)

{
	app, err := New(&testRootCmd{},
		WithVersion("1.0.0"),
		WithPanicRecovery(),
	)
	if err != nil {
		t.Fatalf("New with options failed: %v", err)
	}
	if app.version != "1.0.0" {
		t.Errorf("got version %q, want %q", app.version, "1.0.0")
	}
	if !app.panicRecovery {
		t.Error("expected panicRecovery to be true")
	}
}

func TestNew_WithContainer(t *testing.T)

{
	builder := di.NewBuilder()
	container, err := builder.Build()
	if err != nil {
		t.Fatalf("Build failed: %v", err)
	}
	app, err := New(&testRootCmd{}, WithContainer(container))
	if err != nil {
		t.Fatalf("New with container failed: %v", err)
	}
	if app.Container == nil {
		t.Error("expected non-nil Container")
	}
}

func TestRun_WithValidation(t *testing.T)

{
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	v := validation.New()
	os.Args = []string{"app", "--email", "not-an-email"}
	err := Run(&validationCmd{}, WithValidator(v))
	if err == nil {
		t.Error("expected validation error")
	}
}

func TestRun_WithValidationPass(t *testing.T)

{
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	v := validation.New()
	os.Args = []string{"app", "--email", "[email protected]"}
	err := Run(&validationCmd{}, WithValidator(v))
	if err != nil {
		t.Errorf("expected no validation error, got: %v", err)
	}
}

func TestRun_WithoutPanicRecovery(t *testing.T)

{
	defer func() {
		if r := recover(); r == nil {
			t.Error("expected panic to propagate without recovery")
		}
	}()
	oldArgs := os.Args
	defer func() { os.Args = oldArgs }()

	os.Args = []string{"app"}
	Run(&panicCmd{})
}

func TestResolveCommand_PositionalAllowed(t *testing.T)

{
	root := parser.NewCommandNode("app", "", reflect.ValueOf(struct{}{}))
	leaf := parser.NewCommandNode("greet", "", reflect.ValueOf(struct{}{}))
	leaf.Args = []*parser.ArgMetadata{{Description: "name"}}
	root.Children["greet"] = leaf

	n, rem, err := resolveCommand(root, []string{"greet", "alice"})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if n.Name != "greet" {
		t.Fatalf("expected greet node, got %q", n.Name)
	}
	if len(rem) != 1 || rem[0] != "alice" {
		t.Fatalf("expected positional [alice], got %v", rem)
	}
}