cmd := exec.Command("gocyclo", "-over", "18", ".")

	cmd := exec.Command("gocyclo", "-over", "15", ".")

	"flag"

	"strconv"
	"strings"

// clipArgParser holds state for parsing CLI arguments incrementally.
type clipArgParser struct {
	args []string
	i    int
}
// nextValue returns the next argument after the current flag, or exits with an error.
func (p *clipArgParser) nextValue(flag string) string {
	if p.i+1 >= len(p.args) {
		fmt.Fprintf(os.Stderr, "Error: %s requires a value\n", flag)
		os.Exit(1)
	}
	v := p.args[p.i+1]
	p.i += 2
	return v
}
// nextInt parses the next argument as an integer, or exits with an error.
func (p *clipArgParser) nextInt(flag string) int {
	s := p.nextValue(flag)
	v, err := strconv.Atoi(s)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error: %s must be an integer\n", flag)
		os.Exit(1)
	}
	return v
}

// nextUniqueValue returns the next argument after the flag, or exits if already set.
func (p *clipArgParser) nextUniqueValue(flag, current string) string {
	if current != "" {
		fmt.Fprintf(os.Stderr, "Error: %s can only be specified once\n", flag)
		os.Exit(1)
	}
	return p.nextValue(flag)
}

// parseClipArgs parses CLI arguments into clip flags

// parseClipArgs parses CLI arguments into clip flags using flag.FlagSet.

	f := clipFlags{certainty: -1}
	p := &clipArgParser{args: args}
	for p.i < len(args) {
		arg := args[p.i]
		switch arg {
		case "--file":
			f.file = p.nextValue(arg)
		case "--folder":
			f.folder = p.nextValue(arg)
		case "--output":
			f.output = p.nextValue(arg)
		case "--prefix":
			f.prefix = p.nextValue(arg)
		case "--filter":
			f.filter = p.nextUniqueValue(arg, f.filter)
		case "--species":
			f.species = p.nextUniqueValue(arg, f.species)
		case "--certainty":
			v := p.nextInt(arg)
			if v < 0 || v > 100 {
				fmt.Fprintf(os.Stderr, "Error: --certainty must be between 0 and 100\n")
				os.Exit(1)
			}
			f.certainty = v
		case "--size":
			f.size = p.nextInt(arg)
		case "--color":
			f.color = true
			p.i++
		case "--night":
			f.night = true
			p.i++
		case "--day":
			f.day = true
			p.i++
		case "--location":
			f.location = p.nextUniqueValue(arg, f.location)
		case "-h", "--help":
			printClipUsage()
			os.Exit(0)
		default:
			if strings.HasPrefix(arg, "--") {
				fmt.Fprintf(os.Stderr, "Error: unknown flag: %s\n\n", arg)
				printClipUsage()
				os.Exit(1)
			}
			p.i++
		}

	fs := flag.NewFlagSet("calls clip", flag.ExitOnError)
	file := fs.String("file", "", "Path to .data file (required if no --folder)")
	folder := fs.String("folder", "", "Path to folder containing .data files (required if no --file)")
	output := fs.String("output", "", "Output folder for generated clips (required)")
	prefix := fs.String("prefix", "", "Prefix for output filenames (required)")
	filter := fs.String("filter", "", "Filter by ML model name")
	species := fs.String("species", "", "Filter by species, optionally with calltype")
	certainty := fs.Int("certainty", -1, "Filter by certainty value (0-100)")
	size := fs.Int("size", 0, "Spectrogram image size in pixels (224-896)")
	color := fs.Bool("color", false, "Apply L4 colormap to spectrogram")
	night := fs.Bool("night", false, "Only clip recordings made during solar night")
	day := fs.Bool("day", false, "Only clip recordings made during solar day")
	location := fs.String("location", "", "GPS coordinates and optional timezone")
	fs.Usage = printClipUsage
	_ = fs.Parse(args)
	if *certainty < -1 || *certainty > 100 {
		fmt.Fprintf(os.Stderr, "Error: --certainty must be between 0 and 100\n")
		os.Exit(1)
	}
	return clipFlags{
		file:      *file,
		folder:    *folder,
		output:    *output,
		prefix:    *prefix,
		filter:    *filter,
		species:   *species,
		size:      *size,
		certainty: *certainty,
		color:     *color,
		night:     *night,
		day:       *day,
		location:  *location,

	return f