engine

type AndCondition struct {
	Conditions []ConditionEntry `yaml:"and"`
}

type ChainTemplate struct {
	Filepaths     []string               `yaml:"filepaths,omitempty" json:"filepaths,omitempty"`
	Extras        map[string]interface{} `yaml:"extras,omitempty" json:"extras,omitempty"`
	ExcludedPaths []string               `yaml:"excludedPaths,omitempty" json:"excludedPaths,omitempty"`
}

type CodeSnip interface {
	GetCodeSnip(uri.URI, Location) (string, error)
}

type ConditionContext struct {
	Tags     map[string]interface{}   `yaml:"tags"`
	Template map[string]ChainTemplate `yaml:"template"`
	RuleID   string                   `yaml:"ruleID"`
}

type ConditionEntry struct {
	From                   string
	As                     string
	Ignorable              bool
	Not                    bool
	ProviderSpecificConfig Conditional
}

type ConditionResponse struct {
	Matched bool `yaml:"matched"`
	// For each time the condition is hit, add all of the context.
	// keys here, will be used in the message.
	Incidents       []IncidentContext      `yaml:"incidents"`
	TemplateContext map[string]interface{} `yaml:",inline"`
}

type Conditional interface {
	Evaluate(ctx context.Context, log logr.Logger, condCtx ConditionContext) (ConditionResponse, error)
}

type CustomVariable struct {
	Pattern            *regexp.Regexp `yaml:"pattern"`
	Name               string         `yaml:"name"`
	DefaultValue       string         `yaml:"defaultValue"`
	NameOfCaptureGroup string         `yaml:"nameOfCaptureGroup"`
}

type IncidentContext struct {
	FileURI      uri.URI                `yaml:"fileURI"`
	Effort       *int                   `yaml:"effort"`
	LineNumber   *int                   `yaml:"lineNumber,omitempty"`
	Variables    map[string]interface{} `yaml:"variables"`
	Links        []konveyor.Link        `yaml:"externalLink"`
	CodeLocation *Location              `yaml:"location,omitempty"`
}

type Location struct {
	StartPosition Position `yaml:"startPosition"`
	EndPosition   Position `yaml:"endPosition"`
}

type Message struct {
	Text  *string         `yaml:"message,omitempty"`
	Links []konveyor.Link `yaml:"links,omitempty"`
}

type Option func(engine *ruleEngine)

type OrCondition struct {
	Conditions []ConditionEntry `yaml:"or"`
}

type Perform struct {
	Message Message  `yaml:",inline"`
	Tag     []string `yaml:"tag,omitempty"`
}

type Position struct {
	/*Line defined:
	 * Line position in a document (zero-based).
	 * If a line number is greater than the number of lines in a document, it defaults back to the number of lines in the document.
	 * If a line number is negative, it defaults to 0.
	 */
	Line int `yaml:"line"`

	/*Character defined:
	 * Character offset on a line in a document (zero-based). Assuming that the line is
	 * represented as a string, the `character` value represents the gap between the
	 * `character` and `character + 1`.
	 *
	 * If the character value is greater than the line length it defaults back to the
	 * line length.
	 * If a line number is negative, it defaults to 0.
	 */
	Character int `yaml:"character"`
}

type Rule struct {
	RuleMeta        `yaml:",inline" json:",inline"`
	Perform         Perform          `yaml:",inline" json:"perform,omitempty"`
	When            Conditional      `yaml:"when,omitempty" json:"when,omitempty"`
	Snipper         CodeSnip         `yaml:"-" json:"-"`
	CustomVariables []CustomVariable `yaml:"customVariables,omitempty" json:"customVariables,omitempty"`
}

type RuleEngine interface {
	// RunRules runs the given rulesets with optional selectors
	RunRules(context context.Context, rules []RuleSet, selectors ...RuleSelector) []konveyor.RuleSet

	// RunRulesWithOptions runs the given rulesets with run-specific options (e.g., progress reporter) and selectors
	RunRulesWithOptions(context context.Context, rules []RuleSet, opts []RunOption, selectors ...RuleSelector) []konveyor.RuleSet

	// RunRulesScoped runs the given rulesets with a scope and optional selectors
	RunRulesScoped(ctx context.Context, ruleSets []RuleSet, scopes Scope, selectors ...RuleSelector) []konveyor.RuleSet

	// RunRulesScopedWithOptions runs the given rulesets with a scope, run-specific options, and selectors
	RunRulesScopedWithOptions(ctx context.Context, ruleSets []RuleSet, scopes Scope, opts []RunOption, selectors ...RuleSelector) []konveyor.RuleSet

	// Stop stops the rule engine and waits for all workers to complete
	Stop()
}

type RuleMeta struct {
	RuleID      string             `yaml:"ruleID,omitempty" json:"ruleID,omitempty"`
	Description string             `yaml:"description,omitempty" json:"description,omitempty"`
	Category    *konveyor.Category `yaml:"category,omitempty" json:"category,omitempty"`
	Labels      []string           `yaml:"labels,omitempty" json:"labels,omitempty"`
	Effort      *int               `json:"effort,omitempty"`
	UsesHasTags bool
}

type RuleSelector interface {
	Matches(*RuleMeta) (bool, error)
}

type RuleSet struct {
	Name        string   `json:"name,omitempty" yaml:"name,omitempty"`
	Description string   `json:"description,omitempty" yaml:"description,omitempty"`
	Labels      []string `json:"labels,omitempty" yaml:"labels,omitempty"`
	Tags        []string `json:"tags,omitempty" yaml:"tags,omitempty"`
	Rules       []Rule   `json:"rules,omitempty" yaml:"rules,omitempty"`
}

type RunOption func(*runConfig)

type Scope interface {
	Name() string
	// For now this is the only place that we are considering adding a scope
	// in the future, we could scope other things
	AddToContext(*ConditionContext) error
	FilterResponse(IncidentContext) bool
}