///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000-2018 Ericsson Telecom AB
//
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
///////////////////////////////////////////////////////////////////////////////
//
//  File:     MBT_Qtronic_Main.ttcn
//  Rev:      <RnXnn>
//  Prodnr:   CNL 113 659
//  Updated:  2010-10-01
//  Contact:  http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////
module MBT_Qtronic_Main
{

import from EPTF_MBT_LGen_Definitions all;
import from EPTF_MBT_LGen_Functions all;

import from EPTF_CLL_Common_Definitions all;
import from EPTF_CLL_Base_Definitions all;
import from EPTF_CLL_Base_Functions all;
import from EPTF_CLL_LGenBase_Definitions all;

import from EPTF_GTP_LGen_Definitions all;
import from EPTF_GTP_LGen_Functions all;
import from EPTF_GTP_Transport_Definitions all;
import from EPTF_GTP_Transport_Functions all;

import from EPTF_TELNET_Transport_Definitions all;
import from EPTF_TELNET_Transport_Functions all;
import from EPTF_TELNET_LGen_Definitions all;
import from EPTF_TELNET_LGen_Functions all;

import from EPTF_LANL2_Transport_Definitions all;
import from EPTF_LANL2_Transport_Functions all;
import from EPTF_LANL2_LGen_Definitions all;
import from EPTF_LANL2_LGen_Functions all;

import from MBT_Qtronic_Types all;
import from MBT_Qtronic_TestSystem all;

modulepar
{
  boolean tsp_Mapper_enableDebug := false;
}

function f_Mapper_log(in charstring p_log)
{
  if (tsp_Mapper_enableDebug) { log(p_log); }
}

type component MBT_Demo_LGen_CT extends EPTF_MBT_LGen_CT,
  EPTF_GTP_LGen_CT, EPTF_GTP_LocalTransport_CT,
  EPTF_TELNET_LGen_CT, EPTF_TELNET_LocalTransport_CT,
  EPTF_LANL2_LGen_CT, EPTF_LANL2_LocalTransport_CT
{
}

type component MBT_Demo_Tester_CT extends EPTF_MBT_Tester_CT
{
  port GnInPort   GN_IN_LGEN_PCO;
  port GnOutPort  GN_OUT_LGEN_PCO;
  port GiInPort   GI_IN_LGEN_PCO;
  port GiOutPort  GI_OUT_LGEN_PCO;
}

type component MBT_Qtronic_Main_CT extends MBT_Demo_Tester_CT,  MBT_Demo_LGen_CT
{
}

type component MBT_Demo_Main_CT extends EPTF_Base_CT {}


///////////////////////////////////////////////////////////////////////////////////
//      Initialization
///////////////////////////////////////////////////////////////////////////////////

function f_cq_beginTestcase()
runs on QtronicCT
{
  f_Mapper_log(log2str(%definitionId, " enter"));

  // MBT Applib initialization
  f_EPTF_MBT_Tester_init("MBT_Demo");
  f_EPTF_MBT_init("MBT_Demo",0, "MBT_");
  f_EPTF_MBT_initLGenFsm(refers(f_MBT_Demo_LGen_createUserMessage), null);

  // GTP Applib initialization
  f_EPTF_GTP_init(
    pl_selfName:="GTP_LoadGen", 
    pl_selfId:=0, 
    pl_entityNamePrefix:="GTP_AppLib_", 
    pl_numEntities:=0);
  f_EPTF_GTP_LocalTransport_init_CT();

  vf_EPTF_GTP_sendMessage:=refers(f_EPTF_GTP_LocalTransport_sendMessage);
  vf_EPTF_GTP_handleMessage:=refers(f_EPTF_GTP_LocalTransport_handleMessage);
  vf_EPTF_GTP_cleanUpTransport:=refers(f_EPTF_GTP_LocalTransport_cleanUpTransport);
  vf_EPTF_GTP_LocalTransport_receive:=refers(f_EPTF_GTP_messageHandler);

  // TELNET Applib initialization
  f_EPTF_TELNET_init(
    pl_selfName := "TELNET_AppLib", 
    pl_selfId := 0, 
    pl_entityNamePrefix := "TELNET_", 
    pl_numEntities := 0, 
    pl_bind := refers(f_EPTF_TELNET_bindEntity4Behavior)
  );

  f_EPTF_TELNET_LocalTransport_init_CT(
    pl_selfName:= "EPTF_TELNET_LocalTransport", 
    pl_receiveFunction:= refers(f_EPTF_TELNET_messageReceived), 
    pl_eventReceiveFunction:= refers(f_EPTF_TELNET_eventReceived)
  );

  vf_EPTF_TELNET_newTransportUser:=refers( f_EPTF_TELNET_LocalTransport_newTransportUser);
  vf_EPTF_TELNET_sendMessage := refers(f_EPTF_TELNET_LocalTransport_sendMessage)
  vf_EPTF_TELNET_playList:=refers(f_EPTF_TELNET_LocalTransport_playListElement)

  // LANL2 Applib initialization
  f_EPTF_LANL2_init(
    pl_selfName := "IPL2_AppLib", 
    pl_selfId := 0, 
    pl_entityNamePrefix := "IPL2_", 
    pl_numEntities := 0, 
    pl_bind := refers(f_EPTF_LANL2_bindEntity4Behavior)
  );

  f_EPTF_LANL2_LocalTransport_init_CT(
    pl_selfName:= c_EPTF_LANL2_Transport_LGenType, 
    pl_receiveFunction:= refers(f_EPTF_LANL2_messageReceived), 
    pl_eventReceiveFunction:= refers(f_EPTF_LANL2_eventReceived)
  );

  f_EPTF_LANL2_setSendMessageFunction(plf_sendMessageFunction := refers(f_EPTF_LANL2_LocalTransport_sendMessage));
  f_EPTF_LANL2_setEchoMessageFunction(plf_echoMessageFunction := refers(f_EPTF_LANL2_LocalTransport_echoMessage));
  f_EPTF_LANL2_setListenFunction(plf_listenFunction := refers(f_EPTF_LANL2_LocalTransport_listen));
  f_EPTF_LANL2_setCloseFunction(plf_closeFunction := refers(f_EPTF_LANL2_LocalTransport_close));

  // Connecting the MBT Test Harness with the Tester component
  connect(self:EPTF_MBT_PCO, self:EPTF_MBT_TESTER_PCO);
  connect(self:GN_IN_LGEN_PCO, self:GnIn);
  connect(self:GN_OUT_LGEN_PCO, self:GnOut);
  connect(self:GI_IN_LGEN_PCO, self:GiIn);
  connect(self:GI_OUT_LGEN_PCO, self:GiOut);

  // Creating 1 entity with 1 MBT_FSM
  EPTF_MBT_TESTER_PCO.send(EPTF_MBT_ConfigRequest:
    {
      entityGroupName := "MBT_EntityType",
      noEntities := 1,
      behaviors := {c_EPTF_MBT_myBName, c_EPTF_GTP_behavior, c_EPTF_TELNET_behavior},
      fsmName := "FSM_MBT"
    }
  );

  // TODO: activate default altstep, with timeout handling
  EPTF_MBT_TESTER_PCO.receive(EPTF_MBT_ConfigResponse:?);

  //Activating GTP Echo Handler
  f_MBT_Demo_LGen_activateEchoHandler();
    
  f_Mapper_log(log2str(%definitionId, " finished"));
}

function f_cq_endTestcase()
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter"));

  f_EPTF_Base_stopAll(none);

  f_Mapper_log(log2str(%definitionId, " finished"));
}

///////////////////////////////////////////////////////////////////////////////////
//        Mapping Testcase -> Test Harness
///////////////////////////////////////////////////////////////////////////////////

function f_Model_sendCreatePDPContext(in CreatePDPcontext p_CreatePDPcontext)
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter ", p_CreatePDPcontext));

  // Creating a GTP session in the test harness
  f_MBT_execute(c_EPTF_GTP_stepName_init, valueof(t_addr(0)));

  // Start listening on Gi
  f_MBT_execute(c_EPTF_LANL2_stepName_init, valueof(t_addr(0)), {0});
  f_MBT_execute(c_EPTF_LANL2_stepName_listen, valueof(t_addr(0)));

  // Example of setting the parameters for the GTP session
  var EPTF_GTP_FSM_Ctx p_client_ctx;
  f_EPTF_GTP_getContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);

  p_client_ctx.primaryCtx.imsi := f_getIMSI_str2hex(p_CreatePDPcontext.imsi);
  p_client_ctx.primaryCtx.apn := f_getAPN_char2oct(p_CreatePDPcontext.apn);
  p_client_ctx.primaryCtx.msisdn := f_getMSISDN_str2hex(p_CreatePDPcontext.imsi);
  f_EPTF_GTP_setContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);
  // Example ends

  // Generating a PDP context request
  f_MBT_execute(c_EPTF_GTP_stepName_createPDPContextRequest, valueof(t_addr(0)));

  // Example of how to update the generated message
  f_EPTF_GTP_getContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);
  p_client_ctx.gtpcMsgToSend.gtpc_pdu.createPDPContextRequest.charging_char.chargingChar := '0800'O;
  f_EPTF_GTP_setContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);
  // Example ends

  // Sending the message
  f_MBT_execute(c_EPTF_GTP_stepName_sendMessage, valueof(t_addr(0)));
  
  f_Mapper_log(log2str(%definitionId, " finished"));
}

function f_Model_sendUpdatePDPContext(in UpdatePDPcontext p_UpdatePDPcontext)
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter ", p_UpdatePDPcontext));

  // Generating an update PDP context message by the test harness
  f_MBT_execute(c_EPTF_GTP_stepName_updatePDPContextRequest, valueof(t_addr(0)));
  // Sending the message
  f_MBT_execute(c_EPTF_GTP_stepName_sendMessage, valueof(t_addr(0)));
  
  f_Mapper_log(log2str(%definitionId, " finished"));
}

function f_Model_sendDeletePDPContext(in DeletePDPcontext p_DeletePDPcontext)
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter ", p_DeletePDPcontext));

  f_MBT_execute(c_EPTF_GTP_stepName_deletePDPContextRequest, valueof(t_addr(0)));
  f_MBT_execute(c_EPTF_GTP_stepName_sendMessage, valueof(t_addr(0)));
  
  f_Mapper_log(log2str(%definitionId, " finished"));
}

function f_Model_sendGPDU(in GPDU p_gpdu)
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter ", p_gpdu));

  // First we load the Payload we want to send in the GTP tunnel into the GTP Context
  var EPTF_GTP_FSM_Ctx p_client_ctx;
  f_EPTF_GTP_getContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);
  p_client_ctx.primaryCtx.payload :=
    f_EPTF_GTP_createUDPpacket(
      f_EPTF_GTP_convertIP_oct2str(p_client_ctx.primaryCtx.end_user_address), //"20.46.0.2",
      tsp_EPTF_LANL2_connectionInfoList[0].remPort,
      tsp_EPTF_LANL2_connectionInfoList[0].locHost,
      tsp_EPTF_LANL2_connectionInfoList[0].locPort,
      tsp_EPTF_LANL2_connectionInfoList[0].payload
  );
  f_EPTF_GTP_setContext(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), p_client_ctx);

  // Then we generate the GPDU. The previously loaded payload will be in the generated PDU.
  f_MBT_execute(c_EPTF_GTP_stepName_createGTPU, valueof(t_addr(0)));

  // It can be now sent out.
  f_MBT_execute(c_EPTF_GTP_stepName_sendGTPU, valueof(t_addr(0)));
  
  f_Mapper_log(log2str(%definitionId, " finished"));
}

function f_Model_sendUDPpdu(in UDPpdu p_UDPpdu)
runs on MBT_Qtronic_Main_CT
{
  f_Mapper_log(log2str(%definitionId, " enter ", p_UDPpdu));

  f_MBT_execute(c_EPTF_LANL2_stepName_sendMessage, valueof(t_addr(0)), {0});

  f_Mapper_log(log2str(%definitionId, " finished"));
}

///////////////////////////////////////////////////////////////////////////////////
//        Message handling: Test Harness -> Testcase
///////////////////////////////////////////////////////////////////////////////////

function f_MBT_Demo_LGen_createUserMessage(in EPTF_LGenBase_TestStepArgs pl_ptr) 
runs on MBT_Qtronic_Main_CT
return boolean
{
  // This function catches the events that are generated by the test harness when a message is received.
  // The purpose of this function to create the message structure that is expected by the model (and thus by the generated test case code)

  f_Mapper_log(log2str(%definitionId & " creating message for:\n", pl_ptr, "\n", pl_ptr.reportedEvent));

  // CreatePDPContextResponse
  if (pl_ptr.reportedEvent.event.bIdx == v_EPTF_GTP_myBIdx and pl_ptr.reportedEvent.event.iIdx == c_EPTF_GTP_inputIdx_createPDPContextResponse)
  {
    f_MBT_execute(c_EPTF_GTP_stepName_handleIncomingMessage, valueof(t_addr(0)));

    var integer vl_cause :=
      oct2int(v_EPTF_GTP_lastReceived.msg.gtpc.gtpc_pdu.createPDPContextResponse.cause.causevalue);

    GN_OUT_LGEN_PCO.send(CreatePDPresponse:{vl_cause});
  }
  // UpdatePDPContextResponse
  else if (pl_ptr.reportedEvent.event.bIdx == v_EPTF_GTP_myBIdx and pl_ptr.reportedEvent.event.iIdx == c_EPTF_GTP_inputIdx_updatePDPContextResponse)
  {
    f_MBT_execute(c_EPTF_GTP_stepName_handleIncomingMessage, valueof(t_addr(0)));

    var integer vl_cause :=
      oct2int(v_EPTF_GTP_lastReceived.msg.gtpc.gtpc_pdu.updatePDPContextResponse.updatePDPContextResponseSGSN.cause.causevalue);

    GN_OUT_LGEN_PCO.send(UpdatePDPresponse:{vl_cause});
  }
  // DeletePDPContextResponse
  else if (pl_ptr.reportedEvent.event.bIdx == v_EPTF_GTP_myBIdx and pl_ptr.reportedEvent.event.iIdx == c_EPTF_GTP_inputIdx_deletePDPContextResponse)
  {
    f_MBT_execute(c_EPTF_GTP_stepName_handleIncomingMessage, valueof(t_addr(0)));

    var integer vl_cause :=
      oct2int(v_EPTF_GTP_lastReceived.msg.gtpc.gtpc_pdu.deletePDPContextResponse.cause.causevalue);

    GN_OUT_LGEN_PCO.send(DeletePDPresponse:{vl_cause});
    f_MBT_execute(c_EPTF_GTP_stepName_cleanUp, valueof(t_addr(0)));
  }
  // Incoming GTPU
  else if (pl_ptr.reportedEvent.event.bIdx == v_EPTF_GTP_myBIdx and pl_ptr.reportedEvent.event.iIdx == c_EPTF_GTP_inputIdx_GTPU)
  {
    // Access and convert the payload here
    var octetstring vl_payload := ''O;
    var integer vl_data := 0;
    if (f_EPTF_GTP_getUDPpayload(vl_payload))
    { 
      vl_data := oct2int(vl_payload);
    }
    GN_OUT_LGEN_PCO.send(GPDU:{data := vl_data});
  }
  // Incmoing LANL2
  else if (pl_ptr.reportedEvent.event.bIdx == v_EPTF_LANL2_myBIdx and pl_ptr.reportedEvent.event.iIdx == c_EPTF_LANL2_inputIdx_incomingMessage)
  { 
    // Access and convert the payload here
    var octetstring vl_payload := ''O;
    var integer vl_data := 0;
    if (f_EPTF_LANL2_getLastUDP(f_convert_FsmAddr2TestStepArgs(valueof(t_addr(0))), vl_payload))
    {
      vl_data := oct2int(vl_payload);
    }
    GI_OUT_LGEN_PCO.send(UDPpdu:{data := vl_data});
  }
  else
  {
    f_Mapper_log(log2str(%definitionId & "(): unhandled incoming message"));
    return false;
  }
  return true;
}

///////////////////////////////////////////////////////////////////////////////////
//        FSM Activation
///////////////////////////////////////////////////////////////////////////////////

function f_MBT_Demo_LGen_activateEchoHandler() runs on MBT_Qtronic_Main_CT
{
  f_EPTF_GTP_declareEchoHandlerFsm();

  var EPTF_MBT_LGen_Definitions.FsmAddr vl_addr;

  f_MBT_activateFsm("MBT_EntityType", 0, "FSM_GTP_EchoHandler", vl_addr);

  f_MBT_dispatch(c_EPTF_LGenBase_behavior, c_EPTF_LGenBase_inputIdx_testMgmt_startTC, vl_addr);
}

///////////////////////////////////////////////////////////////////////////////////
//        Utility functions
///////////////////////////////////////////////////////////////////////////////////

function f_EPTF_TELNET_bindEntity4Behavior(
  in integer pl_eIdx)
runs on QtronicCT 
return EPTF_IntegerList
{  
  return {pl_eIdx};
}

function f_getAPN_char2oct(in charstring p_apn)
return octetstring
{
  var octetstring vl_ret := '04'O & char2oct(p_apn)
  for (var integer i:=0; i<lengthof(vl_ret); i:=i+1){ if (vl_ret[i]=='2E'O) { vl_ret[i] := '03'O } }
  f_Mapper_log(log2str(%definitionId, " in ", p_apn, " -> ", vl_ret));
  return vl_ret;
}

function f_getIMSI_str2hex(in charstring p_imsi_str)
return hexstring
{  
  var hexstring vl_ret := f_str2tbcd(p_imsi_str);
  f_Mapper_log(log2str(%definitionId, " in ", p_imsi_str, " -> ", vl_ret));
  return vl_ret;
}

function f_getMSISDN_str2hex(in charstring p_imsi_str)
return octetstring
{  
  var octetstring vl_ret := ''O;
  var hexstring vl_imsi := f_str2tbcd(p_imsi_str);
  vl_imsi := substr(vl_imsi, lengthof(vl_imsi)-6, 6);
  vl_ret := '916464'O & f_encodeTBCD_hex2oct(vl_imsi);
  
  f_Mapper_log(log2str(%definitionId, " in ", p_imsi_str, " -> ", vl_ret));
  return vl_ret;
}

function f_str2tbcd(in charstring p_str)
return hexstring
{
  var hexstring vl_ret := ''H;

  for (var integer i:=0; i<lengthof(p_str); i:=i+1)
  {
    vl_ret[i] := int2hex(str2int(p_str[i]),1);
  }

  return vl_ret;
}

function f_encodeTBCD_hex2oct( in hexstring pl_hex )
return octetstring
{
  var integer vl_size:= lengthof(pl_hex);
  if((vl_size mod 2) == 1)
  {
    pl_hex := pl_hex & 'F'H;
    vl_size := vl_size + 1;
  }
  vl_size := vl_size / 2;

  var integer vl_i;
  var octetstring vl_oct := ''O;

  for (vl_i := 0; vl_i < vl_size; vl_i := vl_i + 1)
  {
    vl_oct := vl_oct & hex2oct(pl_hex[(2*vl_i) + 1] & pl_hex[2*vl_i]);
  }

  return vl_oct;
}

template EPTF_MBT_LGen_Definitions.FsmAddr t_addr(integer eIdx) :=
{
  entityGroupName := "MBT_EntityType",
  eIdx := eIdx,
  fIdx  := 0
}

}