import {Ice} from 'ice';
import '../Ice/BuiltinSequences';
import '../Ice/Current';
import {IceGrid} from '../IceGrid/Admin';

declare module './IceGrid.ns' {
  namespace IceGrid {
    /**
     * The ReplicaGroupFilter is used by IceGrid to filter adapters
     * returned to the client when it resolves a filtered replica group.
     *
     * IceGrid provides the list of available adapters. The implementation
     * of this method can use the provided context and connection to
     * filter and return the filtered set of adapters.
     */
    interface ReplicaGroupFilter {
      /**
       * Filter the the given set of adapters.
       *
       * @param replicaGroupId The replica group ID.
       *
       * @param adapterIds The adpater IDs to filter.
       *
       * @param con The connection from the Ice client which is
       * resolving the replica group endpoints.
       *
       * @param ctx The context from the Ice client which is resolving
       * the replica group endpoints.
       *
       * @return The filtered adapter IDs.
       */
      filter(
        replicaGroupId: string,
        adapterIds: Ice.StringSeq,
        con: Ice.Connection,
        ctx: Ice.Context,
      ): Ice.StringSeq;
    }

    /**
     * The TypeFilter is used by IceGrid to filter well-known proxies
     * returned to the client when it searches a well-known object by
     * type.
     *
     * IceGrid provides the list of available proxies. The implementation
     * of this method can use the provided context and connection to
     * filter and return the filtered set of proxies.
     */
    interface TypeFilter {
      /**
       * Filter the the given set of proxies.
       *
       * @param type The type.
       *
       * @param proxies The proxies to filter.
       *
       * @param con The connection from the Ice client which is
       * looking up well-known objects by type.
       *
       * @param ctx The context from the Ice client which is looking up
       * well-known objects by type.
       *
       * @return The filtered proxies.
       */
      filter(
        type: string,
        proxies: Ice.ObjectProxySeq,
        con: Ice.Connection,
        ctx: Ice.Context,
      ): Ice.ObjectProxySeq;
    }

    /**
     * The RegistryPluginFacade is implemented by IceGrid and can be used
     * by plugins and filter implementations to retrieve information from
     * IceGrid about the well-known objects or adapters. It's also used to
     * register/unregister replica group and type filters.
     */
    interface RegistryPluginFacade {
      /**
       * Get an application descriptor.
       *
       * @param name The application name.
       *
       * @return The application descriptor.
       *
       * @throws ApplicationNotExistException Raised if the application
       * doesn't exist.
       */
      getApplicationInfo(name: string): ApplicationInfo;

      /**
       * Get the server information for the server with the given id.
       *
       * @param id The server id.
       *
       * @throws ServerNotExistException Raised if the server doesn't exist.
       *
       * @return The server information.
       */
      getServerInfo(id: string): ServerInfo;

      /**
       * Get the ID of the server to which the given adapter belongs.
       *
       * @param adapterId The adapter ID.
       *
       * @return The server ID or the empty string if the given
       * identifier is not associated to an object adapter defined with
       * an application descriptor.
       *
       * @throws AdapterNotExistException Raised if the adapter doesn't
       * exist.
       */
      getAdapterServer(adapterId: string): string;

      /**
       * Get the name of the application to which the given adapter belongs.
       *
       * @param adapterId The adapter ID.
       *
       * @return The application name or the empty string if the given
       * identifier is not associated to a replica group or object
       * adapter defined with an application descriptor.
       *
       * @throws AdapterNotExistException Raised if the adapter doesn't
       * exist.
       */
      getAdapterApplication(adapterId: string): string;

      /**
       * Get the name of the node to which the given adapter belongs.
       *
       * @param adapterId The adapter ID.
       *
       * @return The node name or the empty string if the given
       * identifier is not associated to an object adapter defined with
       * an application descriptor.
       *
       * @throws AdapterNotExistException Raised if the adapter doesn't
       * exist.
       */
      getAdapterNode(adapterId: string): string;

      /**
       * Get the adapter information for the replica group or adapter
       * with the given id.
       *
       * @param id The adapter id.
       *
       * @return A sequence of adapter information structures. If the
       * given id refers to an adapter, this sequence will contain only
       * one element. If the given id refers to a replica group, the
       * sequence will contain the adapter information of each member of
       * the replica group.
       *
       * @throws AdapterNotExistException Raised if the adapter or
       * replica group doesn't exist.
       */
      getAdapterInfo(id: string): AdapterInfoSeq;

      /**
       * Get the object info for the object with the given identity.
       *
       * @param id The identity of the object.
       *
       * @return The object info.
       *
       * @throws ObjectNotRegisteredException Raised if the object isn't
       * registered with the registry.
       */
      getObjectInfo(id: Ice.Identity): ObjectInfo;

      /**
       * Get the node information for the node with the given name.
       *
       * @param name The node name.
       *
       * @return The node information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeInfo(name: string): NodeInfo;

      /**
       * Get the load averages of the node.
       *
       * @param name The node name.
       *
       * @return The node load information.
       *
       * @throws NodeNotExistException Raised if the node doesn't exist.
       *
       * @throws NodeUnreachableException Raised if the node could not be
       * reached.
       */
      getNodeLoad(name: string): LoadInfo;

      /**
       * Get the property value for the given property and adapter. The
       * property is looked up in the server or service descriptor where
       * the adapter is defined.
       *
       * @param adapterId The adapter ID
       *
       * @param name The name of the property.
       *
       * @return The property value.
       *
       * @throws AdapterNotExistException Raised if the adapter doesn't exist.
       */
      getPropertyForAdapter(adapterId: string, name: string): string;

      /**
       * Add a replica group filter.
       *
       * @param id The identifier of the filter. This identifier must
       * match the value of the "filter" attribute specified in the
       * replica group descriptor. To filter dynamically registered
       * replica groups, you should use the empty filter id.
       *
       * @param filter The filter implementation.
       */
      addReplicaGroupFilter(id: string, filter: ReplicaGroupFilter): void;

      /**
       * Remove a replica group filter.
       *
       * @param id The identifier of the filter.
       *
       * @param filter The filter implementation.
       *
       * @return True of the filter was removed, false otherwise.
       */
      removeReplicaGroupFilter(id: string, filter: ReplicaGroupFilter): boolean;

      /**
       * Add a type filter.
       *
       * @param type The type to register this filter with.
       *
       * @param filter The filter implementation.
       */
      addTypeFilter(type: string, filter: TypeFilter): void;

      /**
       * Remove a type filter.
       *
       * @param type The type to register this filter with.
       *
       * @param filter The filter implementation.
       *
       * @return True of the filter was removed, false otherwise.
       */
      removeTypeFilter(type: string, filter: TypeFilter): boolean;
    }
  }
}
export {IceGrid} from './IceGrid.ns';