policy

var (
	// MaxLengthRule checks message content length.
	MaxLengthRule = func(maxLength int) ConformanceRule {
		return ConformanceRule{
			ID:          "max_length",
			Name:        "Maximum Message Length",
			Description: fmt.Sprintf("Messages must not exceed %d characters", maxLength),
			Severity:    SeverityWarning,
			Enabled:     true,
			Check: func(_ context.Context, msg *Message) error {
				if len(msg.Content) > maxLength {
					return fmt.Errorf("message length %d exceeds maximum %d", len(msg.Content), maxLength)
				}
				return nil
			},
		}
	}

	// NoEmptyContentRule checks that messages have content.
	NoEmptyContentRule = ConformanceRule{
		ID:          "no_empty_content",
		Name:        "No Empty Content",
		Description: "Messages must have non-empty content",
		Severity:    SeverityError,
		Enabled:     true,
		Check: func(_ context.Context, msg *Message) error {
			if msg.Content == "" {
				return fmt.Errorf("message content is empty")
			}
			return nil
		},
	}

	// ValidSenderRule checks that messages have a sender.
	ValidSenderRule = ConformanceRule{
		ID:          "valid_sender",
		Name:        "Valid Sender",
		Description: "Messages must have a valid sender ID",
		Severity:    SeverityError,
		Enabled:     true,
		Check: func(_ context.Context, msg *Message) error {
			if msg.SenderID == "" {
				return fmt.Errorf("sender ID is required")
			}
			return nil
		},
	}

	// ContentPatternRule checks message content against a regex pattern.
	ContentPatternRule = func(id, name string, pattern string, severity Severity, mustMatch bool) ConformanceRule {
		re := regexp.MustCompile(pattern)
		return ConformanceRule{
			ID:          id,
			Name:        name,
			Description: fmt.Sprintf("Content must %smatch pattern: %s", map[bool]string{true: "", false: "not "}[mustMatch], pattern),
			Severity:    severity,
			Enabled:     true,
			Check: func(_ context.Context, msg *Message) error {
				matches := re.MatchString(msg.Content)
				if mustMatch && !matches {
					return fmt.Errorf("content does not match required pattern")
				}
				if !mustMatch && matches {
					return fmt.Errorf("content matches prohibited pattern")
				}
				return nil
			},
		}
	}

	// RateLimitRule checks if sender is within rate limits.
	RateLimitRule = func(maxPerMinute int, tracker RateLimitTracker) ConformanceRule {
		return ConformanceRule{
			ID:          "rate_limit",
			Name:        "Rate Limit",
			Description: fmt.Sprintf("Senders limited to %d messages per minute", maxPerMinute),
			Severity:    SeverityWarning,
			Enabled:     true,
			Check: func(ctx context.Context, msg *Message) error {
				count := tracker.GetCount(msg.SenderID)
				if count >= maxPerMinute {
					return fmt.Errorf("rate limit exceeded: %d/%d messages per minute", count, maxPerMinute)
				}
				tracker.Increment(msg.SenderID)
				return nil
			},
		}
	}
)