import 'dart:async';

class GlobalEventSystem {
  static final GlobalEventSystem _instance = GlobalEventSystem._internal();

  factory GlobalEventSystem() {
    return _instance;
  }

  GlobalEventSystem._internal();

  final _eventController = StreamController<Event>.broadcast();
  final Map<String, StreamSubscription<Event>> _subscriptions = {};
  final Map<String, dynamic> _eventsWithDefaultArguments = {};

  /// Log seviyeleri
  static const LogLevel DEBUG = LogLevel._('DEBUG');
  static const LogLevel INFO = LogLevel._('INFO');
  static const LogLevel WARNING = LogLevel._('WARNING');
  static const LogLevel ERROR = LogLevel._('ERROR');

  /// Loglama fonksiyonu
  void _log(String message, {LogLevel level = INFO}) {
    final timestamp = DateTime.now().toIso8601String();
    print('[$timestamp] [${level.name}] $message');
  }

  /// Yeni bir event ekler ve default argüman tanımlar veya var olanla birleştirir
  void addEvent(String eventName, {dynamic defaultArgument}) {
    if (_eventsWithDefaultArguments.containsKey(eventName)) {
      final existingArgs = _eventsWithDefaultArguments[eventName];
      if (existingArgs is Map && defaultArgument is Map) {
        _eventsWithDefaultArguments[eventName] = {
          ...existingArgs,
          ...defaultArgument,
        };
      } else {
        _eventsWithDefaultArguments[eventName] = defaultArgument;
      }
      _log("Event '$eventName' mevcut, argümanlar birleştirildi.", level: DEBUG);
    } else {
      _eventsWithDefaultArguments[eventName] = defaultArgument;
      _log("Yeni event eklendi: $eventName", level: INFO);
    }
  }

  /// Event gönderir (default ve verilen argümanları birleştirerek)
  void sendEvent(String eventName, [dynamic argument]) {
    if (!_eventsWithDefaultArguments.containsKey(eventName)) {
      _log("Event '$eventName' tanımlı değil!", level: ERROR);
      throw Exception("Event '$eventName' tanımlı değil!");
    }

    final defaultArg = _eventsWithDefaultArguments[eventName];
    dynamic mergedArgument;

    if (defaultArg is Map && argument is Map) {
      mergedArgument = {...defaultArg, ...argument};
    } else {
      mergedArgument = argument ?? defaultArg;
    }

    // Argümanlardaki fonksiyonları çalıştırma
    if (mergedArgument is Map) {
      mergedArgument = _executeFunctionsInArguments(mergedArgument);
    }

    _log("Event gönderiliyor: $eventName, Argüman: $mergedArgument", level: INFO);
    _eventController.add(Event(eventName, mergedArgument));
  }

  /// Argümanlardaki fonksiyonları çalıştırma
  Map _executeFunctionsInArguments(Map arguments) {
    final updatedArguments = <String, dynamic>{};

    arguments.forEach((key, value) {
      if (value is Function) {
        updatedArguments[key] = value();
        _log("Fonksiyon çalıştırıldı: $key -> ${updatedArguments[key]}", level: DEBUG);
      } else {
        updatedArguments[key] = value;
      }
    });

    return updatedArguments;
  }

  /// Event dinleme
  StreamSubscription<Event> onEvent(String eventName, void Function(Event) onData) {
    if (!_eventsWithDefaultArguments.containsKey(eventName)) {
      _log("Event '$eventName' tanımlı değil!", level: ERROR);
      throw Exception("Event '$eventName' tanımlı değil!");
    }

    final subscription = _eventController.stream.where((e) => e.name == eventName).listen((event) {
      _log("Event tetiklendi: ${event.name}, Argüman: ${event.argument}", level: DEBUG);
      onData(event);
    });

    _subscriptions[eventName] = subscription;
    _log("Event dinleniyor: $eventName", level: INFO);
    return subscription;
  }

  /// Event duraklatma
  void pauseEvent(String eventName) {
    if (_subscriptions[eventName]?.isPaused == true) {
      _log("Event '$eventName' zaten duraklatılmış.", level: WARNING);
      return;
    }
    _subscriptions[eventName]?.pause();
    _log("Event '$eventName' duraklatıldı.", level: INFO);
  }

  /// Event'e devam ettirme
  void resumeEvent(String eventName) {
    if (_subscriptions[eventName]?.isPaused == false) {
      _log("Event '$eventName' zaten aktif.", level: WARNING);
      return;
    }
    _subscriptions[eventName]?.resume();
    _log("Event '$eventName' devam ettirildi.", level: INFO);
  }

  /// Event'i iptal etme
  void cancelEvent(String eventName) {
    if (!_subscriptions.containsKey(eventName)) {
      _log("Event '$eventName' zaten iptal edilmiş veya bulunmuyor.", level: WARNING);
      return;
    }
    _subscriptions[eventName]?.cancel();
    _subscriptions.remove(eventName);
    _eventsWithDefaultArguments.remove(eventName);
    _log("Event '$eventName' iptal edildi ve sistemden kaldırıldı.", level: INFO);
  }

  /// Tüm event'leri iptal etme
  void cancelAllEvents() {
    for (final subscription in _subscriptions.values) {
      subscription.cancel();
    }
    _subscriptions.clear();
    _eventsWithDefaultArguments.clear();
    _log("Tüm event'ler iptal edildi ve sistem sıfırlandı.", level: WARNING);
  }

  /// Tanımlı event'leri listeleme
  List<String> listEvents() => _eventsWithDefaultArguments.keys.toList();

  void dispose() {
    _eventController.close();
    cancelAllEvents();
    _log("Global Event System tamamen kapatıldı.", level: ERROR);
  }
}

class Event {
  final String name;
  final dynamic argument;

  Event(this.name, [this.argument]);
}

/// Log seviyeleri için sınıf
class LogLevel {
  final String name;

  const LogLevel._(this.name);

  @override
  String toString() => name;
}