action

type Action struct {
	Type                     string                    `bson:"type" json:"type"`
	Parameters               interface{}               `bson:"parameters,omitempty" json:"parameters,omitempty"` // parameters for the action
	AlarmPatterns            pattern.AlarmPatternList  `bson:"alarm_patterns" json:"alarm_patterns"`
	EntityPatterns           pattern.EntityPatternList `bson:"entity_patterns" json:"entity_patterns"`
	DropScenarioIfNotMatched bool                      `bson:"drop_scenario_if_not_matched" json:"drop_scenario_if_not_matched"`
	EmitTrigger              bool                      `bson:"emit_trigger" json:"emit_trigger"`
}

type Adapter interface {
	GetEnabled() ([]Scenario, error)
	GetEnabledById(id string) (Scenario, error)
	GetEnabledByIDs(ids []string) ([]Scenario, error)
}

type DelayedScenario struct {
	ID            string        `json:"id"`
	ScenarioID    string        `json:"scenario_id"`
	AlarmID       string        `json:"alarm_id"`
	ExecutionTime types.CpsTime `json:"execution_time"`
	Paused        bool          `json:"paused"`
	TimeLeft      time.Duration `json:"time_left"`
}

type DelayedScenarioManager interface {
	AddDelayedScenario(context.Context, types.Alarm, Scenario) error
	PauseDelayedScenarios(context.Context, types.Alarm) error
	ResumeDelayedScenarios(context.Context, types.Alarm) error
	Run(context.Context) (<-chan DelayedScenarioTask, error)
}

type DelayedScenarioStorage interface {
	Add(ctx context.Context, scenario DelayedScenario) (string, error)
	GetAll(ctx context.Context) ([]DelayedScenario, error)
	Get(ctx context.Context, id string) (*DelayedScenario, error)
	Delete(ctx context.Context, id string) (bool, error)
	Update(ctx context.Context, scenario DelayedScenario) (bool, error)
}

type DelayedScenarioTask struct {
	Alarm    types.Alarm
	Scenario Scenario
}

type ExecuteScenariosTask struct {
	Triggers             []string
	DelayedScenarioID    string
	AbandonedExecutionID string
	Entity               types.Entity
	Alarm                types.Alarm
	AckResources         bool
}

type Execution struct {
	Action   Action `json:"a"`
	Executed bool   `json:"e"`
}

type RpcResult struct {
	CorrelationID   string
	Alarm           *types.Alarm
	AlarmChangeType types.AlarmChangeType
	Header          map[string]string
	Response        map[string]interface{}
	Error           error
}

type Scenario struct {
	ID                   string                  `bson:"_id,omitempty" json:"_id,omitempty"`
	Name                 string                  `bson:"name" json:"name"`
	Author               string                  `bson:"author" json:"author"`
	Enabled              bool                    `bson:"enabled" json:"enabled"`
	DisableDuringPeriods []string                `bson:"disable_during_periods" json:"disable_during_periods"`
	Triggers             []string                `bson:"triggers" json:"triggers"`
	Actions              []Action                `bson:"actions" json:"actions"`
	Priority             int                     `bson:"priority" json:"priority"`
	Delay                *types.DurationWithUnit `bson:"delay" json:"delay"`
	Created              types.CpsTime           `bson:"created,omitempty" json:"created,omitempty"`
	Updated              types.CpsTime           `bson:"updated,omitempty" json:"updated,omitempty"`
}

type ScenarioExecution struct {
	ID               string                 `json:"-"`
	ScenarioID       string                 `json:"-"`
	AlarmID          string                 `json:"-"`
	Entity           types.Entity           `json:"e"`
	ActionExecutions []Execution            `json:"ae"`
	LastUpdate       int64                  `json:"u"`
	AckResources     bool                   `json:"ar"`
	Tries            int64                  `json:"t"`
	Header           map[string]string      `json:"h,omitempty"`
	Response         map[string]interface{} `json:"r,omitempty"`
}

type ScenarioExecutionStorage interface {
	Get(ctx context.Context, executionID string) (*ScenarioExecution, error)
	GetAbandoned(ctx context.Context) ([]ScenarioExecution, error)
	Create(ctx context.Context, execution ScenarioExecution) (string, error)
	Update(ctx context.Context, execution ScenarioExecution) error
	Del(ctx context.Context, executionID string) error
	Inc(ctx context.Context, id string, inc int64, drop bool) (int64, error)
}

type ScenarioResult struct {
	Alarm types.Alarm
	Err   error
}

type ScenarioStorage interface {
	// ReloadScenarios trigger a refresh on scenarios cache from DB
	ReloadScenarios() error

	// GetTriggeredScenarios returns scenarios which are triggered by triggers.
	GetTriggeredScenarios(
		triggers []string,
		alarm types.Alarm,
	) (triggered []Scenario, err error)

	// RunDelayedScenarios starts delay timeout for scenarios which are triggered by triggers.
	RunDelayedScenarios(
		ctx context.Context,
		triggers []string,
		alarm types.Alarm,
		entity types.Entity,
	) error

	// GetScenario returns scenario.
	GetScenario(id string) *Scenario
}

type Service interface {
	// Process parse an event to see if an action is suitable.
	Process(ctx context.Context, event *types.Event) error

	// ListenScenarioFinish receives message when all scenarios for event are finished
	// and acknowledges fifo.
	ListenScenarioFinish(ctx context.Context, channel <-chan ScenarioResult)

	// ProcessAbandonedExecutions checks execution storage and processes executions which
	// weren't updated for a long time
	ProcessAbandonedExecutions(ctx context.Context) error
}

type Task struct {
	Source       string
	Action       Action
	Alarm        types.Alarm
	Entity       types.Entity
	Step         int
	ExecutionID  string
	ScenarioID   string
	AckResources bool
	Header       map[string]string
	Response     map[string]interface{}
}

type TaskManager interface {
	Run(ctx context.Context, rpcResultChannel <-chan RpcResult,
		inputChannel <-chan ExecuteScenariosTask) (<-chan ScenarioResult, error)
}

type TaskResult struct {
	Source          string
	Alarm           types.Alarm
	Step            int
	ExecutionID     string
	AlarmChangeType types.AlarmChangeType
	Status          int
	Header          map[string]string
	Response        map[string]interface{}
	Err             error
}

type WorkerPool interface {
	RunWorkers(ctx context.Context, taskChannel <-chan Task) (<-chan TaskResult, error)
}