// Package lintcmd implements the frontend of an analysis runner.
// It serves as the entry-point for the staticcheck command, and can also be used to implement custom linters that behave like staticcheck.
package lintcmd

import (
	"bufio"
	"encoding/gob"
	"flag"
	"fmt"
	"go/token"
	stdversion "go/version"
	"io"
	"log"
	"maps"
	"os"
	"path/filepath"
	"reflect"
	"runtime"
	"runtime/pprof"
	"runtime/trace"
	"slices"
	"sort"
	"strings"
	"sync"
	"time"

	"honnef.co/go/tools/analysis/lint"
	"honnef.co/go/tools/config"
	"honnef.co/go/tools/go/loader"
	"honnef.co/go/tools/lintcmd/version"

	"golang.org/x/tools/go/analysis"
	"golang.org/x/tools/go/buildutil"
)

type buildConfig struct {
	Name  string
	Envs  []string
	Flags []string
}

type caseFoldedString struct {
	s string
}

func makeCaseFoldedString(s string) caseFoldedString {
	return caseFoldedString{strings.ToLower(s)}
}

func makeCaseFoldedStrings(ss []string) []caseFoldedString {
	out := make([]caseFoldedString, len(ss))
	for i, s := range ss {
		out[i] = makeCaseFoldedString(s)
	}
	return out
}

func (cs caseFoldedString) String() string {
	return cs.s
}

func (cs caseFoldedString) Index(idx int) byte {
	return cs.s[idx]
}

func (cs caseFoldedString) Slice(start, end int) caseFoldedString {
	if end == -1 {
		end = len(cs.s)
	}
	return caseFoldedString{cs.s[start:end]}
}

func (cs caseFoldedString) Length() int {
	return len(cs.s)
}

// Command represents a linter command line tool.
type Command struct {
	name           string
	analyzers      map[caseFoldedString]*lint.Analyzer
	version        string
	machineVersion string

	flags struct {
		fs *flag.FlagSet

		tags        string
		tests       bool
		showIgnored bool
		formatter   string

		// mutually exclusive mode flags
		explain      string
		printVersion bool
		listChecks   bool
		merge        bool

		matrix bool

		debugCpuprofile       string
		debugMemprofile       string
		debugVersion          bool
		debugNoCompileErrors  bool
		debugMeasureAnalyzers string
		debugTrace            string

		checks    list
		fail      list
		goVersion versionFlag
	}
}

// NewCommand returns a new Command.
func NewCommand(name string) *Command {
	cmd := &Command{
		name:           name,
		analyzers:      map[caseFoldedString]*lint.Analyzer{},
		version:        "devel",
		machineVersion: "devel",
	}
	cmd.initFlagSet(name)
	return cmd
}

// SetVersion sets the command's version.
// It is divided into a human part and a machine part.
// For example, Staticcheck 2020.2.1 had the human version "2020.2.1" and the machine version "v0.1.1".
// If you only use Semver, you can set both parts to the same value.
//
// Calling this method is optional. Both versions default to "devel", and we'll attempt to deduce more version information from the Go module.
func (cmd *Command) SetVersion(human, machine string) {
	cmd.version = human
	cmd.machineVersion = machine
}

// FlagSet returns the command's flag set.
// This can be used to add additional command line arguments.
func (cmd *Command) FlagSet() *flag.FlagSet {
	return cmd.flags.fs
}

// AddAnalyzers adds analyzers to the command.
// These are lint.Analyzer analyzers, which wrap analysis.Analyzer analyzers, bundling them with structured documentation.
//
// To add analysis.Analyzer analyzers without providing structured documentation, use AddBareAnalyzers.
func (cmd *Command) AddAnalyzers(as ...*lint.Analyzer) {
	for _, a := range as {
		cmd.analyzers[makeCaseFoldedString(a.Analyzer.Name)] = a
	}
}

// AddBareAnalyzers adds bare analyzers to the command.
func (cmd *Command) AddBareAnalyzers(as ...*analysis.Analyzer) {
	for _, a := range as {
		var title, text string
		if idx := strings.Index(a.Doc, "\n\n"); idx > -1 {
			title = a.Doc[:idx]
			text = a.Doc[idx+2:]
		}

		doc := &lint.RawDocumentation{
			Title:    title,
			Text:     text,
			Severity: lint.SeverityWarning,
		}

		cmd.analyzers[makeCaseFoldedString(a.Name)] = &lint.Analyzer{
			Doc:      doc,
			Analyzer: a,
		}
	}
}

func (cmd *Command) initFlagSet(name string) {
	flags := flag.NewFlagSet("", flag.ExitOnError)
	cmd.flags.fs = flags
	flags.Usage = usage(name, flags)

	flags.StringVar(&cmd.flags.tags, "tags", "", "List of `build tags`")
	flags.BoolVar(&cmd.flags.tests, "tests", true, "Include tests")
	flags.BoolVar(&cmd.flags.printVersion, "version", false, "Print version and exit")
	flags.BoolVar(&cmd.flags.showIgnored, "show-ignored", false, "Don't filter ignored diagnostics")
	flags.StringVar(&cmd.flags.formatter, "f", "text", "Output `format` (valid choices are 'stylish', 'text' and 'json')")
	flags.StringVar(&cmd.flags.explain, "explain", "", "Print description of `check`")
	flags.BoolVar(&cmd.flags.listChecks, "list-checks", false, "List all available checks")
	flags.BoolVar(&cmd.flags.merge, "merge", false, "Merge results of multiple Staticcheck runs")
	flags.BoolVar(&cmd.flags.matrix, "matrix", false, "Read a build config matrix from stdin")

	flags.StringVar(&cmd.flags.debugCpuprofile, "debug.cpuprofile", "", "Write CPU profile to `file`")
	flags.StringVar(&cmd.flags.debugMemprofile, "debug.memprofile", "", "Write memory profile to `file`")
	flags.BoolVar(&cmd.flags.debugVersion, "debug.version", false, "Print detailed version information about this program")
	flags.BoolVar(&cmd.flags.debugNoCompileErrors, "debug.no-compile-errors", false, "Don't print compile errors")
	flags.StringVar(&cmd.flags.debugMeasureAnalyzers, "debug.measure-analyzers", "", "Write analysis measurements to `file`. `file` will be opened for appending if it already exists.")
	flags.StringVar(&cmd.flags.debugTrace, "debug.trace", "", "Write trace to `file`")

	cmd.flags.checks = list{"inherit"}
	cmd.flags.fail = list{"all"}
	cmd.flags.goVersion = versionFlag("module")
	flags.Var(&cmd.flags.checks, "checks", "Comma-separated list of `checks` to enable.")
	flags.Var(&cmd.flags.fail, "fail", "Comma-separated list of `checks` that can cause a non-zero exit status.")
	flags.Var(&cmd.flags.goVersion, "go", "Target Go `version` in the format '1.x', or the literal 'module' to use the module's Go version")
}

type list []string

func (list *list) String() string {
	return `"` + strings.Join(*list, ",") + `"`
}

func (list *list) Set(s string) error {
	if s == "" {
		*list = nil
		return nil
	}

	elems := strings.Split(s, ",")
	for i, elem := range elems {
		elems[i] = strings.TrimSpace(elem)
	}
	*list = elems
	return nil
}

type versionFlag string

func (v *versionFlag) String() string {
	return fmt.Sprintf("%q", string(*v))
}

func (v *versionFlag) Set(s string) error {
	if s == "module" {
		*v = "module"
	} else {
		orig := s
		if !strings.HasPrefix(s, "go") {
			s = "go" + s
		}
		if stdversion.IsValid(s) {
			*v = versionFlag(s)
		} else {
			return fmt.Errorf("%q is not a valid Go version", orig)
		}
	}
	return nil
}

// ParseFlags parses command line flags.
// It must be called before calling Run.
// After calling ParseFlags, the values of flags can be accessed.
//
// Example:
//
//	cmd.ParseFlags(os.Args[1:])
func (cmd *Command) ParseFlags(args []string) {
	cmd.flags.fs.Parse(args)
}

// diagnosticDescriptor represents the uniquely identifying information of diagnostics.
type diagnosticDescriptor struct {
	Position token.Position
	End      token.Position
	Category string
	Message  string
}

func (diag diagnostic) descriptor() diagnosticDescriptor {
	return diagnosticDescriptor{
		Position: diag.Position,
		End:      diag.End,
		Category: diag.Category,
		Message:  diag.Message,
	}
}

type run struct {
	checkedFiles map[string]struct{}
	diagnostics  map[diagnosticDescriptor]diagnostic
}

func runFromLintResult(res lintResult) run {
	out := run{
		checkedFiles: map[string]struct{}{},
		diagnostics:  map[diagnosticDescriptor]diagnostic{},
	}

	for _, cf := range res.CheckedFiles {
		out.checkedFiles[cf] = struct{}{}
	}
	for _, diag := range res.Diagnostics {
		out.diagnostics[diag.descriptor()] = diag
	}
	return out
}

func decodeGob(br io.ByteReader) ([]run, error) {
	var runs []run
	for {
		var res lintResult
		if err := gob.NewDecoder(br.(io.Reader)).Decode(&res); err != nil {
			if err == io.EOF {
				break
			} else {
				return nil, err
			}
		}
		runs = append(runs, runFromLintResult(res))
	}
	return runs, nil
}

// Execute runs all registered analyzers and reports their findings.
// The status code returned can be used for os.Exit(cmd.Execute()).
func (cmd *Command) Execute() int {
	// Set up profiling and tracing
	if path := cmd.flags.debugCpuprofile; path != "" {
		f, err := os.Create(path)
		if err != nil {
			log.Fatal(err)
		}
		pprof.StartCPUProfile(f)
	}
	if path := cmd.flags.debugTrace; path != "" {
		f, err := os.Create(path)
		if err != nil {
			log.Fatal(err)
		}
		trace.Start(f)
	}

	// Update the default config's list of enabled checks
	defaultChecks := []string{"all"}
	for _, a := range cmd.analyzers {
		if a.Doc.NonDefault {
			defaultChecks = append(defaultChecks, "-"+a.Analyzer.Name)
		}
	}
	config.DefaultConfig.Checks = defaultChecks

	// Run the appropriate mode
	var exit int
	switch {
	case cmd.flags.debugVersion:
		exit = cmd.printDebugVersion()
	case cmd.flags.listChecks:
		exit = cmd.listChecks()
	case cmd.flags.printVersion:
		exit = cmd.printVersion()
	case cmd.flags.explain != "":
		exit = cmd.explain()
	case cmd.flags.merge:
		exit = cmd.merge()
	default:
		exit = cmd.lint()
	}

	// Stop profiling
	if cmd.flags.debugCpuprofile != "" {
		pprof.StopCPUProfile()
	}
	if path := cmd.flags.debugMemprofile; path != "" {
		f, err := os.Create(path)
		if err != nil {
			panic(err)
		}
		runtime.GC()
		pprof.WriteHeapProfile(f)
	}
	if cmd.flags.debugTrace != "" {
		trace.Stop()
	}

	return exit
}

// Run runs all registered analyzers and reports their findings.
// It always calls os.Exit and does not return.
func (cmd *Command) Run() {
	os.Exit(cmd.Execute())
}

func (cmd *Command) printDebugVersion() int {
	version.Verbose(cmd.version, cmd.machineVersion)
	return 0
}

func (cmd *Command) listChecks() int {
	cs := slices.Collect(maps.Values(cmd.analyzers))
	sort.Slice(cs, func(i, j int) bool {
		return cs[i].Analyzer.Name < cs[j].Analyzer.Name
	})
	for _, c := range cs {
		var title string
		if c.Doc != nil {
			title = c.Doc.Compile().Title
		}
		fmt.Printf("%s %s\n", c.Analyzer.Name, title)
	}
	return 0
}

func (cmd *Command) printVersion() int {
	version.Print(cmd.version, cmd.machineVersion)
	return 0
}

func (cmd *Command) explain() int {
	explain := cmd.flags.explain
	check, ok := cmd.analyzers[makeCaseFoldedString(explain)]
	if !ok {
		fmt.Fprintln(os.Stderr, "Couldn't find check", explain)
		return 1
	}
	if check.Analyzer.Doc == "" {
		fmt.Fprintln(os.Stderr, check.Analyzer.Name, "has no documentation")
		return 1
	}
	fmt.Println(check.Doc.Compile())
	fmt.Println("Online documentation\n    https://staticcheck.dev/docs/checks#" + check.Analyzer.Name)
	return 0
}

func (cmd *Command) merge() int {
	var runs []run
	if len(cmd.flags.fs.Args()) == 0 {
		var err error
		runs, err = decodeGob(bufio.NewReader(os.Stdin))
		if err != nil {
			fmt.Fprintln(os.Stderr, fmt.Errorf("couldn't parse stdin: %s", err))
			return 1
		}
	} else {
		for _, path := range cmd.flags.fs.Args() {
			someRuns, err := func(path string) ([]run, error) {
				f, err := os.Open(path)
				if err != nil {
					return nil, err
				}
				defer f.Close()
				br := bufio.NewReader(f)
				return decodeGob(br)
			}(path)
			if err != nil {
				fmt.Fprintln(os.Stderr, fmt.Errorf("couldn't parse file %s: %s", path, err))
				return 1
			}
			runs = append(runs, someRuns...)
		}
	}

	relevantDiagnostics := mergeRuns(runs)
	cs := slices.Collect(maps.Values(cmd.analyzers))
	return cmd.printDiagnostics(cs, relevantDiagnostics)
}

func (cmd *Command) lint() int {
	switch cmd.flags.formatter {
	case "text", "stylish", "json", "sarif", "binary", "null":
	default:
		fmt.Fprintf(os.Stderr, "unsupported output format %q\n", cmd.flags.formatter)
		return 2
	}

	var bconfs []buildConfig
	if cmd.flags.matrix {
		if cmd.flags.tags != "" {
			fmt.Fprintln(os.Stderr, "cannot use -matrix and -tags together")
			return 2
		}

		var err error
		bconfs, err = parseBuildConfigs(os.Stdin)
		if err != nil {
			if perr, ok := err.(parseBuildConfigError); ok {
				fmt.Fprintf(os.Stderr, "<stdin>:%d couldn't parse build matrix: %s\n", perr.line, perr.err)
			} else {
				fmt.Fprintln(os.Stderr, err)
			}
			return 2
		}
	} else {
		bc := buildConfig{}
		if cmd.flags.tags != "" {
			// Validate that the tags argument is well-formed. go/packages
			// doesn't detect malformed build flags and returns unhelpful
			// errors.
			tf := buildutil.TagsFlag{}
			if err := tf.Set(cmd.flags.tags); err != nil {
				fmt.Fprintln(os.Stderr, fmt.Errorf("invalid value %q for flag -tags: %s", cmd.flags.tags, err))
				return 1
			}

			bc.Flags = []string{"-tags", cmd.flags.tags}
		}
		bconfs = append(bconfs, bc)
	}

	var measureAnalyzers func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration)
	if path := cmd.flags.debugMeasureAnalyzers; path != "" {
		f, err := os.OpenFile(path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0600)
		if err != nil {
			log.Fatal(err)
		}

		mu := &sync.Mutex{}
		measureAnalyzers = func(analysis *analysis.Analyzer, pkg *loader.PackageSpec, d time.Duration) {
			mu.Lock()
			defer mu.Unlock()
			// FIXME(dh): print pkg.ID
			if _, err := fmt.Fprintf(f, "%s\t%s\t%d\n", analysis.Name, pkg, d.Nanoseconds()); err != nil {
				log.Println("error writing analysis measurements:", err)
			}
		}
	}

	var runs []run
	cs := slices.Collect(maps.Values(cmd.analyzers))
	opts := options{
		analyzers: cs,
		patterns:  cmd.flags.fs.Args(),
		lintTests: cmd.flags.tests,
		goVersion: string(cmd.flags.goVersion),
		config: config.Config{
			Checks: cmd.flags.checks,
		},
		printAnalyzerMeasurement: measureAnalyzers,
	}
	l, err := newLinter(opts)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		return 1
	}
	for _, bconf := range bconfs {
		res, err := l.run(bconf)
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			return 1
		}

		for _, w := range res.Warnings {
			fmt.Fprintln(os.Stderr, "warning:", w)
		}

		cwd, err := os.Getwd()
		if err != nil {
			cwd = ""
		}
		relPath := func(s string) string {
			if cwd == "" {
				return filepath.ToSlash(s)
			}
			out, err := filepath.Rel(cwd, s)
			if err != nil {
				return filepath.ToSlash(s)
			}
			return filepath.ToSlash(out)
		}

		if cmd.flags.formatter == "binary" {
			for i, s := range res.CheckedFiles {
				res.CheckedFiles[i] = relPath(s)
			}
			for i := range res.Diagnostics {
				// We turn all paths into relative, /-separated paths. This is to make -merge work correctly when
				// merging runs from different OSs, with different absolute paths.
				//
				// We zero out Offset, because checkouts of code on different OSs may have different kinds of
				// newlines and thus different offsets. We don't ever make use of the Offset, anyway. Line and
				// column numbers are precomputed.

				d := &res.Diagnostics[i]
				d.Position.Filename = relPath(d.Position.Filename)
				d.Position.Offset = 0
				d.End.Filename = relPath(d.End.Filename)
				d.End.Offset = 0
				for j := range d.Related {
					r := &d.Related[j]
					r.Position.Filename = relPath(r.Position.Filename)
					r.Position.Offset = 0
					r.End.Filename = relPath(r.End.Filename)
					r.End.Offset = 0
				}
			}
			err := gob.NewEncoder(os.Stdout).Encode(res)
			if err != nil {
				fmt.Fprintf(os.Stderr, "failed writing output: %s\n", err)
				return 2
			}
		} else {
			runs = append(runs, runFromLintResult(res))
		}
	}

	l.cache.Close()

	if cmd.flags.formatter != "binary" {
		diags := mergeRuns(runs)
		return cmd.printDiagnostics(cs, diags)
	}
	return 0
}

func mergeRuns(runs []run) []diagnostic {
	var relevantDiagnostics []diagnostic
	for _, r := range runs {
		for _, diag := range r.diagnostics {
			switch diag.MergeIf {
			case lint.MergeIfAny:
				relevantDiagnostics = append(relevantDiagnostics, diag)
			case lint.MergeIfAll:
				doPrint := true
				for _, r := range runs {
					if _, ok := r.checkedFiles[diag.Position.Filename]; ok {
						if _, ok := r.diagnostics[diag.descriptor()]; !ok {
							doPrint = false
						}
					}
				}
				if doPrint {
					relevantDiagnostics = append(relevantDiagnostics, diag)
				}
			}
		}
	}
	return relevantDiagnostics
}

// printDiagnostics prints the diagnostics and exits the process.
func (cmd *Command) printDiagnostics(cs []*lint.Analyzer, diagnostics []diagnostic) int {
	if len(diagnostics) > 1 {
		sort.Slice(diagnostics, func(i, j int) bool {
			di := diagnostics[i]
			dj := diagnostics[j]
			pi := di.Position
			pj := dj.Position

			if pi.Filename != pj.Filename {
				return pi.Filename < pj.Filename
			}
			if pi.Line != pj.Line {
				return pi.Line < pj.Line
			}
			if pi.Column != pj.Column {
				return pi.Column < pj.Column
			}
			if di.Message != dj.Message {
				return di.Message < dj.Message
			}
			if di.BuildName != dj.BuildName {
				return di.BuildName < dj.BuildName
			}
			return di.Category < dj.Category
		})

		filtered := []diagnostic{
			diagnostics[0],
		}
		builds := []map[string]struct{}{
			{diagnostics[0].BuildName: {}},
		}
		for _, diag := range diagnostics[1:] {
			// We may encounter duplicate diagnostics because one file
			// can be part of many packages, and because multiple
			// build configurations may check the same files.
			if !filtered[len(filtered)-1].equal(diag) {
				if filtered[len(filtered)-1].descriptor() == diag.descriptor() {
					// Diagnostics only differ in build name, track new name
					builds[len(filtered)-1][diag.BuildName] = struct{}{}
				} else {
					filtered = append(filtered, diag)
					builds = append(builds, map[string]struct{}{})
					builds[len(filtered)-1][diag.BuildName] = struct{}{}
				}
			}
		}

		var names []string
		for i := range filtered {
			names = names[:0]
			for k := range builds[i] {
				names = append(names, k)
			}
			sort.Strings(names)
			filtered[i].BuildName = strings.Join(names, ",")
		}
		diagnostics = filtered
	}

	var f formatter
	switch cmd.flags.formatter {
	case "text":
		f = textFormatter{W: os.Stdout}
	case "stylish":
		f = &stylishFormatter{W: os.Stdout}
	case "json":
		f = jsonFormatter{W: os.Stdout}
	case "sarif":
		f = &sarifFormatter{
			driverName:    cmd.name,
			driverVersion: cmd.version,
		}
		if cmd.name == "staticcheck" {
			f.(*sarifFormatter).driverName = "Staticcheck"
			f.(*sarifFormatter).driverWebsite = "https://staticcheck.dev"
		}
	case "binary":
		fmt.Fprintln(os.Stderr, "'-f binary' not supported in this context")
		return 2
	case "null":
		f = nullFormatter{}
	default:
		fmt.Fprintf(os.Stderr, "unsupported output format %q\n", cmd.flags.formatter)
		return 2
	}

	fail := makeCaseFoldedStrings(cmd.flags.fail)
	analyzerNames := make([]caseFoldedString, len(cs))
	for i, a := range cs {
		analyzerNames[i] = makeCaseFoldedString(a.Analyzer.Name)
	}
	shouldExit := filterAnalyzerNames(analyzerNames, fail)
	shouldExit[makeCaseFoldedString("staticcheck")] = true
	shouldExit[makeCaseFoldedString("compile")] = true
	shouldExit[makeCaseFoldedString("config")] = true

	var (
		numErrors   int
		numWarnings int
		numIgnored  int
	)
	notIgnored := make([]diagnostic, 0, len(diagnostics))
	for _, diag := range diagnostics {
		if diag.Category == "compile" && cmd.flags.debugNoCompileErrors {
			continue
		}
		if diag.Severity == severityIgnored && !cmd.flags.showIgnored {
			numIgnored++
			continue
		}
		if shouldExit[makeCaseFoldedString(diag.Category)] {
			numErrors++
		} else {
			diag.Severity = severityWarning
			numWarnings++
		}
		notIgnored = append(notIgnored, diag)
	}

	f.Format(cs, notIgnored)
	if f, ok := f.(statter); ok {
		f.Stats(len(diagnostics), numErrors, numWarnings, numIgnored)
	}

	if numErrors > 0 {
		if _, ok := f.(*sarifFormatter); ok {
			// When emitting SARIF, finding errors is considered success.
			return 0
		} else {
			return 1
		}
	}
	return 0
}

func usage(name string, fs *flag.FlagSet) func() {
	return func() {
		fmt.Fprintf(os.Stderr, "Usage: %s [flags] [packages]\n", name)

		fmt.Fprintln(os.Stderr)
		fmt.Fprintln(os.Stderr, "Flags:")
		printDefaults(fs)

		fmt.Fprintln(os.Stderr)
		fmt.Fprintln(os.Stderr, "For help about specifying packages, see 'go help packages'")
	}
}

// isZeroValue determines whether the string represents the zero
// value for a flag.
//
// this function has been copied from the Go standard library's 'flag' package.
func isZeroValue(f *flag.Flag, value string) bool {
	// Build a zero value of the flag's Value type, and see if the
	// result of calling its String method equals the value passed in.
	// This works unless the Value type is itself an interface type.
	typ := reflect.TypeOf(f.Value)
	var z reflect.Value
	if typ.Kind() == reflect.Pointer {
		z = reflect.New(typ.Elem())
	} else {
		z = reflect.Zero(typ)
	}
	return value == z.Interface().(flag.Value).String()
}

// this function has been copied from the Go standard library's 'flag' package and modified to skip debug flags.
func printDefaults(fs *flag.FlagSet) {
	fs.VisitAll(func(f *flag.Flag) {
		// Don't print debug flags
		if strings.HasPrefix(f.Name, "debug.") {
			return
		}

		var b strings.Builder
		fmt.Fprintf(&b, "  -%s", f.Name) // Two spaces before -; see next two comments.
		name, usage := flag.UnquoteUsage(f)
		if len(name) > 0 {
			b.WriteString(" ")
			b.WriteString(name)
		}
		// Boolean flags of one ASCII letter are so common we
		// treat them specially, putting their usage on the same line.
		if b.Len() <= 4 { // space, space, '-', 'x'.
			b.WriteString("\t")
		} else {
			// Four spaces before the tab triggers good alignment
			// for both 4- and 8-space tab stops.
			b.WriteString("\n    \t")
		}
		b.WriteString(strings.ReplaceAll(usage, "\n", "\n    \t"))

		if !isZeroValue(f, f.DefValue) {
			if T := reflect.TypeOf(f.Value); T.Name() == "*stringValue" && T.PkgPath() == "flag" {
				// put quotes on the value
				fmt.Fprintf(&b, " (default %q)", f.DefValue)
			} else {
				fmt.Fprintf(&b, " (default %v)", f.DefValue)
			}
		}
		fmt.Fprint(fs.Output(), b.String(), "\n")
	})
}
