binder

func (*Binder) AddBool(key string, fn func(bool) error)
{
	b.handlers[key] = func(args []string) error {
		var val bool
		if len(args) > 0 {
			fmt.Sscanf(args[0], "%t", &val)
		} else {
			val = true
		}
		return fn(val)
	}
}

func (*Binder) AddInt(key string, fn func(int64) error)
{
	b.handlers[key] = func(args []string) error {
		if len(args) == 0 {
			return fmt.Errorf("missing value for %s", key)
		}
		var val int64
		if _, err := fmt.Sscanf(args[0], "%d", &val); err != nil {
			return err
		}
		return fn(val)
	}
}

func (*Binder) Run(key string, args []string) error
{
	b.hooks.runBefore(key, args)

	h, ok := b.handlers[key]
	if !ok {
		return fmt.Errorf("no handler for key: %s", key)
	}

	if err := h(args); err != nil {
		return err
	}

	b.hooks.runAfter(key, args)
	return nil
}

func (*Binder) AutoDiscover() error
{
	v := reflect.ValueOf(b.dst)
	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
		return fmt.Errorf("binder: destination must be a pointer to a struct")
	}

	elem := v.Elem()
	typ := elem.Type()

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

		tag := fieldType.Tag.Get("flag")
		if tag == "" {
			continue
		}

		params := ParseTag(tag)
		long := params["long"]
		if long == "" {
			long = strings.ToLower(fieldType.Name)
		}

		// Register default handler if not already registered
		if _, ok := b.handlers[long]; !ok {
			b.RegisterDefaultHandler(field, long)
		}
	}

	return nil
}

func (*Binder) RegisterDefaultHandler(field reflect.Value, name string)
{
	switch field.Kind() {
	case reflect.Bool:
		b.handlers[name] = func(args []string) error {
			if len(args) > 0 {
				var val bool
				fmt.Sscanf(args[0], "%t", &val)
				field.SetBool(val)
			} else {
				field.SetBool(true)
			}
			return nil
		}
	case reflect.String:
		b.handlers[name] = func(args []string) error {
			if len(args) > 0 {
				field.SetString(args[0])
			}
			return nil
		}
	case reflect.Int, reflect.Int64:
		b.handlers[name] = func(args []string) error {
			if len(args) > 0 {
				var val int64
				fmt.Sscanf(args[0], "%d", &val)
				field.SetInt(val)
			}
			return nil
		}
	}
}

func (*Binder) AddDuration(key string, fn func(time.Duration) error)
{
	b.handlers[key] = func(args []string) error {
		if len(args) == 0 {
			return fmt.Errorf("missing value for %s", key)
		}
		val, err := time.ParseDuration(args[0])
		if err != nil {
			return err
		}
		return fn(val)
	}
}

func (*Binder) AddEnum(key string, choices []string, fn func(string) error)
{
	b.handlers[key] = func(args []string) error {
		if len(args) == 0 {
			return fmt.Errorf("missing value for %s", key)
		}
		val := args[0]
		found := slices.Contains(choices, val)
		if !found {
			return fmt.Errorf("invalid value %s for %s, allowed: %v", val, key, choices)
		}
		return fn(val)
	}
}