import 'dart:async';

// Log seviyeleri
class LogLevel {
  final String name;

  const LogLevel._(this.name);

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

  @override
  String toString() => name;
}

// Global Event Sistemi
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, Event> _events = {};

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

  // Event sınıfını ekler
  void addEvent(Event event) {
    final eventName = event.name;

    if (_events.containsKey(eventName)) {
      _log("Event '$eventName' mevcut, argümanlar birleştirildi.", level: LogLevel.DEBUG);
      _events[eventName]?.mergeArguments(event.arguments);
    } else {
      _events[eventName] = event;
      _log("Yeni event eklendi: $eventName", level: LogLevel.INFO);
    }
  }

  // Event gönderme
  void sendEvent(dynamic eventIdentifier, [dynamic argument]) {
    String eventName;

    // Event enum veya string olarak tanımlandıysa çözümleme
    if (eventIdentifier is EventEnum) {
      eventName = eventIdentifier.toString().split('.').last;
    } else if (eventIdentifier is String) {
      eventName = eventIdentifier;
    } else {
      _log("Event '$eventIdentifier' geçerli değil!", level: LogLevel.ERROR);
      return;
    }

    if (!_events.containsKey(eventName)) {
      _log("Event '$eventName' tanımlı değil!", level: LogLevel.ERROR);
      throw Exception("Event '$eventName' tanımlı değil!");
    }

    final event = _events[eventName];

    // Argümanları birleştirerek gönderme
    event?.send(argument);
  }

  // Event dinleme
  StreamSubscription<Event> onEvent(dynamic eventIdentifier, void Function(Event) onData) {
    String eventName;

    // Event enum veya string olarak tanımlandıysa çözümleme
    if (eventIdentifier is EventEnum) {
      eventName = eventIdentifier.toString().split('.').last;
    } else if (eventIdentifier is String) {
      eventName = eventIdentifier;
    } else {
      _log("Event '$eventIdentifier' geçerli değil!", level: LogLevel.ERROR);
      throw Exception("Event '$eventIdentifier' geçerli değil!");
    }

    if (!_events.containsKey(eventName)) {
      _log("Event '$eventName' tanımlı değil!", level: LogLevel.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.arguments}", level: LogLevel.DEBUG);
      onData(event);
    });

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

  // Event duraklatma
  void pauseEvent(dynamic eventIdentifier) {
    String eventName;

    if (eventIdentifier is EventEnum) {
      eventName = eventIdentifier.toString().split('.').last;
    } else if (eventIdentifier is String) {
      eventName = eventIdentifier;
    } else {
      _log("Event '$eventIdentifier' geçerli değil!", level: LogLevel.ERROR);
      return;
    }

    if (_subscriptions[eventName]?.isPaused == true) {
      _log("Event '$eventName' zaten duraklatılmış.", level: LogLevel.WARNING);
      return;
    }

    _subscriptions[eventName]?.pause();
    _log("Event '$eventName' duraklatıldı.", level: LogLevel.INFO);
  }

  // Event'e devam ettirme
  void resumeEvent(dynamic eventIdentifier) {
    String eventName;

    if (eventIdentifier is EventEnum) {
      eventName = eventIdentifier.toString().split('.').last;
    } else if (eventIdentifier is String) {
      eventName = eventIdentifier;
    } else {
      _log("Event '$eventIdentifier' geçerli değil!", level: LogLevel.ERROR);
      return;
    }

    if (_subscriptions[eventName]?.isPaused == false) {
      _log("Event '$eventName' zaten aktif.", level: LogLevel.WARNING);
      return;
    }

    _subscriptions[eventName]?.resume();
    _log("Event '$eventName' devam ettirildi.", level: LogLevel.INFO);
  }

  // Event'i iptal etme
  void cancelEvent(dynamic eventIdentifier) {
    String eventName;

    if (eventIdentifier is EventEnum) {
      eventName = eventIdentifier.toString().split('.').last;
    } else if (eventIdentifier is String) {
      eventName = eventIdentifier;
    } else {
      _log("Event '$eventIdentifier' geçerli değil!", level: LogLevel.ERROR);
      return;
    }

    if (!_subscriptions.containsKey(eventName)) {
      _log("Event '$eventName' zaten iptal edilmiş veya bulunmuyor.", level: LogLevel.WARNING);
      return;
    }

    _subscriptions[eventName]?.cancel();
    _subscriptions.remove(eventName);
    _events.remove(eventName);
    _log("Event '$eventName' iptal edildi ve sistemden kaldırıldı.", level: LogLevel.INFO);
  }

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

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

// Event veri sınıfı
class Event {
  final String name;
  dynamic _arguments; // private variable for arguments

  Event(this.name, [this._arguments]);

  // Getter
  dynamic get arguments => _arguments;

  // Setter (Kopyalama işlemi ile)
  void mergeArguments(dynamic newArguments) {
    if (_arguments is Map && newArguments is Map) {
      _arguments = {..._arguments, ...newArguments};
    } else {
      _arguments = newArguments;
    }
  }

  // Event gönderme
  void send(dynamic argument) {
    mergeArguments(argument);
    GlobalEventSystem()._eventController.add(this);
  }
}

// Enum sınıfı - Event isimlerini içerir
enum EventEnum { loginEvent, logoutEvent, dataUpdateEvent }

// void main() {
//   final eventSystem = GlobalEventSystem();

//   // Event tanımlama
//   eventSystem.addEvent(Event('loginEvent', {'user': 'guest', 'timestamp': DateTime.now().toString()}));

//   // Event gönderme
//   eventSystem.sendEvent('loginEvent', {'user': 'john.doe'});

//   // Enum ile event gönderme
//   eventSystem.sendEvent(EventEnum.loginEvent, {'user': 'jane.doe'});

//   // Event dinleme
//   eventSystem.onEvent(EventEnum.loginEvent, (event) {
//     print('Event tetiklendi: ${event.name}, Argüman: ${event.arguments}');
//   });
// }