// Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'package:logging/logging.dart';
import 'package:observatory/models.dart' as M;
import 'package:observatory/service.dart' as S;

class VMUpdateEvent implements M.VMUpdateEvent {
  final DateTime timestamp;
  final M.VMRef vm;
  VMUpdateEvent(this.timestamp, this.vm);
}

class IsolateStartEvent implements M.IsolateStartEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  IsolateStartEvent(this.timestamp, this.isolate);
}

class IsolateRunnableEvent implements M.IsolateRunnableEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  IsolateRunnableEvent(this.timestamp, this.isolate);
}

class IsolateExitEvent implements M.IsolateExitEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  IsolateExitEvent(this.timestamp, this.isolate);
}

class IsolateUpdateEvent implements M.IsolateUpdateEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  IsolateUpdateEvent(this.timestamp, this.isolate);
}

class IsolateReloadEvent implements M.IsolateReloadEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.ErrorRef error;
  IsolateReloadEvent(this.timestamp, this.isolate, this.error);
}

class ServiceExtensionAddedEvent implements M.ServiceExtensionAddedEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final String extensionRPC;
  ServiceExtensionAddedEvent(this.timestamp, this.isolate, this.extensionRPC);
}

class DebuggerSettingsUpdateEvent implements M.DebuggerSettingsUpdateEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  DebuggerSettingsUpdateEvent(this.timestamp, this.isolate);
}

class PauseStartEvent implements M.PauseStartEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  PauseStartEvent(this.timestamp, this.isolate);
}

class PauseExitEvent implements M.PauseExitEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  PauseExitEvent(this.timestamp, this.isolate);
}

class PauseBreakpointEvent implements M.PauseBreakpointEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final Iterable<M.Breakpoint> pauseBreakpoints;
  final M.Frame topFrame;
  final bool atAsyncSuspension;

  /// [optional]
  final M.Breakpoint? breakpoint;
  PauseBreakpointEvent(
      this.timestamp,
      this.isolate,
      Iterable<M.Breakpoint> pauseBreakpoints,
      this.topFrame,
      this.atAsyncSuspension,
      [this.breakpoint])
      : pauseBreakpoints = new List.unmodifiable(pauseBreakpoints) {}
}

class PauseInterruptedEvent implements M.PauseInterruptedEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Frame? topFrame;
  final bool atAsyncSuspension;
  PauseInterruptedEvent(
      this.timestamp, this.isolate, this.topFrame, this.atAsyncSuspension);
}

class PausePostRequestEvent implements M.PausePostRequestEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Frame? topFrame;
  final bool atAsyncSuspension;
  PausePostRequestEvent(
      this.timestamp, this.isolate, this.topFrame, this.atAsyncSuspension);
}

class PauseExceptionEvent implements M.PauseExceptionEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Frame topFrame;
  final M.InstanceRef exception;
  PauseExceptionEvent(
      this.timestamp, this.isolate, this.topFrame, this.exception);
}

class ResumeEvent implements M.ResumeEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Frame? topFrame;
  ResumeEvent(this.timestamp, this.isolate, this.topFrame);
}

class BreakpointAddedEvent implements M.BreakpointAddedEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Breakpoint breakpoint;
  BreakpointAddedEvent(this.timestamp, this.isolate, this.breakpoint);
}

class BreakpointResolvedEvent implements M.BreakpointResolvedEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Breakpoint breakpoint;
  BreakpointResolvedEvent(this.timestamp, this.isolate, this.breakpoint);
}

class BreakpointRemovedEvent implements M.BreakpointRemovedEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.Breakpoint breakpoint;
  BreakpointRemovedEvent(this.timestamp, this.isolate, this.breakpoint);
}

class InspectEvent implements M.InspectEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final M.InstanceRef inspectee;
  InspectEvent(this.timestamp, this.isolate, this.inspectee);
}

class NoneEvent implements M.NoneEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  NoneEvent(this.timestamp, this.isolate);
}

class GCEvent implements M.GCEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  GCEvent(this.timestamp, this.isolate);
}

class LoggingEvent implements M.LoggingEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final Map logRecord;
  LoggingEvent(this.timestamp, this.isolate, this.logRecord);
}

class ExtensionEvent implements M.ExtensionEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final String extensionKind;
  final M.ExtensionData extensionData;
  ExtensionEvent(
      this.timestamp, this.isolate, this.extensionKind, this.extensionData);
}

class TimelineEventsEvent implements M.TimelineEventsEvent {
  final DateTime timestamp;
  final M.IsolateRef isolate;
  final Iterable<M.TimelineEvent> timelineEvents;
  TimelineEventsEvent(
      this.timestamp, this.isolate, Iterable<M.TimelineEvent> timelineEvents)
      : timelineEvents = new List.unmodifiable(timelineEvents) {}
}

class ConnectionClosedEvent implements M.ConnectionClosedEvent {
  final DateTime timestamp;
  final String reason;
  ConnectionClosedEvent(this.timestamp, this.reason);
}

class ServiceRegisteredEvent implements M.ServiceRegisteredEvent {
  final DateTime timestamp;
  final String service;
  final String method;
  final String alias;
  ServiceRegisteredEvent(this.timestamp, this.service, this.method, this.alias);
}

class ServiceUnregisteredEvent implements M.ServiceUnregisteredEvent {
  final DateTime timestamp;
  final String service;
  final String method;
  ServiceUnregisteredEvent(this.timestamp, this.service, this.method);
}

M.Event? createEventFromServiceEvent(S.ServiceEvent event) {
  switch (event.kind) {
    case S.ServiceEvent.kVMUpdate:
      return new VMUpdateEvent(event.timestamp!, event.vm);
    case S.ServiceEvent.kIsolateStart:
      return new IsolateStartEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kIsolateRunnable:
      return new IsolateRunnableEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kIsolateUpdate:
      return new IsolateUpdateEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kIsolateReload:
      return new IsolateReloadEvent(
          event.timestamp!, event.isolate!, event.error!);
    case S.ServiceEvent.kIsolateExit:
      return new IsolateExitEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kBreakpointAdded:
      return new BreakpointAddedEvent(
          event.timestamp!, event.isolate!, event.breakpoint!);
    case S.ServiceEvent.kBreakpointResolved:
      return new BreakpointResolvedEvent(
          event.timestamp!, event.isolate!, event.breakpoint!);
    case S.ServiceEvent.kBreakpointRemoved:
      return new BreakpointRemovedEvent(
          event.timestamp!, event.isolate!, event.breakpoint!);
    case S.ServiceEvent.kDebuggerSettingsUpdate:
      return new DebuggerSettingsUpdateEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kResume:
      return new ResumeEvent(event.timestamp!, event.isolate!, event.topFrame);
    case S.ServiceEvent.kPauseStart:
      return new PauseStartEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kPauseExit:
      return new PauseExitEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kPausePostRequest:
      return new PausePostRequestEvent(event.timestamp!, event.isolate!,
          event.topFrame, event.atAsyncSuspension!);
    case S.ServiceEvent.kPauseBreakpoint:
      return new PauseBreakpointEvent(
          event.timestamp!,
          event.isolate!,
          event.pauseBreakpoints!,
          event.topFrame!,
          event.atAsyncSuspension!,
          event.breakpoint);
    case S.Isolate.kLoggingStream:
      return new LoggingEvent(
          event.timestamp!, event.isolate!, event.logRecord!);
    case S.ServiceEvent.kPauseInterrupted:
      return new PauseInterruptedEvent(event.timestamp!, event.isolate!,
          event.topFrame, event.atAsyncSuspension!);
    case S.ServiceEvent.kPauseException:
      return new PauseExceptionEvent(
          event.timestamp!, event.isolate!, event.topFrame!, event.exception!);
    case S.ServiceEvent.kInspect:
      return new InspectEvent(
          event.timestamp!, event.isolate!, event.inspectee!);
    case S.ServiceEvent.kGC:
      return new GCEvent(event.timestamp!, event.isolate!);
    case S.ServiceEvent.kServiceRegistered:
      return new ServiceRegisteredEvent(
          event.timestamp!, event.service!, event.method!, event.alias!);
    case S.ServiceEvent.kServiceUnregistered:
      return new ServiceUnregisteredEvent(
          event.timestamp!, event.service!, event.method!);
    case S.ServiceEvent.kNone:
      return new NoneEvent(event.timestamp!, event.isolate!);
    default:
      // Ignore unrecognized events.
      Logger.root.severe('Unrecognized event: $event');
      return null;
  }
}