/**
   * (no-javadoc)
   *
   * @see FermatPacketProcessor#processingPackage(FermatPacket)
   */
  @Override
  public void processingPackage(FermatPacket receiveFermatPacket) {

    /*
     * Get the filters from the message content and decrypt
     */
    String messageContentJsonStringRepresentation =
        AsymmetricCryptography.decryptMessagePrivateKey(
            receiveFermatPacket.getMessageContent(),
            getWsCommunicationsCloudClientChannel().getClientIdentity().getPrivateKey());

    // System.out.println("FailureComponentRegistrationRequestPacketProcessor -
    // messageContentJsonStringRepresentation = "+messageContentJsonStringRepresentation);

    /*
     * Construct the json object
     */
    JsonObject packetContent =
        jsonParser.parse(messageContentJsonStringRepresentation).getAsJsonObject();
    NetworkServiceType networkServiceApplicant =
        gson.fromJson(
            packetContent.get(JsonAttNamesConstants.NETWORK_SERVICE_TYPE).getAsString(),
            NetworkServiceType.class);
    PlatformComponentProfile platformComponentProfile =
        new PlatformComponentProfileCommunication()
            .fromJson(packetContent.get(JsonAttNamesConstants.PROFILE_TO_REGISTER).getAsString());
    String errorMsj = packetContent.get(JsonAttNamesConstants.FAILURE_VPN_MSJ).getAsString();

    System.out.println("FailureComponentRegistrationRequestPacketProcessor - errorMsj " + errorMsj);

    /*
     * Create a new event whit the networkServiceType and remoteIdentity
     */
    FermatEvent event =
        P2pEventType.FAILURE_COMPONENT_REGISTRATION_REQUEST_NOTIFICATION.getNewEvent();
    event.setSource(EventSource.WS_COMMUNICATION_CLOUD_CLIENT_PLUGIN);

    /*
     * Configure the values
     */
    ((FailureComponentRegistrationNotificationEvent) event)
        .setNetworkServiceApplicant(networkServiceApplicant);
    ((FailureComponentRegistrationNotificationEvent) event)
        .setPlatformComponentProfile(platformComponentProfile);
    ((FailureComponentRegistrationNotificationEvent) event).setErrorMsj(errorMsj);

    /*
     * Raise the event
     */
    // System.out.println("FailureComponentRegistrationRequestPacketProcessor - Raised a event =
    // P2pEventType.FAILURE_COMPONENT_REGISTRATION_REQUEST_NOTIFICATION");
    getWsCommunicationsCloudClientChannel().getEventManager().raiseEvent(event);
  }
  /**
   * Validate the signature of the packet
   *
   * @param fermatPacketReceive
   */
  private void validateFermatPacketSignature(FermatPacket fermatPacketReceive) {

    System.out.println(" WsCommunicationsTyrusCloudClientChannel - validateFermatPacketSignature");

    /*
     * Validate the signature
     */
    boolean isValid =
        AsymmetricCryptography.verifyMessageSignature(
            fermatPacketReceive.getSignature(),
            fermatPacketReceive.getMessageContent(),
            getServerIdentity());

    // System.out.println(" WsCommunicationsTyrusCloudClientChannel - isValid = " + isValid);

    /*
     * if not valid signature
     */
    if (!isValid) {
      throw new RuntimeException(
          "Fermat Packet received has not a valid signature, go to close this connection maybe is compromise");
    }
  }
  /**
   * (no-javadoc)
   *
   * @see FermatTyrusPacketProcessor#processingPackage(FermatPacket)
   */
  @Override
  public void processingPackage(FermatPacket receiveFermatPacket) {

    // System.out.println(" ---------------------------------------------------------------------
    // ");
    // System.out.println("ComponentConnectionRespondTyrusPacketProcessor - Starting
    // processingPackage");

    /*
     * Get the message content and decrypt
     */
    String messageContentJsonStringRepresentation =
        AsymmetricCryptography.decryptMessagePrivateKey(
            receiveFermatPacket.getMessageContent(),
            getWsCommunicationsTyrusCloudClientChannel().getClientIdentity().getPrivateKey());

    // System.out.println("ComponentConnectionRespondTyrusPacketProcessor -
    // messageContentJsonStringRepresentation = "+messageContentJsonStringRepresentation);

    try {

      /*
       * Construct the json object
       */
      Gson gson = new Gson();
      JsonParser parser = new JsonParser();
      JsonObject respond = parser.parse(messageContentJsonStringRepresentation).getAsJsonObject();

      // Get all values
      URI vpnServerUri = new URI(respond.get(JsonAttNamesConstants.VPN_URI).getAsString());
      String vpnServerIdentity =
          respond.get(JsonAttNamesConstants.VPN_SERVER_IDENTITY).getAsString();
      PlatformComponentProfile participantVpn =
          gson.fromJson(
              respond.get(JsonAttNamesConstants.APPLICANT_PARTICIPANT_VPN).getAsString(),
              PlatformComponentProfileCommunication.class);
      PlatformComponentProfile remotePlatformComponentProfile =
          gson.fromJson(
              respond.get(JsonAttNamesConstants.REMOTE_PARTICIPANT_VPN).getAsString(),
              PlatformComponentProfileCommunication.class);
      PlatformComponentProfile remoteNsPlatformComponentProfile =
          gson.fromJson(
              respond.get(JsonAttNamesConstants.REMOTE_PARTICIPANT_NS_VPN).getAsString(),
              PlatformComponentProfileCommunication.class);

      /*
       * get the Server ip and port
       */
      String ServerIp =
          getWsCommunicationsTyrusCloudClientChannel()
              .getWsCommunicationsTyrusCloudClientConnection()
              .getServerIp();
      Integer ServerPort =
          getWsCommunicationsTyrusCloudClientChannel()
              .getWsCommunicationsTyrusCloudClientConnection()
              .getServerPort();

      vpnServerUri = new URI(ServerConf.WS_PROTOCOL + ServerIp + ":" + ServerPort + vpnServerUri);

      System.out.println(
          "ComponentConnectionRespondTyrusPacketProcessor - vpnServerUri to connect = "
              + vpnServerUri);

      /*
       * Get the  wsCommunicationVPNClientManagerAgent
       */
      WsCommunicationTyrusVPNClientManagerAgent wsCommunicationTyrusVPNClientManagerAgent =
          WsCommunicationTyrusVPNClientManagerAgent.getInstance();

      /*
       * Create a new VPN client
       */
      wsCommunicationTyrusVPNClientManagerAgent.createNewWsCommunicationVPNClient(
          vpnServerUri,
          vpnServerIdentity,
          participantVpn,
          remotePlatformComponentProfile,
          remoteNsPlatformComponentProfile,
          getWsCommunicationsTyrusCloudClientChannel().getEventManager());

    } catch (Exception e) {
      throw new RuntimeException(e);
    }
  }
  /**
   * (no-javadoc)
   *
   * @see FermatTyrusPacketProcessor#processingPackage(FermatPacket)
   */
  @Override
  public void processingPackage(final FermatPacket receiveFermatPacket) {

    // System.out.println(" ---------------------------------------------------------------------
    // ");
    // System.out.println("ServerHandshakeRespondTyrusPacketProcessor - processingPackage");

    /* -----------------------------------------------------------------------------------------
     * IMPORTANT: This Message Content of this packet come encrypted with the temporal identity public key
     * and contain the server identity whit the communications cloud client that
     * have to use to talk with the server.
     * -----------------------------------------------------------------------------------------
     */

    /*
     * Decrypt the message content
     */
    String jsonRepresentation =
        AsymmetricCryptography.decryptMessagePrivateKey(
            receiveFermatPacket.getMessageContent(),
            getWsCommunicationsTyrusCloudClientChannel().getTemporalIdentity().getPrivateKey());

    /*
     * Construct the json object
     */
    JsonParser parser = new JsonParser();
    JsonObject serverIdentity = parser.parse(jsonRepresentation).getAsJsonObject();

    /*
     * Get the server identity and set into the communication cloud client
     */
    getWsCommunicationsTyrusCloudClientChannel()
        .setServerIdentity(serverIdentity.get(JsonAttNamesConstants.SERVER_IDENTITY).getAsString());

    // System.out.println("ServerHandshakeRespondTyrusPacketProcessor - ServerIdentity = "+
    // getWsCommunicationsTyrusCloudClientChannel().getServerIdentity());

    /*
     * Construct a Communications Cloud Client Profile for this component and send and fermat packet type FermatPacketType.COMPONENT_REGISTRATION_REQUEST
     */

    HardwareManager hardwareManager =
        getWsCommunicationsTyrusCloudClientChannel().getHardwareManager();
    CloudClientExtraData cloudClientExtraData = null;
    if (hardwareManager != null) {
      cloudClientExtraData =
          new CloudClientExtraData(
              hardwareManager.getOperativeSystem(),
              hardwareManager.getBoard(),
              hardwareManager.getBrand(),
              hardwareManager.getDevice());
    }

    PlatformComponentProfile communicationsCloudClientProfile =
        getWsCommunicationsTyrusCloudClientChannel()
            .getWsCommunicationsTyrusCloudClientConnection()
            .constructPlatformComponentProfileFactory(
                getWsCommunicationsTyrusCloudClientChannel().getClientIdentity().getPublicKey(),
                "WsCommunicationsCloudClientChannel",
                "Web Socket Communications Cloud Client",
                NetworkServiceType.UNDEFINED,
                PlatformComponentType.COMMUNICATION_CLOUD_CLIENT,
                (hardwareManager != null) ? new Gson().toJson(cloudClientExtraData) : null);
    getWsCommunicationsTyrusCloudClientChannel()
        .setPlatformComponentProfile(communicationsCloudClientProfile);

    /* ------------------------------------
     * IMPORTANT: At this moment the server only
     * know the temporal identity of the client
     * the packet has construct with this identity
     * --------------------------------------
     */

    /*
     * Construc the jsonObject
     */
    Gson gson = new Gson();
    JsonObject jsonObject = new JsonObject();
    jsonObject.addProperty(
        JsonAttNamesConstants.NETWORK_SERVICE_TYPE, NetworkServiceType.UNDEFINED.toString());
    jsonObject.addProperty(
        JsonAttNamesConstants.PROFILE_TO_REGISTER, communicationsCloudClientProfile.toJson());

    /*
     * Construct a fermat packet whit the server identity
     */
    FermatPacket fermatPacketRespond =
        FermatPacketCommunicationFactory.constructFermatPacketEncryptedAndSinged(
            getWsCommunicationsTyrusCloudClientChannel().getServerIdentity(), // Destination
            getWsCommunicationsTyrusCloudClientChannel()
                .getTemporalIdentity()
                .getPublicKey(), // Sender
            gson.toJson(jsonObject), // Message Content
            FermatPacketType.COMPONENT_REGISTRATION_REQUEST, // Packet type
            getWsCommunicationsTyrusCloudClientChannel()
                .getTemporalIdentity()
                .getPrivateKey()); // Sender private key

    /*
     * Send the encode packet to the server
     */
    getWsCommunicationsTyrusCloudClientChannel()
        .sendMessage(FermatPacketEncoder.encode(fermatPacketRespond));
  }