Handles a message: find a state and run it.

        :return: The register that was saved

async def _handle_message(self,
                              message: BaseMessage,
                              responder: Responder) -> Optional[Dict]:
        """
        Handles a message: find a state and run it.

        :return: The register that was saved
        """

        async def noop(request: Request, responder: Responder):
            pass

        mm = MiddlewareManager.instance()
        reg_manager = self.register\
            .work_on_register(message.get_conversation().id)

        async with reg_manager as reg:
            request = Request(message, reg)
            await request.transform()

            if not request.stack.layers:
                return

            logger.debug('Incoming message: %s', request.stack)
            await mm.get('pre_handle', noop)(request, responder)

            # noinspection PyBroadException
            try:
                state, trigger, dnr = \
                    await self._build_state(request, message, responder)
            except Exception:
                logger.exception('Error while finding a transition from %s',
                                 reg.get(Register.STATE))
                reporter.report(request, None)
                return

            if state is None:
                logger.debug(
                    'No next state found but "%s" is not confusing, stopping',
                    request.message,
                )
                return

            state = await self._run_state(responder, state, trigger, request)

            # noinspection PyBroadException
            try:
                await responder.flush(request)
            except MissingTranslationError as e:
                responder.clear()
                responder.send([RawText(str(e))])
                await responder.flush(request)

                reporter.report(request, state.name())
                logger.exception('Missing translation in state %s',
                                 state.name())
            except Exception:
                reporter.report(request, state.name())
                logger.exception('Could not flush content after %s',
                                 state.name())
            else:
                if not dnr:
                    reg.replacement = await self._build_state_register(
                        state,
                        request,
                        responder,
                    )
                return reg.replacement