import { Message } from '@node-ts/bus-messages'
import { LoggerFactory } from '../logger'
import { ClassConstructor } from '../util'
import { Handler, HandlerDefinition, MessageBase } from './handler'

interface RegisteredHandlers {
  messageType: ClassConstructor<MessageBase>
  handlers: HandlerDefinition[]
}

export interface HandlerRegistrations {
  [key: string]: RegisteredHandlers
}

/**
 * Provide a way for externally managed messages to be handled
 * by the Bus
 */
export interface CustomResolver<MessageType = any> {
  /**
   * A resolver function that will be executed for each read message
   * to determine if it's to be handled by the handler declaring this resolver
   */
  resolveWith: (message: MessageType) => boolean

  /**
   * If provided, will attempt to subscribe the queue to this topic.
   * If not provided, assumes that the queue will be subscribed to the topic manually.
   */
  topicIdentifier?: string
}

export interface HandlerResolver {
  handler: HandlerDefinition
  resolver(message: unknown): boolean
  messageType: ClassConstructor<MessageBase> | undefined
  topicIdentifier: string | undefined
}

export type MessageName = string

/**
 * An internal singleton that contains all registrations of messages to functions that handle
 * those messages.
 */
export interface HandlerRegistry {
  /**
   * Registers that a function handles a particular message type
   * @param messageType The class type of message to handle
   * @param handler The function handler to dispatch messages to as they arrive
   * @param customResolver An optional custom resolver that will be used instead
   * of the default @node-ts/bus-messages/Message behaviour in terms of matching
   * incoming messages to handlers.
   */
  register<TMessage extends MessageBase>(
    messageType: ClassConstructor<TMessage>,
    handler: HandlerDefinition<TMessage>
  ): void

  registerCustom<TMessage extends MessageBase>(
    handler: HandlerDefinition<TMessage>,
    customResolver: CustomResolver<TMessage>
  ): void

  /**
   * Gets all registered message handlers for a given message name
   * @param message A message that has been received from the bus
   */
  get<MessageType extends Message>(
    loggerFactory: LoggerFactory,
    message: object
  ): HandlerDefinition<MessageType>[]

  /**
   * Retrieves a list of all messages that have handler registrations
   */
  getMessageNames(): string[]

  /**
   * Returns the class constructor for a message that has a handler registration
   * @param messageName Message to get a class constructor for
   */
  getMessageConstructor<TMessage extends Message>(
    messageName: string
  ): ClassConstructor<TMessage> | undefined

  /**
   * Retrieves an array of all topic arns that are managed externally but require subscribing to as there are
   * custom handlers that handle those messages.
   */
  getExternallyManagedTopicIdentifiers(): string[]

  /**
   * Gets all registered message handler resolvers
   */
  getResolvers(): HandlerResolver[]

  /**
   * Gets a list of all class based handlers that have been registered
   */
  getClassHandlers(): Handler[]

  /**
   * Removes all handlers from the registry
   */
  reset(): void
}