run

type Algorithm[Input, Option, Solution any] func(
	context.Context, Input, Option, chan<- Solution,
) error

type AsyncHTTPRequestHandlerOption func(*asyncHTTPHandler)

type CLIRunnerConfig struct {
	Runner struct {
		Input struct {
			Path string `usage:"The input file path"`
		}
		Profile struct {
			CPU    string `usage:"The CPU profile file path"`
			Memory string `usage:"The memory profile file path"`
		}
		Output struct {
			Path      string `usage:"The output file path"`
			Solutions string `default:"last" usage:"{all, last}"`
		}
	}
}

type CPUProfiler interface {
	CPUProfilePath() string
}

type Callback func(requestID string, contentType string) error

type ContentTyper interface {
	ContentType() string
}

type Decoder[Input any] func(context.Context, any) (Input, error)

type Encoder[Solution, Option any] interface {
	Encode(context.Context, <-chan Solution, any, any, Option) error
}

type HTTPRequestHandler func(
	w http.ResponseWriter, req *http.Request,
) (Callback, IOProducer[HTTPRunnerConfig], error)

type HTTPRunner[RunnerConfig, Input, Option, Solution any] interface {
	Runner[RunnerConfig, Input, Option, Solution]
	// ActiveRuns returns the number of currently active runs.
	ActiveRuns() int
}

type HTTPRunnerConfig struct {
	Runner struct {
		Log    *log.Logger
		Output struct {
			Solutions string `default:"last" usage:"Return all or last solution"`
		}
		HTTP struct {
			Address           string        `default:":9000" usage:"The host address"`
			Certificate       string        `usage:"The certificate file path"`
			Key               string        `usage:"The key file path"`
			ReadHeaderTimeout time.Duration `default:"60s" usage:"The maximum duration for reading the request headers"`
			MaxParallel       int           `default:"1" usage:"The max number of requests"`
		}
	}
}

type HTTPRunnerOption[Input, Option, Solution any] func(
	*httpRunner[Input, Option, Solution],
)

type IOData interface {
	Input() any
	Option() any
	Writer() any
}

type IOProducer[RunnerConfig any] func(
	context.Context, RunnerConfig,
) (IOData, error)

type MemoryProfiler interface {
	MemoryProfilePath() string
}

type OutputPather interface {
	OutputPath() string
}

type Runner[RunnerConfig, Input, Option, Solution any] interface {
	// Run runs the runner.
	Run(context.Context) error
	// SetIOProducer sets the ioProducer of a runner.
	SetIOProducer(IOProducer[RunnerConfig])
	// SetInputDecoder sets the inputDecoder of a runner.
	SetInputDecoder(Decoder[Input])
	// SetInputValidator sets the inputValidator of a runner.
	SetInputValidator(Validator[Input])
	// SetOptionDecoder sets the optionDecoder of a runner.
	SetOptionDecoder(Decoder[Option])
	// SetAlgorithm sets the algorithm of a runner.
	SetAlgorithm(Algorithm[Input, Option, Solution])
	// SetEncoder sets the encoder of a runner.
	SetEncoder(Encoder[Solution, Option])
	// GetEncoder returns the encoder of a runner.
	GetEncoder() Encoder[Solution, Option]
	// RunnerConfig returns the runnerConfig of a runner.
	RunnerConfig() RunnerConfig
}

type RunnerOption[RunnerConfig, Input, Option, Solution any] func(
	Runner[RunnerConfig, Input, Option, Solution],
)

type SolutionLimiter interface {
	Solutions() (Solutions, error)
}

type Solutions int

type Validator[Input any] func(context.Context, any) error