OrchestrAD/backend/internal/services/rule_service.go

// Package services - Rule service
package services

import (
	"database/sql"
	"fmt"

	"github.com/Grace-Solutions/OrchestrAD/internal/logging"
	"github.com/Grace-Solutions/OrchestrAD/internal/models"
	"github.com/Grace-Solutions/OrchestrAD/internal/repository"
)

// RuleService handles rule operations
type RuleService struct {
	repo   *repository.RuleRepository
	logger *logging.Logger
}

// NewRuleService creates a new RuleService
func NewRuleService(db *sql.DB, logger *logging.Logger) *RuleService {
	return &RuleService{
		repo:   repository.NewRuleRepository(db),
		logger: logger,
	}
}

// CreateRuleInput represents input for creating a rule
type CreateRuleInput struct {
	Name                string
	Description         *string
	ADConnectionID      string
	ObjectType          string
	BaseDNOverride      *string
	SearchScopeOverride *string
	ScheduleID          *string
	ExecutionMode       string
	GroupJoinOperator   string
	MaxParallelism      *int
	StopOnError         bool
}

// Create creates a new rule
func (s *RuleService) Create(input CreateRuleInput) (*models.Rule, error) {
	rule := &models.Rule{
		Name:                input.Name,
		Description:         input.Description,
		IsEnabled:           true,
		ADConnectionID:      input.ADConnectionID,
		ObjectType:          input.ObjectType,
		BaseDNOverride:      input.BaseDNOverride,
		SearchScopeOverride: input.SearchScopeOverride,
		ScheduleID:          input.ScheduleID,
		ExecutionMode:       input.ExecutionMode,
		GroupJoinOperator:   input.GroupJoinOperator,
		MaxParallelism:      input.MaxParallelism,
		StopOnError:         input.StopOnError,
	}

	if err := s.repo.Create(rule); err != nil {
		return nil, err
	}

	s.logger.Info("RuleService", "Created rule '%s' (ID: %s)", rule.Name, rule.ID)
	return rule, nil
}

// GetByID retrieves a rule by ID with all nested data
func (s *RuleService) GetByID(id string) (*models.Rule, error) {
	return s.repo.GetByID(id)
}

// ReplaceLogic replaces a rule's condition groups and actions wholesale. Used
// by the rule editor to persist the filter and target-group actions.
func (s *RuleService) ReplaceLogic(ruleID string, groups []models.RuleConditionGroup, actions []models.RuleAction) error {
	if err := s.repo.ReplaceLogic(ruleID, groups, actions); err != nil {
		return err
	}
	s.logger.Info("RuleService", "Replaced logic for rule %s (%d groups, %d actions)", ruleID, len(groups), len(actions))
	return nil
}

// RuleListItem represents a rule in list views
type RuleListItem struct {
	ID             string
	Name           string
	Description    *string
	IsEnabled      bool
	ObjectType     string
	ScheduleID     *string
	LastRunUTC     *string
	LastRunResult  *string
	ConditionCount int
	ActionCount    int
}

// List retrieves rules for list view with per-rule condition/action counts.
func (s *RuleService) List(page, pageSize int) ([]RuleListItem, int, error) {
	offset := (page - 1) * pageSize
	rules, total, err := s.repo.List(offset, pageSize)
	if err != nil {
		return nil, 0, err
	}

	items := make([]RuleListItem, 0, len(rules))
	for i := range rules {
		r := &rules[i]
		cc, err := s.repo.CountConditionsForRule(r.ID)
		if err != nil {
			return nil, 0, err
		}
		ac, err := s.repo.CountActionsForRule(r.ID)
		if err != nil {
			return nil, 0, err
		}
		var lastRun *string
		if r.LastRunUTC != nil {
			v := r.LastRunUTC.UTC().Format("2006-01-02T15:04:05Z")
			lastRun = &v
		}
		items = append(items, RuleListItem{
			ID:             r.ID,
			Name:           r.Name,
			Description:    r.Description,
			IsEnabled:      r.IsEnabled,
			ObjectType:     r.ObjectType,
			ScheduleID:     r.ScheduleID,
			LastRunUTC:     lastRun,
			LastRunResult:  r.LastRunResult,
			ConditionCount: cc,
			ActionCount:    ac,
		})
	}
	return items, total, nil
}

// UpdateRuleInput represents updatable top-level rule fields.
type UpdateRuleInput struct {
	ID                  string
	Name                *string
	Description         *string
	IsEnabled           *bool
	ADConnectionID      *string
	ObjectType          *string
	BaseDNOverride      *string
	SearchScopeOverride *string
	ScheduleID          *string
	ExecutionMode       *string
	GroupJoinOperator   *string
	MaxParallelism      *int
	StopOnError         *bool
}

// Update modifies top-level rule fields.
func (s *RuleService) Update(input UpdateRuleInput) (*models.Rule, error) {
	rule, err := s.repo.GetByID(input.ID)
	if err != nil {
		return nil, err
	}
	if rule == nil {
		return nil, fmt.Errorf("rule not found")
	}

	if input.Name != nil {
		rule.Name = *input.Name
	}
	if input.Description != nil {
		rule.Description = input.Description
	}
	if input.IsEnabled != nil {
		rule.IsEnabled = *input.IsEnabled
	}
	if input.ADConnectionID != nil {
		rule.ADConnectionID = *input.ADConnectionID
	}
	if input.ObjectType != nil {
		rule.ObjectType = *input.ObjectType
	}
	if input.BaseDNOverride != nil {
		rule.BaseDNOverride = input.BaseDNOverride
	}
	if input.SearchScopeOverride != nil {
		rule.SearchScopeOverride = input.SearchScopeOverride
	}
	if input.ScheduleID != nil {
		rule.ScheduleID = input.ScheduleID
	}
	if input.ExecutionMode != nil {
		rule.ExecutionMode = *input.ExecutionMode
	}
	if input.GroupJoinOperator != nil {
		rule.GroupJoinOperator = *input.GroupJoinOperator
	}
	if input.MaxParallelism != nil {
		rule.MaxParallelism = input.MaxParallelism
	}
	if input.StopOnError != nil {
		rule.StopOnError = *input.StopOnError
	}

	if err := s.repo.Update(rule); err != nil {
		return nil, err
	}
	s.logger.Info("RuleService", "Updated rule '%s' (ID: %s)", rule.Name, rule.ID)
	return rule, nil
}

// Enable enables a rule
func (s *RuleService) Enable(id string) error {
	if err := s.repo.UpdateEnabled(id, true); err != nil {
		return err
	}
	s.logger.Info("RuleService", "Enabled rule (ID: %s)", id)
	return nil
}

// Disable disables a rule
func (s *RuleService) Disable(id string) error {
	if err := s.repo.UpdateEnabled(id, false); err != nil {
		return err
	}
	s.logger.Info("RuleService", "Disabled rule (ID: %s)", id)
	return nil
}

// Delete soft-deletes a rule.
func (s *RuleService) Delete(id string) error {
	if err := s.repo.SoftDelete(id); err != nil {
		return err
	}
	s.logger.Info("RuleService", "Deleted rule (ID: %s)", id)
	return nil
}

// ValidateRule validates a rule configuration
func (s *RuleService) ValidateRule(rule *models.Rule) []string {
	var errors []string

	if rule.Name == "" {
		errors = append(errors, "Name is required")
	}
	if rule.ADConnectionID == "" {
		errors = append(errors, "AD Connection is required")
	}
	if rule.ObjectType == "" {
		errors = append(errors, "Object Type is required")
	}
	if len(rule.ConditionGroups) == 0 {
		errors = append(errors, "At least one condition group is required")
	}
	if len(rule.Actions) == 0 {
		errors = append(errors, "At least one action is required")
	}

	// Validate condition groups have conditions
	for i, group := range rule.ConditionGroups {
		if len(group.Conditions) == 0 {
			errors = append(errors, fmt.Sprintf("Condition group %d has no conditions", i+1))
		}
	}

	return errors
}