engine

type CatEvaluator interface {
	Evaluate(event *objectmap.ObjectAttributeMap, frames []interface{}) (bool, error)
	GetCategory() types.Category
	immutable.SetElement
}

type CatEvaluatorKind int8

type CompareCondRepo struct {
	AttributeToCompareCondRecord map[string]*hashset.Set[*EvalCategoryRec]
	CondToCompareCondRecord      *hashmap.Map[condition.Condition, *EvalCategoryRec]
	CondToCategoryMap            *hashmap.Map[condition.Condition, *hashmap.Map[condition.Operand, []condition.Operand]]
	CondToStringMatcher          *hashmap.Map[condition.Condition, *StringMatcher]
	EvalCategoryRecs             []*EvalCategoryRec
	// Categories that must be evaluated even if their attributes aren't in the event
	// (e.g., null checks like "field == null", constant expressions like "1 == 1")
	AlwaysEvaluateCategories *hashset.Set[*EvalCategoryRec]
	// Set of categories that check "field == undefined" (for efficient DefaultCatList)
	UndefinedEqualityCategories *hashset.Set[types.Category]
	RuleRepo                    condition.RuleRepo
	ObjectAttributeMapper       *objectmap.ObjectAttributeMapper
	CondFactory                 *condition.Factory
	// contains filtered or unexported fields
}

type EvalCategoryRec struct {
	Cat                      types.Category
	Eval                     condition.Operand
	AttrKeys                 []string
	IsUndefinedEqualityCheck bool   // true if this category checks "field == undefined"
	FieldPath                string // field path for undefined checks (e.g., "age", "user.name")
}

type EvalCondFunc func(event *objectmap.ObjectAttributeMap, frames []interface{}) (bool, error)

type ExternalRule struct {
	Metadata   map[string]interface{} `json:"metadata,omitempty"`
	Expression string                 `json:"expression"`
	Tests      []TestCase             `json:"tests,omitempty" yaml:"tests,omitempty"`
}

type ForEachScope struct {
	// Path, e.g. $.members or $member.children.
	// Each path consist of the outer path reference (e.g. $ for root or $member for path to
	// the member element) and the path to a nested array element.  The address of the denoted
	// element is therefore a concatenation of the address of the parent element's path
	// and the address of the path of the current element.
	Path         string
	Element      string
	NestingLevel int
	ParentScope  *ForEachScope
	Evaluator    *EvalCategoryRec
	AttrDictRec  *objectmap.AttrDictionaryRec
}

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

type InternalRule struct {
	Metadata  map[string]interface{}
	Condition condition.Condition
}

type LoadOption func(*loadConfig)

type LoadResult struct {
	RuleIDs      []uint       // IDs of loaded rules
	ValidationOK bool         // True if all rules validated successfully
	TestResults  []TestResult // Results from test execution
	Errors       []error      // Validation or test errors
}

type RepoInterface interface {
	Register(f *InternalRule)
}

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

type RuleEngine struct {
	Metrics RuleEngineMetrics
	// contains filtered or unexported fields
}

type RuleEngineMetrics struct {
	NumCatEvals uint64
}

type RuleEngineRepo struct {
	Rules []*GeneralRuleRecord

	Optimize bool // If true, apply category engine optimizations (default: true)
	// contains filtered or unexported fields
}

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

type TestCase struct {
	Name   string                 `json:"name" yaml:"name"`
	Event  map[string]interface{} `json:"event" yaml:"event"`
	Expect bool                   `json:"expect" yaml:"expect"`
}

type TestResult struct {
	RuleID   string                 // Rule ID from metadata
	TestName string                 // Test case name
	Passed   bool                   // Whether test passed
	Expected bool                   // Expected result
	Actual   bool                   // Actual result
	Event    map[string]interface{} // Test event data
	Error    error                  // Error if test execution failed
}

type TestSummary struct {
	Total  int // Total number of tests
	Passed int // Number of tests that passed
	Failed int // Number of tests that failed
	Errors int // Number of tests that had execution errors
}