package pflagfork

import (
	
	
	

	
)

type FlagSet struct {
	*pflag.FlagSet
}

func ( FlagSet) () bool {
	if  := reflect.ValueOf(.FlagSet).Elem().FieldByName("interspersed"); .IsValid() {
		return .Bool()
	}
	return false
}

func ( FlagSet) () bool {
	if  := reflect.ValueOf(.FlagSet).MethodByName("IsPosix"); .IsValid() {
		if  := .Call([]reflect.Value{}); len() == 1 && [0].Kind() == reflect.Bool {
			return [0].Bool()
		}
	}
	return true
}

func ( FlagSet) ( string) bool {
	 := regexp.MustCompile("^-(?P<shorthand>[^-].*)")
	return .MatchString() && .IsPosix()
}

func ( FlagSet) ( *pflag.Flag) bool {
	if ,  := .Annotations["cobra_annotation_mutually_exclusive"];  {
		for ,  := range  {
			for ,  := range strings.Split(, " ") {
				if  := .Lookup();  != nil && .Changed {
					return true
				}
			}
		}
	}
	return false
}

func ( *FlagSet) ( func(*Flag)) {
	.FlagSet.VisitAll(func( *pflag.Flag) {
		(&Flag{Flag: , Args: []string{}})
	})

}

func ( FlagSet) ( string) ( *Flag) {
	 := .IsPosix()

	switch {
	case strings.HasPrefix(, "--"):
		return .lookupPosixLonghandArg()
	case :
		return .lookupPosixShorthandArg()
	case !:
		return .lookupNonPosixShorthandArg()
	}
	return
}

func ( FlagSet) ( string) *Flag {
	if  := .FlagSet.ShorthandLookup();  != nil {
		return &Flag{
			Flag: ,
			Args: []string{},
		}
	}
	return nil
}

func ( FlagSet) ( string) ( *Flag) {
	if !strings.HasPrefix(, "--") {
		return nil
	}

	.VisitAll(func( *Flag) { // TODO needs to be sorted to try longest matching first
		if  != nil || .Mode() != Default {
			return
		}

		 := strings.SplitAfterN(, string(.OptargDelimiter()), 2)
		if strings.TrimSuffix([0], string(.OptargDelimiter())) == "--"+.Name {
			 = 
			.Prefix = [0]
			if len() > 1 {
				.Args = [1:]
			}
		}
	})
	return
}

func ( FlagSet) ( string) *Flag {
	if !strings.HasPrefix(, "-") || !.IsPosix() || len() < 2 {
		return nil
	}

	for ,  := range [1:] {
		 += 1
		 := .ShorthandLookup(string())

		switch {
		case  == nil:
			return 
		case len() == +1:
			.Prefix = 
			return 
		case [+1] == byte(.OptargDelimiter()) && len() > +2:
			.Prefix = [:+2]
			.Args = []string{[+2:]}
			return 
		case [+1] == byte(.OptargDelimiter()):
			.Prefix = [:+2]
			.Args = []string{""}
			return 
		case !.IsOptarg() && len() > +1:
			.Prefix = [:+1]
			.Args = []string{[+1:]}
			return 
		}
	}
	return nil
}

func ( FlagSet) ( string) ( *Flag) { // TODO pretty much duplicates longhand lookup
	if !strings.HasPrefix(, "-") {
		return nil
	}

	.VisitAll(func( *Flag) { // TODO needs to be sorted to try longest matching first
		if  != nil {
			return
		}

		 := strings.SplitAfterN(, string(.OptargDelimiter()), 2)
		if strings.TrimSuffix([0], string(.OptargDelimiter())) == "-"+.Shorthand {
			 = 
			.Prefix = [0]
			if len() > 1 {
				.Args = [1:]
			}
		}
	})
	return
}