// reorderArgs returns a copy of a slice of command-line
// arguments, rearranged so that flags appear before non-
// flag arguments (as required by Go's flag parsing code).
// The provided flagset should contain all valid flags.
func reorderArgs(args []string, fs *flag.FlagSet) []string {

	nArgs := len(args)

	if nArgs < 2 {
		return args
	}

	// Define slices to hold flag and non-flag
	// arguments.
	flags := make([]string, 0, nArgs)
	nonFlags := make([]string, 0, nArgs)

	// Loop over the arguments adding each one to
	// the relevant slice.
	for i := 0; i < nArgs; i++ {

		arg := args[i]

		// A double dash signifies the end of the flag
		// arguments. This and all remaining arguments
		// are non-flags.
		if arg == "--" {
			nonFlags = append(nonFlags, args[i:]...)
			break
		}

		// Arguments with fewer than two characters or
		// a non-dash first letter are non-flags.
		if len(arg) < 2 || arg[0] != '-' {
			nonFlags = append(nonFlags, arg)
			continue
		}

		// We have what looks like a flag. Get its name,
		// remembering to handle single and double dashes.
		name := arg[1:]
		if name[0] == '-' {
			name = name[1:]
		}

		// Go supports 3 flag styles:
		//   -name=value
		//   -name value (non-boolean only)
		//   -name		 (boolean only)
		//
		// If the name contains an equals sign, assume
		// a -name=value style flag.
		hasValue := false
		for j, n := 0, len(name); j < n; j++ {
			if name[j] == '=' {
				hasValue = true
				break
			}
		}

		// Handle -name=value style flags.
		if hasValue {
			flags = append(flags, arg)
			continue
		}

		// Handle -name style (i.e. boolean) flags.
		if isBoolFlag(name, fs) {
			flags = append(flags, arg)
			continue
		}

		// Assume anything else is a -name value style
		// flag.
		flags = append(flags, arg)
		if i < nArgs-1 {
			i++
			flags = append(flags, args[i])
		}
	}

	return append(flags, nonFlags...)
}

type boolFlag interface {
	IsBoolFlag() bool
}

func isBoolFlag(name string, fs *flag.FlagSet) bool {

	f := fs.Lookup(name)
	if f == nil {
		return false
	}

	b, ok := f.Value.(boolFlag)
	if !ok {
		return false
	}

	return b.IsBoolFlag()
}