geutebruck/geutebruck_app/lib/data/models/action_mapping_model.dart

import '../../domain/entities/action_mapping.dart';
import 'action_output.dart';

/// Data model for action mapping with JSON serialization
/// Handles conversion between API (snake_case) and domain entities
class ActionMappingModel {
  final String id;
  final String name;
  final String? description;
  final String inputAction;
  final Map<String, dynamic> inputParameters;
  final List<ActionOutput> outputActions;
  final String? geviscopeInstanceScope;
  final bool enabled;
  final int executionCount;
  final DateTime? lastExecuted;
  final DateTime createdAt;
  final DateTime updatedAt;
  final String createdBy;

  const ActionMappingModel({
    required this.id,
    required this.name,
    this.description,
    required this.inputAction,
    this.inputParameters = const {},
    required this.outputActions,
    this.geviscopeInstanceScope,
    this.enabled = true,
    this.executionCount = 0,
    this.lastExecuted,
    required this.createdAt,
    required this.updatedAt,
    required this.createdBy,
  });

  /// Create model from JSON (API response with snake_case keys)
  factory ActionMappingModel.fromJson(Map<String, dynamic> json) {
    // Convert ID from int to string if needed
    final id = json['id'].toString();

    // Extract input action and parameters from array of objects
    final inputActions = json['input_actions'] as List<dynamic>?;
    String inputAction;
    Map<String, dynamic> inputParameters;

    if (inputActions != null && inputActions.isNotEmpty) {
      final firstInput = inputActions[0] as Map<String, dynamic>;
      inputAction = firstInput['action'] as String;
      inputParameters = Map<String, dynamic>.from(firstInput['parameters'] as Map? ?? {});
    } else {
      inputAction = json['name'] as String;  // Fallback to name
      inputParameters = {};
    }

    // Extract output actions and parameters from array of objects
    final outputActionsRaw = json['output_actions'] as List<dynamic>?;
    final outputActions = outputActionsRaw != null
        ? outputActionsRaw.map((e) => ActionOutput.fromJson(e as Map<String, dynamic>)).toList()
        : <ActionOutput>[];

    return ActionMappingModel(
      id: id,
      name: json['name'] as String,
      description: json['description'] as String?,
      inputAction: inputAction,
      inputParameters: inputParameters,
      outputActions: outputActions,
      geviscopeInstanceScope: json['geviscope_instance_scope'] as String?,
      enabled: json['enabled'] as bool? ?? true,
      executionCount: json['execution_count'] as int? ?? 0,
      lastExecuted: json['last_executed'] != null
          ? DateTime.parse(json['last_executed'] as String)
          : null,
      createdAt: json['created_at'] != null
          ? DateTime.parse(json['created_at'] as String)
          : DateTime.now(),
      updatedAt: json['updated_at'] != null
          ? DateTime.parse(json['updated_at'] as String)
          : DateTime.now(),
      createdBy: json['created_by'] as String? ?? 'system',
    );
  }

  /// Convert model to JSON (for API requests with snake_case keys)
  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'name': name,
      if (description != null) 'description': description,
      // API expects input_actions as array of objects with parameters
      'input_actions': [
        {'action': inputAction, 'parameters': inputParameters}
      ],
      // API expects output_actions as array of objects with parameters
      'output_actions': outputActions.map((output) => output.toJson()).toList(),
      if (geviscopeInstanceScope != null)
        'geviscope_instance_scope': geviscopeInstanceScope,
      'enabled': enabled,
      'execution_count': executionCount,
      if (lastExecuted != null) 'last_executed': lastExecuted!.toIso8601String(),
      'created_at': createdAt.toIso8601String(),
      'updated_at': updatedAt.toIso8601String(),
      'created_by': createdBy,
    };
  }

  /// Convert to domain entity
  ActionMapping toEntity() {
    return ActionMapping(
      id: id,
      name: name,
      description: description,
      inputAction: inputAction,
      inputParameters: inputParameters,
      outputActions: outputActions,
      geviscopeInstanceScope: geviscopeInstanceScope,
      enabled: enabled,
      executionCount: executionCount,
      lastExecuted: lastExecuted,
      createdAt: createdAt,
      updatedAt: updatedAt,
      createdBy: createdBy,
    );
  }

  /// Create model from domain entity
  factory ActionMappingModel.fromEntity(ActionMapping mapping) {
    return ActionMappingModel(
      id: mapping.id,
      name: mapping.name,
      description: mapping.description,
      inputAction: mapping.inputAction,
      inputParameters: mapping.inputParameters,
      outputActions: mapping.outputActions,
      geviscopeInstanceScope: mapping.geviscopeInstanceScope,
      enabled: mapping.enabled,
      executionCount: mapping.executionCount,
      lastExecuted: mapping.lastExecuted,
      createdAt: mapping.createdAt,
      updatedAt: mapping.updatedAt,
      createdBy: mapping.createdBy,
    );
  }
}