base

type CheckContext interface {
	// ShouldCheck validate the process with policy item should be checked or ignore
	// Usually if the process already start profiling with specific process, the check should be ignored
	ShouldCheck(p api.ProcessInterface, item *PolicyItem) bool
}

type CheckType string

type Checker interface {
	// Init the checker with basic configs
	Init(config *ContinuousConfig) error
	// SyncPolicies from all service policies and processes
	SyncPolicies(policies []*SyncPolicyWithProcesses)
	// Fetch the policies data and save to the time windows
	Fetch() error
	// Check the policies are reached
	// Each policy with process should use CheckContext.ShouldCheck to validate the policy should be checked or not
	Check(ctx CheckContext, metricsAppender *MetricsAppender) []ThresholdCause
	// Close the checker
	Close() error
}

type ContinuousConfig struct {
	MeterPrefix string `mapstructure:"meter_prefix"` // continuous related meters prefix name

	FetchInterval string        `mapstructure:"fetch_interval"` // The interval of fetch metrics from the system
	CheckInterval string        `mapstructure:"check_interval"` // The interval of check metrics is reach the thresholds
	Trigger       TriggerConfig `mapstructure:"trigger"`
}

type LatestWindowData[D comparable] struct {
	Value D
}

type MetricsAppender struct {
	// contains filtered or unexported fields
}

type Policy struct {
	TargetProfilingType TargetProfilingType
	Items               map[CheckType]*PolicyItem

	ServicePolicy *ServicePolicy
}

type PolicyItem struct {
	Threshold string
	Period    int
	Count     int
	URIList   []string
	URIRegex  string

	Policy *Policy
}

type ServicePolicy struct {
	Service string
	UUID    string

	Policies  []*Policy
	Processes map[string]api.ProcessInterface
}

type SyncPolicyWithProcesses struct {
	Policy    *Policy
	Processes map[string]api.ProcessInterface
}

type TargetProfilingType string

type ThresholdCause interface {
	// Process is over threshold
	Process() api.ProcessInterface
	// FromPolicy current from which policy
	FromPolicy() *PolicyItem
	// GenerateTransferCause transmit to the backend
	GenerateTransferCause() *v3.ContinuousProfilingCause
}

type TimeWindows[V any, R any] struct {
	// contains filtered or unexported fields
}

type Trigger interface {
	// Init trigger
	Init(moduleMgr *module.Manager, conf *ContinuousConfig) error
	// ShouldTrigger validate the process should be trigger task
	ShouldTrigger(p api.ProcessInterface) bool
	// TriggerTasks generate task and execute that policy could be trigger
	TriggerTasks(reporter TriggerReporter, causes []ThresholdCause) int
}

type TriggerConfig struct {
	ExecuteDuration string `mapstructure:"execute_duration"` // the duration of the profiling task
	SilenceDuration string `mapstructure:"silence_duration"` // the duration between the execution of the same profiling task.
}

type TriggerReporter interface {
	ReportProcesses(causeProcess api.ProcessInterface, profilingProcesses []api.ProcessInterface, cases []ThresholdCause,
		taskSetter func(task *taskBase.ProfilingTask),
		reportSetter func(report *v3.ContinuousProfilingReport)) (*task.Context, error)
}

type URIChecker struct {
	FixedURIList []string
	URIRegexList []*regexp.Regexp
}

type URIResponseDurationTimeoutRate struct {
	Timeout int // Define how long(ms) is considered a timeout
	Rate    int // Response timeout rate
}

type WindowData[D any, R any] interface {
	// Reset the data content
	Reset()
	// Accept add data
	Accept(data D)
	// Get calculate the result
	Get() R
}