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

import 'package:equatable/equatable.dart';

/// Model representing an action template from the API
/// Used for dynamic form generation when selecting action types
class ActionTemplate extends Equatable {
  final String actionName;
  final List<String> parameters;
  final String description;
  final String category;
  final bool requiredCaption;
  final bool supportsDelay;
  final Map<String, String>? parameterTypes;

  const ActionTemplate({
    required this.actionName,
    required this.parameters,
    required this.description,
    required this.category,
    this.requiredCaption = true,
    this.supportsDelay = true,
    this.parameterTypes,
  });

  factory ActionTemplate.fromJson(Map<String, dynamic> json) {
    return ActionTemplate(
      actionName: json['action_name'] as String,
      parameters: (json['parameters'] as List<dynamic>)
          .map((e) => e.toString())
          .toList(),
      description: json['description'] as String,
      category: json['category'] as String,
      requiredCaption: json['required_caption'] as bool? ?? true,
      supportsDelay: json['supports_delay'] as bool? ?? true,
      parameterTypes: json['parameter_types'] != null
          ? Map<String, String>.from(json['parameter_types'] as Map)
          : null,
    );
  }

  Map<String, dynamic> toJson() {
    return {
      'action_name': actionName,
      'parameters': parameters,
      'description': description,
      'category': category,
      'required_caption': requiredCaption,
      'supports_delay': supportsDelay,
      if (parameterTypes != null) 'parameter_types': parameterTypes,
    };
  }

  @override
  List<Object?> get props => [
        actionName,
        parameters,
        description,
        category,
        requiredCaption,
        supportsDelay,
        parameterTypes,
      ];
}

/// Model representing a server (G-Core or GeViScope)
class ServerInfo extends Equatable {
  final String id;
  final String alias;
  final bool enabled;

  const ServerInfo({
    required this.id,
    required this.alias,
    required this.enabled,
  });

  factory ServerInfo.fromJson(Map<String, dynamic> json) {
    return ServerInfo(
      id: json['id'].toString(),
      alias: json['alias'] as String,
      enabled: json['enabled'] as bool,
    );
  }

  Map<String, dynamic> toJson() {
    return {
      'id': id,
      'alias': alias,
      'enabled': enabled,
    };
  }

  @override
  List<Object?> get props => [id, alias, enabled];
}

/// Model for servers information
class ServersInfo extends Equatable {
  final List<ServerInfo> gcoreServers;
  final List<ServerInfo> gscServers;

  const ServersInfo({
    required this.gcoreServers,
    required this.gscServers,
  });

  factory ServersInfo.fromJson(Map<String, dynamic> json) {
    return ServersInfo(
      gcoreServers: (json['gcore_servers'] as List<dynamic>?)
              ?.map((e) => ServerInfo.fromJson(e as Map<String, dynamic>))
              .toList() ??
          [],
      gscServers: (json['gsc_servers'] as List<dynamic>?)
              ?.map((e) => ServerInfo.fromJson(e as Map<String, dynamic>))
              .toList() ??
          [],
    );
  }

  @override
  List<Object?> get props => [gcoreServers, gscServers];
}

/// Model for action categories response
class ActionCategoriesResponse extends Equatable {
  final Map<String, List<String>> categories;
  final int totalCategories;
  final int totalActions;
  final ServersInfo servers;
  final List<String> gscSpecificCategories;

  const ActionCategoriesResponse({
    required this.categories,
    required this.totalCategories,
    required this.totalActions,
    required this.servers,
    this.gscSpecificCategories = const [],
  });

  factory ActionCategoriesResponse.fromJson(Map<String, dynamic> json) {
    final categoriesMap = json['categories'] as Map<String, dynamic>;
    final categories = categoriesMap.map(
      (key, value) => MapEntry(
        key,
        (value as List<dynamic>).map((e) => e.toString()).toList(),
      ),
    );

    return ActionCategoriesResponse(
      categories: categories,
      totalCategories: json['total_categories'] as int,
      totalActions: json['total_actions'] as int,
      servers: ServersInfo.fromJson(json['servers'] as Map<String, dynamic>? ?? {}),
      gscSpecificCategories: (json['gsc_specific_categories'] as List<dynamic>?)
              ?.map((e) => e.toString())
              .toList() ??
          [],
    );
  }

  /// Get all action names sorted by category
  List<String> getActionsForCategory(String category) {
    return categories[category] ?? [];
  }

  /// Get list of all category names sorted
  List<String> get categoryNames {
    final names = categories.keys.toList();
    names.sort();
    return names;
  }

  @override
  List<Object?> get props => [categories, totalCategories, totalActions, servers, gscSpecificCategories];
}