/////////////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2017-2018  Ericsson AB
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
/////////////////////////////////////////////////////////////////////////////////////
// Contributors:
// Akos Makovics
//
//  File:         OpcUa_Test_Binary.ttcn
//  Rev:          <RnXnn>
//  Prodnr:       CNL113861
/////////////////////////////////////////////////////////////////////////////////////

module OpcUa_Test_Binary {

  import from IPL4asp_PortType all;

  import from OpcUa_Functions all;
  import from OpcUa_Types_Binary all;

  import from OpcUa_Encoded_Messages all;
  import from OpcUa_Message_Templates all;

  type component MyComp {}

  type component SendReceiveComp {
        port IPL4asp_PT testPort;
        var integer connId;
  }

  // local and remote TCP host/port
  modulepar { OpcUa_Functions.ConnectionData LocalTCPConnection, RemoteTCPConnection }


  function f_encDec_Binary_Message (in MessageChunk pl_in) runs on MyComp {
    log("==========================================================================");
    log("f_encDec_Binary_Message Enter");

     var octetstring v_encodedMessage;
     var octetstring v_secondEncodedMessage;
     var MessageChunk v_decodedMessage;

     var integer v_messageType := pl_in.header.messageType;

     if (v_messageType == 4998472 or v_messageType == 4932417 or v_messageType == 5395013 or v_messageType == 4540498 ) {
      log("Message type: Transport Message");
    } else {
      log("Message type: Service, message contains body");

      var ServiceBody body;

      if (dec_ServiceBody(pl_in.body, body) == -1) {
        setverdict(fail, "Failed to decode service body!");
      }

      var octetstring encodedBody := enc_ServiceBody(body);

      if (encodedBody != pl_in.body) {
        setverdict(fail, "Service body encoding has failed!");
      }
    }

    v_encodedMessage := enc_MessageChunk(pl_in);

    if (dec_MessageChunk(v_encodedMessage, v_decodedMessage) == -1) {
      setverdict ( fail, "Failed to encode message!" );
      return;
    }

    v_secondEncodedMessage :=  enc_MessageChunk(v_decodedMessage);

    if (v_encodedMessage == v_secondEncodedMessage) {
      setverdict ( pass, "Message succesfully encoded and decoded!" );
    } else {
      setverdict ( fail, "First and second encoding yielded a different result!" );
    }
  }

  function f_encDec_OpcUa_MessageChunk(in octetstring pl_in) runs on MyComp
  {

    log("==========================================================================");
    log("f_encDec_OpcUa_Message Enter");

    var MessageChunk v_decodedChunk;
    var octetstring v_encodedChunk;

    if (dec_MessageChunk(pl_in, v_decodedChunk) == -1) {
      setverdict(fail, "Failed to decode message chunk!");
      return;
    }

    var integer v_messageType := v_decodedChunk.header.messageType;

    if (v_messageType == 4998472 or v_messageType == 4932417 or v_messageType == 5395013 or v_messageType == 4540498 ) {
      log("Message type: Transport Message");
    } else {
      log("Message type: Service");

      var ServiceBody body;

      if (dec_ServiceBody(v_decodedChunk.body, body) == -1) {
        setverdict(fail, "Failed to decode service!");
      }

      v_decodedChunk.body := enc_ServiceBody(body);
    }

    v_encodedChunk := enc_MessageChunk(v_decodedChunk);

    if (pl_in == v_encodedChunk) {
      setverdict(pass);
    } else {
      setverdict(fail);
    }
  }


  function f_connectToServer() runs on SendReceiveComp {
    connId := CreateConnection(testPort, LocalTCPConnection, RemoteTCPConnection);
    if (connId != -1) {
      setverdict(pass, "Connection established!");
    } else {
      setverdict(fail, "Failed to create connection!");
    }
  }

  function f_closeConnectToServer() runs on SendReceiveComp {
    if (CloseConnection(testPort, connId)) {
      setverdict(pass, "Connection closed!");
    } else {
      setverdict(fail, "Failed to close connection!");
    }
  }

  function f_sendMessagesToServer() runs on SendReceiveComp {
    connId := CreateConnection(testPort, LocalTCPConnection, RemoteTCPConnection);
    if (connId == -1) {
      setverdict(fail, "Failed to create connection!");
      return;
    }

    f_sendReceive_Message(f_GetHelloMessage(), f_GetAckMessage(), true);
    f_sendReceive_Message(f_GetOpenSecureChannelRequest(), f_GetOpenSecureChannelResponse(), true);
    f_sendReceive_Message(f_GetEndpointsRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetCreateSessionRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetActivateSessionRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetBrowseRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetReadRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetCreateSubscRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetCloseSessionRequest(), f_GetServiceResponse(), true);
    f_sendReceive_Message(f_GetCloseSecureChannelRequest(), omit, false);

    if (not CloseConnection(testPort, connId)) {
      setverdict(fail, "Failed to close connection!");
    }
  }

  //Sends an encoded message, and matches the reply with a template
  function f_sendReceive_Message(in octetstring msgToSend, in template MessageChunk expectedMsg, in boolean expectReply) runs on SendReceiveComp {
    var octetstring actualMsg;

     SendMessage(testPort, RemoteTCPConnection, connId, msgToSend);

     if (expectReply) {
       if (ReceiveMessage(testPort, actualMsg)) {
         var MessageChunk v_decodedMessage; //Expected msg

         //Decode message
         if (dec_MessageChunk(actualMsg, v_decodedMessage) == -1) {
           setverdict(fail, "Received reply, but unable to decode it!");
         }

         if (match(v_decodedMessage, expectedMsg)) {
            setverdict(pass, "Received expected reply!");
          } else {
            setverdict(fail, "Received unexpeted reply!");
          }
       } else {
         setverdict(fail, "Failed to receive response!");
       }
     } else {
       setverdict(pass, "Message sent!");
     }
  }

  testcase tc_dec_Hello() runs on MyComp {
    const octetstring v_msg := encodedBinaryHello;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_Ack() runs on MyComp {
    const octetstring v_msg := encodedBinaryAck;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_Err() runs on MyComp {
    const octetstring v_msg := encodedBinaryError;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_OpenSecReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryOpenSecReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_OpenSecResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryOpenSecResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CloseSecReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryCloseSecReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_GetEndpointsReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryGetEndointsReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_GetEndpointsResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryGetEndointsResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateSessionReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateSessionReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateSessionResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateSessionResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ActivateSessionReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryActivateSessionReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ActivateSessionResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryActivateSessionResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_BrowseReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryBrowseReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_BrowseResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryBrowseResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ReadReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryReadReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ReadResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryReadResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateSubscReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateSubscReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateSubscResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateSubscResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateMonitoredItemReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateMonitoredItemReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CreateMonitoredItemResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryCreateMonitoredItemResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_PublishReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryPublishReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_PublishResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryPublishResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_DeleteSubscReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryDeleteSubsReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_DeleteSubscResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryDeleteSubsResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CloseSessionReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryClodeSessionReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CloseSessionResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryClodeSessionResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_TranslateBrowsePathsToNodeIdsReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryTranslateBrowsePathsToNodeIdsReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_TranslateBrowsePathsToNodeIdsResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryTranslateBrowsePathsToNodeIdsResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_SetPublishingModeReq() runs on MyComp {
    const octetstring v_msg := encodedBinarySetPublishingModeReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_SetPublishingModeResp() runs on MyComp {
    const octetstring v_msg := encodedBinarySetPublishingModeResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CallReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryCallReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_CallResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryCallResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_SetMonitoringModeReq() runs on MyComp {
    const octetstring v_msg := encodedBinarySetMonitoringModeReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_SetMonitoringModeResp() runs on MyComp {
    const octetstring v_msg := encodedBinarySetMonitoringModeResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ModifyMonitoredItemReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryModifyMonitoredItemReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_ModifyMonitoredItemResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryModifyMonitoredItemResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_WriteReq() runs on MyComp {
    const octetstring v_msg := encodedBinaryWriteReq;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }

  testcase tc_dec_WriteResp() runs on MyComp {
    const octetstring v_msg := encodedBinaryWriteResp;
    f_encDec_OpcUa_MessageChunk(v_msg);
  }


  testcase tc_encDec_Hello() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetHelloMessage());
  }

  testcase tc_encDec_OpenSecureChannelReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetOpenSecureChannelRequest());
  }

  testcase tc_encDec_EndpointsReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetEndpointsRequest());
  }

  testcase tc_encDec_CreateSessionReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetCreateSessionRequest());
  }

  testcase tc_encDec_ActivateSessionReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetActivateSessionRequest());
  }

  testcase tc_encDec_GetBrowseReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetBrowseRequest());
  }

  testcase tc_encDec_GetReadReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetReadRequest());
  }

  testcase tc_encDec_CreateSubscReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetCreateSubscRequest());
  }

  testcase tc_encDec_CloseSessionReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetCloseSessionRequest());
  }

  testcase tc_encDec_CloseSecureChannelReq() runs on MyComp {
    f_encDec_OpcUa_MessageChunk(f_GetCloseSecureChannelRequest());
  }

  testcase tc_sendMessagesToServer() runs on SendReceiveComp {
    map(mtc:testPort, system:testPort);
    f_sendMessagesToServer();
  }

  control {
    //Decode and test encoded messages from Wireshark
    execute(tc_dec_Hello());
    execute(tc_dec_Ack());
    execute(tc_dec_Err());

    execute(tc_dec_OpenSecReq());
    execute(tc_dec_OpenSecResp());

    execute(tc_dec_CloseSecReq());

    execute(tc_dec_GetEndpointsReq());
    execute(tc_dec_GetEndpointsResp());

    execute(tc_dec_CreateSessionReq());
    execute(tc_dec_CreateSessionResp());

    execute(tc_dec_ActivateSessionReq());
    execute(tc_dec_ActivateSessionResp());

    execute(tc_dec_BrowseReq());
    execute(tc_dec_BrowseResp());

    execute(tc_dec_ReadReq());
    execute(tc_dec_ReadResp());

    execute(tc_dec_CreateSubscReq());
    execute(tc_dec_CreateSubscResp());

    execute(tc_dec_CreateMonitoredItemReq());
    execute(tc_dec_CreateMonitoredItemResp());

    execute(tc_dec_DeleteSubscReq());
    execute(tc_dec_DeleteSubscResp());

    execute(tc_dec_PublishReq());
    execute(tc_dec_PublishResp());

    execute(tc_dec_CloseSessionReq());
    execute(tc_dec_CloseSessionResp());

    execute(tc_dec_TranslateBrowsePathsToNodeIdsReq());
    execute(tc_dec_TranslateBrowsePathsToNodeIdsResp());

    execute(tc_dec_SetPublishingModeReq());
    execute(tc_dec_SetPublishingModeResp());

    execute(tc_dec_SetMonitoringModeReq());
    execute(tc_dec_SetMonitoringModeResp());

    execute(tc_dec_CallReq());
    execute(tc_dec_CallResp());

    execute(tc_dec_ModifyMonitoredItemReq());
    execute(tc_dec_ModifyMonitoredItemResp());

    execute(tc_dec_WriteReq());
    execute(tc_dec_WriteResp());

    //Encode and decode Messages created from TTCN structures
    execute(tc_encDec_Hello());
    execute(tc_encDec_OpenSecureChannelReq());
    execute(tc_encDec_EndpointsReq());
    execute(tc_encDec_CreateSessionReq());
    execute(tc_encDec_ActivateSessionReq());
    execute(tc_encDec_GetBrowseReq());
    execute(tc_encDec_GetReadReq());
    execute(tc_encDec_CreateSubscReq());
    execute(tc_encDec_CloseSessionReq());
    execute(tc_encDec_CloseSecureChannelReq());

    //Encode and send TTCN messages to a local OPC server
    execute (tc_sendMessagesToServer());
  }
}