config.go

package indelligent

import "runtime"

// Format defines the output format.
type Format int

const (
	// FASTA is the default output format for CLI.
	FASTA Format = iota
	// CompactJSON produces single-line JSON.
	CompactJSON
	// PrettyJSON produces indented JSON.
	PrettyJSON
	// TSV produces tab-separated values.
	TSV
)

// Config keeps settings that affect analysis and output.
type Config struct {
	// Format sets the output format.
	Format Format

	// JobsNum sets the level of parallelism.
	JobsNum int

	// BatchSize sets the maximum number of sequences in a batch.
	BatchSize int

	// WithDetails includes full stats in output.
	WithDetails bool

	// WithNoOrder allows unordered output for maximum throughput.
	WithNoOrder bool

	// WithStream enables stream mode vs batch mode.
	WithStream bool

	// MaxShift is the max phase shift size in bp (default: 15).
	MaxShift int

	// ShiftPenalty is the shift change penalty (default: 2).
	ShiftPenalty int

	// FixShifts restricts analysis to specific shift magnitudes.
	FixShifts []int

	// AlignAlleles aligns reconstructed alleles with gap chars.
	AlignAlleles bool

	// FloatAlign controls floating indel alignment: "left" or "right".
	FloatAlign string

	// LongIndels displays alternative longer indel variants.
	LongIndels bool

	// Port starts web service on this port (0 = no web service).
	Port int

	// WithColor enables ANSI color highlighting of mismatches in CLI output.
	WithColor bool

	// IsTest uses "test_version" in output.
	IsTest bool

	// MaxBatchSequences limits how many sequences a single API batch
	// request may contain. 0 means no limit.
	MaxBatchSequences int

	// MaxSequenceLength limits the length of a single sequence accepted
	// via the API. 0 means no limit.
	MaxSequenceLength int

	// MaxSimLength caps the simulated fragment length. 0 means no limit.
	MaxSimLength int

	// RateLimit sets the per-IP request rate (req/s). 0 means no limit.
	RateLimit float64

	// BodyLimit sets the maximum request body size (e.g. "1M"). Empty
	// means no limit.
	BodyLimit string
}

// Option is a function that modifies Config settings.
type Option func(*Config)

// OptFormat sets the output format.
func OptFormat(f Format) Option {
	return func(cfg *Config) {
		cfg.Format = f
	}
}

// OptJobsNum sets the number of worker goroutines.
func OptJobsNum(i int) Option {
	return func(cfg *Config) {
		if i > 0 {
			cfg.JobsNum = i
		}
	}
}

// OptBatchSize sets the max sequences per batch.
func OptBatchSize(i int) Option {
	return func(cfg *Config) {
		if i > 0 {
			cfg.BatchSize = i
		}
	}
}

// OptWithDetails sets the WithDetails flag.
func OptWithDetails(b bool) Option {
	return func(cfg *Config) {
		cfg.WithDetails = b
	}
}

// OptWithNoOrder sets the WithNoOrder flag.
func OptWithNoOrder(b bool) Option {
	return func(cfg *Config) {
		cfg.WithNoOrder = b
	}
}

// OptWithStream sets the WithStream flag.
func OptWithStream(b bool) Option {
	return func(cfg *Config) {
		cfg.WithStream = b
	}
}

// OptMaxShift sets the max phase shift size.
func OptMaxShift(i int) Option {
	return func(cfg *Config) {
		if i > 0 {
			cfg.MaxShift = i
		}
	}
}

// OptShiftPenalty sets the shift change penalty.
func OptShiftPenalty(i int) Option {
	return func(cfg *Config) {
		if i > 0 {
			cfg.ShiftPenalty = i
		}
	}
}

// OptFixShifts restricts analysis to specific shift magnitudes.
func OptFixShifts(shifts []int) Option {
	return func(cfg *Config) {
		cfg.FixShifts = shifts
	}
}

// OptAlignAlleles sets the AlignAlleles flag.
func OptAlignAlleles(b bool) Option {
	return func(cfg *Config) {
		cfg.AlignAlleles = b
	}
}

// OptFloatAlign sets the floating indel alignment direction.
func OptFloatAlign(s string) Option {
	return func(cfg *Config) {
		if s == "left" || s == "right" {
			cfg.FloatAlign = s
		}
	}
}

// OptLongIndels sets the LongIndels flag.
func OptLongIndels(b bool) Option {
	return func(cfg *Config) {
		cfg.LongIndels = b
	}
}

// OptPort sets the web service port.
func OptPort(i int) Option {
	return func(cfg *Config) {
		cfg.Port = i
	}
}

// OptWithColor sets the WithColor flag.
func OptWithColor(b bool) Option {
	return func(cfg *Config) {
		cfg.WithColor = b
	}
}

// OptIsTest sets the IsTest flag.
func OptIsTest(b bool) Option {
	return func(cfg *Config) {
		cfg.IsTest = b
	}
}

// OptMaxBatchSequences sets the batch sequence limit.
func OptMaxBatchSequences(i int) Option {
	return func(cfg *Config) {
		cfg.MaxBatchSequences = i
	}
}

// OptMaxSequenceLength sets the single-sequence length limit.
func OptMaxSequenceLength(i int) Option {
	return func(cfg *Config) {
		cfg.MaxSequenceLength = i
	}
}

// OptMaxSimLength sets the simulated fragment length cap.
func OptMaxSimLength(i int) Option {
	return func(cfg *Config) {
		cfg.MaxSimLength = i
	}
}

// OptRateLimit sets the per-IP request rate limit.
func OptRateLimit(f float64) Option {
	return func(cfg *Config) {
		cfg.RateLimit = f
	}
}

// OptBodyLimit sets the maximum request body size.
func OptBodyLimit(s string) Option {
	return func(cfg *Config) {
		cfg.BodyLimit = s
	}
}

// NewConfig creates a new Config with defaults, modified by opts.
func NewConfig(opts ...Option) Config {
	cfg := Config{
		Format:       FASTA,
		JobsNum:      runtime.NumCPU(),
		BatchSize:    50_000,
		MaxShift:     15,
		ShiftPenalty: 2,
		AlignAlleles: true,
		FloatAlign:   "right",
		WithColor:    true,
	}
	for _, opt := range opts {
		opt(&cfg)
	}
	return cfg
}