@Override
  public void updateState(PCEPMessage message, ModuleEnum sourceModule) {
    logger.debug("Entering: updateState(PCEPMessage message, ModuleEnum targetLayer)");
    logger.debug("| message: " + message.contentInformation());
    // Client module should have a Buffer for messages not coming from the network (Client or
    // Computation Module) that shoudl be sent once the
    // State Machine comes to the session up state. This is done so that the client
    // module/computation module does not need to buffer
    // Path Computation Requests or Notification messages before the state machine reaches the
    // session up state

    if ((this.state != 4) && (sourceModule.compareTo(ModuleEnum.NETWORK_MODULE) != 0)) {
      sendingQueue.add(message);
    } else {
      // Process the messages normally

      switch (state) {
        case 0:
          {
            enterIdleState();
            break;
          }
        case 1:
          {
            // enterTCPPendingState();
            logger.info("You should not see me!");
            System.out.println("Message Arrived Before State Was Updated");
            break;
          }
        case 2:
          {
            enterOpenWaitState(message);
            break;
          }
        case 3:
          {
            enterKeepWaitState(message);
            // After the keep wait state, if the connection goes into the session up state
            // the buffer with additional connections should be flushed
            if (state == 4) {
              flushBuffer();
            }
            break;
          }
        case 4:
          {
            enterSessionUPState(message, sourceModule);
            break;
          }
        default:
          {
            logger.info("Lost in a completely not reachable state. wtf?");
          }
      }
    }
  }
  private void enterSessionUPState(PCEPMessage message, ModuleEnum sourceModule) {
    logger.debug("Entering: enterSessionUPState(PCEPMessage message)");
    logger.debug("| message: " + message.contentInformation());

    // System.out.println("[StateMachine: " + address.getAddress() +
    // "] entering Session up State" );

    // flushBuffer();

    boolean noErrorsDetected = PCEPMessageAnalyser.checkMessageFormat(message);

    if (noErrorsDetected == false) {
      logger.info("Message Format Error detected");
      sendCloseMessage();
      // releaseResources();
      closeTCPConnection();
    }

    this.checkMultipleConnections();

    logger.debug("Entering: analyzeMessage(PCEPMessage message)");

    int messageType = message.getMessageHeader().getTypeDecimalValue();

    switch (messageType) {
      case 1:
        {
          logger.info("Received Open Message");
          logger.info("Waiting to be implemented. Do something with this Message!");

          break;
        }
      case 2:
        {
          logger.info("Received KeepAlive Message");

          restartDeadTimer();
          logger.info("Processing Information: " + message.contentInformation());

          break;
        }
      case 3:
        {
          logger.info("Received Path Computation Request Message");
          // System.out.println("Received Path Computation Request Message");

          restartDeadTimer();
          if ((sourceModule.compareTo(ModuleEnum.CLIENT_MODULE) == 0)
              || (sourceModule.compareTo(ModuleEnum.COMPUTATION_MODULE) == 0)) {
            lm.getSessionModule().sendMessage(message, ModuleEnum.NETWORK_MODULE);
          } else {
            logger.info(
                "Client State Machine should not receive Path Computation Requests from any module other than Network");
          }
          break;
        }
      case 4:
        {
          logger.info("Received Path Computation Response Message");
          restartDeadTimer();
          if (sourceModule.compareTo(ModuleEnum.NETWORK_MODULE) == 0) {
            // if the state machine is launched in a client, the response should be sent to the
            // Client module
            // or else in case of a server it should be sent to the computation module
            if (lm.isServer() == false)
              lm.getSessionModule().sendMessage(message, ModuleEnum.CLIENT_MODULE);
            else lm.getSessionModule().sendMessage(message, ModuleEnum.COMPUTATION_MODULE);
          } else {
            logger.info(
                "Client State Machine should not receive Path Computation Responses from any module other than Network Module");
          }

          break;
        }
      case 5:
        {
          logger.info("Received Notification Message");

          break;
        }
      case 6:
        {
          logger.info("Received Error Message");

          break;
        }
      case 7:
        {
          logger.info("Received Close Message");

          this.closeTCPConnection();

          break;
        }
      default:
        {
          logger.info("ERROR: Unkown Message");

          break;
        }
    }
  }