types

type Config struct {
	// Name define the name of the monitor
	Name string `json:"name" yaml:"name" toml:"name" mapstructure:"name"`

	// CheckTimeout define the timeout use for healthcheck. Default is 5 second.
	CheckTimeout libdur.Duration `json:"check-timeout" yaml:"check-timeout" toml:"check-timeout" mapstructure:"check-timeout"`

	// IntervalCheck define the time waiting between 2 healthcheck. Default is 5 second.
	IntervalCheck libdur.Duration `json:"interval-check" yaml:"interval-check" toml:"interval-check" mapstructure:"interval-check"`

	// IntervalFall define the time waiting between 2 healthcheck when last check is KO. Default is 5 second.
	IntervalFall libdur.Duration `json:"interval-fall" yaml:"interval-fall" toml:"interval-fall" mapstructure:"interval-down"`

	// IntervalRise define the time waiting between 2 healthcheck when status is KO or Warn but last check is OK. Default is 5 second.
	IntervalRise libdur.Duration `json:"interval-rise" yaml:"interval-rise" toml:"interval-rise" mapstructure:"interval-rise"`

	// FallCountKO define the number of KO before considerate the component as down.
	FallCountKO uint8 `json:"fall-count-ko" yaml:"fall-count-ko" toml:"fall-count-ko" mapstructure:"fall-count-ko"`

	// FallCountWarn define the number of KO before considerate the component as warn.
	FallCountWarn uint8 `json:"fall-count-warn" yaml:"fall-count-warn" toml:"fall-count-warn" mapstructure:"fall-count-warn"`

	// RiseCountKO define the number of OK when status is KO before considerate the component as up.
	RiseCountKO uint8 `json:"rise-count-ko" yaml:"rise-count-ko" toml:"rise-count-ko" mapstructure:"rise-count-ko"`

	// RiseCountWarn define the number of OK when status is Warn before considerate the component as up.
	RiseCountWarn uint8 `json:"rise-count-warn" yaml:"rise-count-warn" toml:"rise-count-warn" mapstructure:"rise-count-warn"`

	// Logger define the logger options for current monitor log
	Logger logcfg.Options `json:"logger" yaml:"logger" toml:"logger" mapstructure:"logger"`
}

type FuncPool func() Pool

type HealthCheck func(ctx context.Context) error

type Info interface {
	encoding.TextMarshaler
	json.Marshaler

	InfoName
	InfoData
}

type InfoData interface {
	// Info returns a map of string to interface that contains information about the
	// monitor. Common keys include "version", "build", "uptime", etc.
	Info() map[string]interface{}
}

type InfoName interface {
	// Name returns the name of the component.
	// The name is used to identify the component in logs and metrics.
	Name() string
}

type Monitor interface {
	MonitorInfo
	MonitorStatus
	MonitorMetrics
	libsrv.Runner

	// SetConfig is used to set or update config of the monitor
	SetConfig(ctx context.Context, cfg Config) error

	// RegisterLoggerDefault is used to define the default logger.
	// Default logger can be used to extend options logger from it
	RegisterLoggerDefault(fct liblog.FuncLog)

	// GetConfig is used to retrieve config of the monitor
	GetConfig() Config

	// SetHealthCheck is used to set or update the healthcheck func
	SetHealthCheck(fct HealthCheck)

	// GetHealthCheck is used to retrieve the healthcheck func
	GetHealthCheck() HealthCheck

	// Clone is used to clone monitor to another standalone instance
	Clone(ctx context.Context) (Monitor, error)
}

type MonitorInfo interface {
	// InfoGet returns the current information of the monitor.
	//
	// It returns the monitor information as a struct of type Info.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   Info - the current information of the monitor.
	InfoGet() Info
	// InfoUpd updates the information of the monitor.
	//
	// Parameters:
	// - inf Info: the new information of the monitor.
	//
	// Returns:
	// - None.
	InfoUpd(inf Info)
	// InfoName returns the name of the monitor information.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   string - the name of the monitor information.
	InfoName() string
	// InfoMap returns the current information of the monitor as a map of strings to
	// interface values.
	//
	// It is a convenience function that allows to access the information
	// without having to know the exact structure of the Info type.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   map[string]interface{} - the current information of the monitor as a map.
	//
	InfoMap() map[string]interface{}
}

type MonitorMetrics interface {
	// RegisterMetricsName registers names of metrics for this monitor.
	// The names are stored in memory and used to register metrics
	// when calling RegisterCollectMetrics.
	//
	// The metric names should be in the format:
	//   <monitor_name>_<metric_name>
	//
	// For example:
	//   monitor_latency
	//   monitor_uptime
	//   monitor_downtime
	//
	// The names are case-sensitive.
	//
	// Parameters:
	//   names - a list of metric names to register.
	//
	// Returns:
	//   None.
	RegisterMetricsName(names ...string)
	// RegisterMetricsAddName registers additional names of metrics for this monitor.
	// The names are added to the list of names stored in memory and used to register metrics
	// when calling RegisterCollectMetrics.
	//
	// The metric names should be in the format:
	//   <monitor_name>_<metric_name>
	//
	// For example:
	//   monitor_latency
	//   monitor_uptime
	//   monitor_downtime
	//
	// The names are case-sensitive.
	//
	// Parameters:
	//   names - a list of metric names to register.
	//
	// Returns:
	//   None.
	RegisterMetricsAddName(names ...string)
	// RegisterCollectMetrics registers a function to collect metrics for this monitor.
	//
	// The function will be called by the monitor with the correct context and metric names.
	// The function should update the metrics with the correct values.
	//
	// Parameters:
	//   fct - the function to register.
	//
	// Returns:
	//   None.
	RegisterCollectMetrics(fct libprm.FuncCollectMetrics)

	// CollectLatency returns the last check's latency.
	//
	// It returns the time spent between the start of the last check and the moment
	// the last check returned a status (OK, Warn, KO).
	//
	// It returns an error if the last check didn't return a status.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   time.Duration - the last check's latency.
	//   liberr.Error - an error if the last check didn't return a status.
	CollectLatency() time.Duration
	// CollectUpTime returns the total duration of uptime (OK status) since the
	// monitor was created.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   time.Duration - the total duration of uptime (OK status).
	CollectUpTime() time.Duration
	// CollectDownTime returns the total duration of downtime (KO status) since the
	// monitor was created.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   time.Duration - the total duration of downtime (KO status).
	CollectDownTime() time.Duration
	// CollectRiseTime returns the total duration of rising status since the monitor was created.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   time.Duration - the total duration of rising status.
	CollectRiseTime() time.Duration
	// CollectFallTime returns the total duration of falling status since the
	// monitor was created.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   time.Duration - the total duration of falling status.
	CollectFallTime() time.Duration
	// CollectStatus returns the current status of the monitor and whether
	// the status is rising or falling.
	//
	// Parameters:
	//   None.
	//
	// Returns:
	//   sts monsts.Status - the current status of the monitor.
	//   rise bool - whether the status is rising.
	//   fall bool - whether the status is falling.
	CollectStatus() (sts monsts.Status, rise bool, fall bool)
}

type MonitorStatus interface {
	encoding.TextMarshaler
	json.Marshaler

	// Name return the name of the monitor.
	Name() string

	// Status return the last status (OK / Warn / KO).
	Status() monsts.Status

	// Message return the last error, warning, message of the last status
	Message() string

	// IsRise return true if rising status from KO or Warn
	IsRise() bool

	// IsFall return true if falling status to KO or Warn
	IsFall() bool

	// Latency return the last check's latency
	Latency() time.Duration

	// Uptime return the total duration of uptime (OK status)
	Uptime() time.Duration

	// Downtime return the total duration of downtime (KO status)
	Downtime() time.Duration
}

type Pool interface {
	PoolStatus
	PoolShell
}

type PoolManage interface {
	// MonitorAdd adds a monitor to the pool.
	// Returns an error if the monitor is nil or has an empty name.
	// If the pool is running, the monitor is automatically started.
	MonitorAdd(mon Monitor) error

	// MonitorGet retrieves a monitor from the pool by name.
	// Returns nil if the monitor is not found.
	MonitorGet(name string) Monitor

	// MonitorSet updates or adds a monitor in the pool.
	// If the monitor doesn't exist, it will be added.
	// Returns an error if the monitor is nil or has an empty name.
	MonitorSet(mon Monitor) error

	// MonitorDel removes a monitor from the pool by name.
	// Does nothing if the monitor doesn't exist.
	MonitorDel(name string)

	// MonitorList returns a slice of all monitor names in the pool.
	MonitorList() []string

	// MonitorWalk iterates over monitors in the pool, calling the provided function for each.
	// The iteration stops if the function returns false.
	// The validName parameter optionally filters which monitors to visit.
	MonitorWalk(fct func(name string, val Monitor) bool, validName ...string)
}

type PoolShell interface {
	// GetShellCommand returns a list of available shell commands for pool operations.
	// Common commands include: list, info, start, stop, restart, and status.
	GetShellCommand(ctx context.Context) []shlcmd.Command
}

type PoolStatus interface {
	encoding.TextMarshaler
	json.Marshaler
	PoolManage
}