onRuleExecutionCompleted method

Implementation

@override
void onRuleExecutionCompleted(RulesExecutionResult result) {
  if (!_isCapturing) return;

  final eventId = _generateEventId(result.context);
  final now = DateTime.now();

  // Buscar evento activo
  final eventExecution = _activeEvents[eventId];
  if (eventExecution == null) {
    ObslyLogger.debug(
        'Rules Monitor: Creating missing event for completion: ${result.ruleKey}');

    // Crear evento si no existe (fallback para reglas que no notificaron inicio)
    final fallbackEvent = RulesEventExecution(
      eventId: eventId,
      timestamp: now,
      eventType: result.eventType,
      eventDescription:
          _generateEventDescription(result.context, result.eventType),
      eventContext: Map<String, dynamic>.from(result.context),
      ruleExecutions: [],
      startTime: now,
    );

    // Agregar regla completada
    fallbackEvent.addRuleExecution(RuleExecution(
      ruleKey: result.ruleKey,
      ruleName: result.ruleName,
      status: result.success
          ? RulesExecutionStatus.success
          : RulesExecutionStatus.error,
      startTime: result.timestamp,
      endTime: now,
      result: result,
      error: result.error,
    ));

    // Finalizar evento inmediatamente y agregarlo al historial
    final finalEvent = RulesEventExecution(
      eventId: fallbackEvent.eventId,
      timestamp: fallbackEvent.timestamp,
      eventType: fallbackEvent.eventType,
      eventDescription: fallbackEvent.eventDescription,
      eventContext: fallbackEvent.eventContext,
      ruleExecutions: List.from(fallbackEvent.ruleExecutions),
      startTime: fallbackEvent.startTime,
      endTime: now,
    );

    _addEventToHistory(finalEvent);
    _updateMetrics(finalEvent);
    _eventExecutionStreamController.add(finalEvent);
    _broadcastMetrics();

    ObslyLogger.debug(
        '✅ Rules Monitor: Fallback event completed - ${result.ruleKey}');
    return;
  }

  // Encontrar y actualizar la regla correspondiente
  final ruleIndex = eventExecution.ruleExecutions.indexWhere((rule) =>
      rule.ruleKey == result.ruleKey &&
      rule.status == RulesExecutionStatus.started);

  if (ruleIndex != -1) {
    // Reemplazar regla existente con resultado completo
    eventExecution.ruleExecutions[ruleIndex] = RuleExecution(
      ruleKey: result.ruleKey,
      ruleName: result.ruleName,
      status: result.success
          ? RulesExecutionStatus.success
          : RulesExecutionStatus.error,
      startTime: eventExecution.ruleExecutions[ruleIndex].startTime,
      endTime: now,
      result: result,
      error: result.error,
    );
  } else {
    // Agregar nueva regla si no se encontró (fallback)
    eventExecution.addRuleExecution(RuleExecution(
      ruleKey: result.ruleKey,
      ruleName: result.ruleName,
      status: result.success
          ? RulesExecutionStatus.success
          : RulesExecutionStatus.error,
      startTime: result.timestamp,
      endTime: now,
      result: result,
      error: result.error,
    ));
  }

  // Verificar si todas las reglas han terminado para finalizar el evento
  final allCompleted = eventExecution.ruleExecutions.every((rule) =>
      rule.status == RulesExecutionStatus.success ||
      rule.status == RulesExecutionStatus.error);

  if (allCompleted) {
    // Finalizar evento y mover a historial
    final finalEvent = RulesEventExecution(
      eventId: eventExecution.eventId,
      timestamp: eventExecution.timestamp,
      eventType: eventExecution.eventType,
      eventDescription: eventExecution.eventDescription,
      eventContext: eventExecution.eventContext,
      ruleExecutions: List.from(eventExecution.ruleExecutions),
      startTime: eventExecution.startTime,
      endTime: now,
    );

    _addEventToHistory(finalEvent);
    _activeEvents.remove(eventId);
    _updateMetrics(finalEvent);
    _eventExecutionStreamController.add(finalEvent);
  } else {
    // Emitir evento actualizado
    _eventExecutionStreamController.add(eventExecution);
  }

  _broadcastMetrics();

  ObslyLogger.debug(
      '✅ Rules Monitor: Rule execution completed - ${result.ruleKey} for event $eventId (${result.success ? 'SUCCESS' : 'ERROR'})');
}