import {Ice} from 'ice';
import '../Ice/BuiltinSequences';

declare module './Ice.ns' {
  namespace Ice {
    type LogMessageTypeName =
      | 'PrintMessage'
      | 'TraceMessage'
      | 'WarningMessage'
      | 'ErrorMessage';

    /**
     * An enumeration representing the different types of log messages.
     */
    class LogMessageType<
      Name extends LogMessageTypeName = LogMessageTypeName
    > extends Ice.EnumBase<Name> {
      /**
       * The {@link Logger} received a print message.
       */
      static PrintMessage: LogMessageType<'PrintMessage'>;

      /**
       * The {@link Logger} received a trace message.
       */
      static TraceMessage: LogMessageType<'TraceMessage'>;

      /**
       * The {@link Logger} received a warning message.
       */
      static WarningMessage: LogMessageType<'WarningMessage'>;

      /**
       * The {@link Logger} received an error message.
       */
      static ErrorMessage: LogMessageType<'ErrorMessage'>;
    }

    /**
     * A sequence of {@link LogMessageType}
     */
    type LogMessageTypeSeq = Array<LogMessageType>;

    /**
     * A complete log message.
     */
    class LogMessage implements Ice.Struct {
      constructor(
        type?: LogMessageType,
        timestamp?: Ice.Long,
        traceCategory?: string,
        message?: string,
      );

      /**
       * The type of message sent to the {@link Logger}.
       */
      type: LogMessageType;

      /**
       * The date and time when the {@link Logger} received this message, expressed
       * as the number of microseconds since the Unix Epoch (00:00:00 UTC on 1 January 1970)
       */
      timestamp: Ice.Long;

      /**
       * For a message of type trace, the trace category of this log message;
       * otherwise, the empty string.
       */
      traceCategory: string;

      /**
       * The log message itself.
       */
      message: string;

      clone(): this;
      equals(other: this): boolean;
      hashCode(): number;
    }

    /**
     * A sequence of {@link LogMessage}.
     */
    type LogMessageSeq = Array<LogMessage>;

    /**
     * The Ice remote logger interface. An application can implement a
     * RemoteLogger to receive the log messages sent to the local {@link Logger}
     * of another Ice application.
     */
    abstract class RemoteLogger extends Ice.Object {
      /**
       * init is called by {@link LoggerAdmin#attachRemoteLogger} when a
       * RemoteLogger proxy is attached.
       *
       * @param prefix The prefix of the associated local {@link Logger}
       *
       * @param logMessages Old log messages generated before "now".
       *
       * @see LoggerAdmin#attachRemoteLogger
       */
      abstract init(
        prefix: string,
        logMessages: LogMessageSeq,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * Log a {@link LogMessage}. Note that log may be called by {@link LoggerAdmin}
       * before {@link RemoteLogger#init}.
       *
       * @param message The message to log.
       *
       * @see Logger
       */
      abstract log(
        message: LogMessage,
        current: Ice.Current,
      ): Ice.OperationResult<void>;
    }

    /**
     * The Ice remote logger interface. An application can implement a
     * RemoteLogger to receive the log messages sent to the local {@link Logger}
     * of another Ice application.
     */
    class RemoteLoggerPrx extends Ice.ObjectPrx {
      /**
       * init is called by {@link LoggerAdmin#attachRemoteLogger} when a
       * RemoteLogger proxy is attached.
       *
       * @param prefix The prefix of the associated local {@link Logger}
       *
       * @param logMessages Old log messages generated before "now".
       *
       * @see LoggerAdmin#attachRemoteLogger
       */
      init(
        prefix: string,
        logMessages: LogMessageSeq,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * Log a {@link LogMessage}. Note that log may be called by {@link LoggerAdmin}
       * before {@link RemoteLogger#init}.
       *
       * @param message The message to log.
       *
       * @see Logger
       */
      log(message: LogMessage, ctx?: Ice.Context): Ice.AsyncResult<void>;
    }

    /**
     * An exception thrown by {@link LoggerAdmin#attachRemoteLogger} to report
     * that the provided {@link RemoteLogger} was previously attached to this
     * {@link LoggerAdmin}.
     */
    class RemoteLoggerAlreadyAttachedException extends Ice.UserException {}

    /**
     * The interface of the admin object that allows an Ice application the attach its
     * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
     */
    abstract class LoggerAdmin extends Ice.Object {
      /**
       * attachRemoteLogger is called to attach a {@link RemoteLogger} object to
       * the local {@link Logger}.
       * attachRemoteLogger calls init on the provided {@link RemoteLogger} proxy.
       *
       * @param prx A proxy to the remote logger.
       *
       * @param messageTypes The list of message types that the remote logger wishes to receive.
       * An empty list means no filtering (send all message types).
       *
       * @param traceCategories The categories of traces that the remote logger wishes to receive.
       * This parameter is ignored if messageTypes is not empty and does not include trace.
       * An empty list means no filtering (send all trace categories).
       *
       * @param messageMax The maximum number of log messages (of all types) to be provided
       * to {@link RemoteLogger#init}. A negative value requests all messages available.
       *
       * @throws RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
       * attached to this admin object.
       */
      abstract attachRemoteLogger(
        prx: RemoteLoggerPrx | null,
        messageTypes: LogMessageTypeSeq,
        traceCategories: StringSeq,
        messageMax: number,
        current: Ice.Current,
      ): Ice.OperationResult<void>;

      /**
       * detachRemoteLogger is called to detach a {@link RemoteLogger} object from
       * the local {@link Logger}.
       *
       * @param prx A proxy to the remote logger.
       *
       * @return True if the provided remote logger proxy was detached, and false otherwise.
       */
      abstract detachRemoteLogger(
        prx: RemoteLoggerPrx | null,
        current: Ice.Current,
      ): Ice.OperationResult<boolean>;

      /**
       * getLog retrieves log messages recently logged.
       *
       * @param messageTypes The list of message types that the caller wishes to receive.
       * An empty list means no filtering (send all message types).
       *
       * @param traceCategories The categories of traces that caller wish to receive.
       * This parameter is ignored if messageTypes is not empty and does not include trace.
       * An empty list means no filtering (send all trace categories).
       *
       * @param messageMax The maximum number of log messages (of all types) to be returned.
       * A negative value requests all messages available.
       *
       * @param prefix The prefix of the associated local {@link Logger}.
       *
       * @return The Log messages.
       */
      abstract getLog(
        messageTypes: LogMessageTypeSeq,
        traceCategories: StringSeq,
        messageMax: number,
        current: Ice.Current,
      ): Ice.OperationResult<[LogMessageSeq, string]>;
    }

    /**
     * The interface of the admin object that allows an Ice application the attach its
     * {@link RemoteLogger} to the {@link Logger} of this admin object's Ice communicator.
     */
    class LoggerAdminPrx extends Ice.ObjectPrx {
      /**
       * attachRemoteLogger is called to attach a {@link RemoteLogger} object to
       * the local {@link Logger}.
       * attachRemoteLogger calls init on the provided {@link RemoteLogger} proxy.
       *
       * @param prx A proxy to the remote logger.
       *
       * @param messageTypes The list of message types that the remote logger wishes to receive.
       * An empty list means no filtering (send all message types).
       *
       * @param traceCategories The categories of traces that the remote logger wishes to receive.
       * This parameter is ignored if messageTypes is not empty and does not include trace.
       * An empty list means no filtering (send all trace categories).
       *
       * @param messageMax The maximum number of log messages (of all types) to be provided
       * to {@link RemoteLogger#init}. A negative value requests all messages available.
       *
       * @throws RemoteLoggerAlreadyAttachedException Raised if this remote logger is already
       * attached to this admin object.
       */
      attachRemoteLogger(
        prx: RemoteLoggerPrx | null,
        messageTypes: LogMessageTypeSeq,
        traceCategories: StringSeq,
        messageMax: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<void>;

      /**
       * detachRemoteLogger is called to detach a {@link RemoteLogger} object from
       * the local {@link Logger}.
       *
       * @param prx A proxy to the remote logger.
       *
       * @return True if the provided remote logger proxy was detached, and false otherwise.
       */
      detachRemoteLogger(
        prx: RemoteLoggerPrx | null,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<boolean>;

      /**
       * getLog retrieves log messages recently logged.
       *
       * @param messageTypes The list of message types that the caller wishes to receive.
       * An empty list means no filtering (send all message types).
       *
       * @param traceCategories The categories of traces that caller wish to receive.
       * This parameter is ignored if messageTypes is not empty and does not include trace.
       * An empty list means no filtering (send all trace categories).
       *
       * @param messageMax The maximum number of log messages (of all types) to be returned.
       * A negative value requests all messages available.
       *
       * @param prefix The prefix of the associated local {@link Logger}.
       *
       * @return The Log messages.
       */
      getLog(
        messageTypes: LogMessageTypeSeq,
        traceCategories: StringSeq,
        messageMax: number,
        ctx?: Ice.Context,
      ): Ice.AsyncResult<[LogMessageSeq, string]>;
    }
  }
}
export {Ice} from './Ice.ns';