rule

type BatchEvaluationResult struct {
	RuleID  types.RuleID
	Passed  bool
	Reason  string
	Err     error
	Skipped bool // true if rule was skipped (e.g., primaryType mismatch)
}

type BatchRuleEvaluator interface {
	RuleEvaluator

	// EvaluateBatch evaluates multiple rules against the same request in a single execution
	// Returns results in the same order as the input rules
	// Rules that don't apply (e.g., primaryType mismatch) will have Skipped=true
	EvaluateBatch(ctx context.Context, rules []*types.Rule, req *types.SignRequest, parsed *types.ParsedPayload) ([]BatchEvaluationResult, error)

	// CanBatchEvaluate returns true if the given rules can be evaluated together
	// Rules might not be batchable if they use different validation modes
	CanBatchEvaluate(rules []*types.Rule) bool
}

type BlockedError struct {
	RuleID   types.RuleID
	RuleName string
	Reason   string
}

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

type DefaultRuleGenerator struct{}

type EvaluationResult struct {
	// Blocked indicates the request was blocked by a blocklist rule
	Blocked bool

	// BlockedBy contains the rule that blocked the request (if Blocked is true)
	BlockedBy *types.Rule

	// BlockReason explains why the request was blocked
	BlockReason string

	// Allowed indicates the request was allowed by a whitelist rule
	Allowed bool

	// AllowedBy contains the rule that allowed the request (if Allowed is true)
	AllowedBy *types.Rule

	// AllowReason explains why the request was allowed
	AllowReason string
}

type RuleEngine interface {
	// Evaluate performs two-tier rule evaluation:
	// 1. Check blocklist rules first - ANY violation = blocked (returns BlockedError)
	// 2. Check whitelist rules - ANY match = allowed
	// Returns:
	// - (*RuleID, reason, nil) if whitelisted
	// - (nil, "", nil) if no whitelist match (needs manual approval)
	// - (nil, "", BlockedError) if blocked by a blocklist rule
	Evaluate(ctx context.Context, req *types.SignRequest, parsed *types.ParsedPayload) (*types.RuleID, string, error)

	// EvaluateWithResult returns detailed evaluation result
	EvaluateWithResult(ctx context.Context, req *types.SignRequest, parsed *types.ParsedPayload) (*EvaluationResult, error)

	// RegisterEvaluator registers a chain-specific rule evaluator
	RegisterEvaluator(evaluator RuleEvaluator)
}

type RuleEngineOption func(*WhitelistRuleEngine)

type RuleEvaluationError struct {
	RuleID   types.RuleID
	RuleName string
	RuleType types.RuleType
	Err      error
}

type RuleEvaluator interface {
	// Type returns the rule type this evaluator handles
	Type() types.RuleType

	// Evaluate evaluates the rule against the request
	// For whitelist mode: returns (true, reason, nil) if request matches the whitelist
	// For blocklist mode: returns (true, reason, nil) if request VIOLATES the limit (should be blocked)
	Evaluate(ctx context.Context, rule *types.Rule, req *types.SignRequest, parsed *types.ParsedPayload) (bool, string, error)
}

type RuleGenerateOptions struct {
	RuleType types.RuleType `json:"rule_type"` // Required: evm_address_list, evm_contract_method, evm_value_limit
	RuleMode types.RuleMode `json:"rule_mode"` // Required: whitelist or blocklist
	RuleName string         `json:"rule_name"` // Optional: custom name, auto-generated if empty

	// For evm_value_limit: explicit max_value (required for this type)
	MaxValue *string `json:"max_value,omitempty"`
}

type RuleGenerator interface {
	// Preview generates a rule preview without saving (for user confirmation)
	Preview(req *types.SignRequest, parsed *types.ParsedPayload, opts *RuleGenerateOptions) (*types.Rule, error)

	// Generate creates and returns a rule (caller is responsible for saving)
	Generate(req *types.SignRequest, parsed *types.ParsedPayload, opts *RuleGenerateOptions) (*types.Rule, error)

	// SupportedTypes returns the rule types this generator can create
	SupportedTypes() []types.RuleType
}

type SignTypeApplicable interface {
	// AppliesToSignType returns false if the rule does not apply to the given sign type (e.g. sign_type_filter mismatch).
	AppliesToSignType(rule *types.Rule, signType string) bool
}

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