///////////////////////////////////////////////////////////////////////////////
//
// 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 v2.0
// which accompanies this distribution, and is available at
// https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
///////////////////////////////////////////////////////////////////////////////
//
//  File:     XTDP_OldTestPortDemoAndTest_Common.ttcn
//  Rev:      <RnXnn>
//  Prodnr:   CNL 11
//  Updated:  2010-03-09
//  Contact:  http://ttcn.ericsson.se
///////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
//  Module: XTDP_OldTestPortDemoAndTest_Common
// 
//  Purpose:
//    This module provides 
// 
//  Module depends on:
//    -
// 
//  Current Owner:
//    
// 
//  Last Review Date:
//    -
//
///////////////////////////////////////////////////////////////
module XTDP_OldTestPortDemoAndTest_Common
{
import from XTDP_EncDecFunctions all
//import from www_mozilla_org_keymaster_gatekeeper_there_is_only_xul all;
//import from ttcn_ericsson_se_xtdp_xtdp_1_0 all
//import from ttcn_ericsson_se_xtdp_xul_1_0 all
import from NoTargetNamespace all;
import from IPL4asp_PortType all;
import from IPL4asp_Types all;
//import from IPL4asp_Functions all;
import from XTDP_Templates all;
//import from TCCDateTime_Functions all;


modulepar boolean tsp_debug_GuiTest :=false; //from XTDP_TP:RunTimeGuiTest.ttcn
modulepar boolean tsp_debugVerbose_GuiTest :=false;//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar integer tsp_callGrpsNo := 80;//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar integer  tsp_sigLinksNo := 80//from XTDP_TP:RunTimeGuiTest.ttcn
modulepar float tsp_guard_timer := 30.0

type record of integer IntegerList;
type record of default DefaultList;
type component MTC {
  port IPL4asp_PT IPL4;
  var integer v_reqId := 1;
  var integer v_plainRequest:= 0;
  var IntegerList xtdp_connection_list := {};
  var DefaultList xtdp_connection_defaultlist := {}
  var XTDP_Message xtdp_message;
  var ASP_Event ipl4_event;
  var template integer newConnId := ?
  
}
function f_getNextReqId() runs on MTC return integer {
  var integer vl_retVal := v_reqId;
  v_reqId := v_reqId+1;
  return vl_retVal;
}
modulepar charstring tsp_xtdp_connectTo_addr := "172.31.21.49";
modulepar integer    tsp_xtdp_connectTo_port := 11420;
modulepar charstring tsp_xtdp_listenAt_addr := "159.107.148.181";
modulepar integer    tsp_xtdp_listenAt_port := 11420;

template ASP_RecvFrom t_recvfrom(template integer pl_connId) := {
  connId := pl_connId,
  remName := ?,
  remPort := ?,
  locName := ?,
  locPort := ?,
  proto := ?,
  userData := ?,
  msg := ?
}

template ASP_Event t_res(template integer pl_connId)  := {
  result := {
    errorCode := *,
    connId := pl_connId,
    os_error_code := *,
    os_error_text := *}
}

template ASP_Event t_open(template integer pl_connId)  := {
  connOpened := {
    connId := pl_connId,
    remName := ?,
    remPort := ?,
    locName := ?,
    locPort := ?,
    proto :=?,
    userData :=?
    
  }
}

template ASP_Event t_sctpEvent := {
  sctpEvent := ?
}

template ASP_Event t_close(template integer pl_connId) := {
  connClosed := {
    connId := pl_connId,
    remName := ?,
    remPort := ?,
    locName := ?,
    locPort := ?,
    proto :=?,
    userData :=?
    
  }
}

function f_connectToServerGui(in charstring pl_addr, in integer pl_port) 
runs on MTC return integer //connId
{
  var integer vl_connId;
  //map
  map(self:IPL4, system:IPL4);
  //connect to GUI
  var Result result:= IPL4asp_PortType.f_IPL4_connect(
    IPL4, 
    pl_addr, pl_port, 
    c_ipv4AnyAddr, c_anyPort, 
    vl_connId, {tcp := {}})
  if (ispresent(result.errorCode)) {
    log("Connection failed: ",result.errorCode);
    setverdict(fail);
    stop;
  }
  log("Connection open: ",result);
  setverdict(pass);
  vl_connId:= result.connId
  
  //register message dissector for receiving
  var f_IPL4_getMsgLen fcb_msglen := refers(f_XTDP_getMsgLen);
  f_IPL4_setGetMsgLen(IPL4, vl_connId, fcb_msglen, {})
  
  return vl_connId;
}

function f_listenForClientGui(in charstring pl_addr, in integer pl_port) 
runs on MTC return integer //server connId
{
  var integer vl_connId;
  //map
  map(self:IPL4, system:IPL4);
  //connect to GUI
  var Result result:= IPL4asp_PortType.f_IPL4_listen(
    portRef:= IPL4, 
    locName:= pl_addr, 
    locPort:= pl_port, 
    proto:= {tcp := {}}, 
    options:= {
      //   {reuseAddress := {enable:=true}}, 
      //   {tcpKeepAlive := {    
      //       /*boolean*/ enable := true /*optional*/,
      //       /*integer*/ count := omit /*optional*/,
      //       /*integer*/ idle :=omit /*optional*/,
      //       /*integer*/ interval := omit /*optional*/
      //     }}
    }
  ) //open listen port
  if (ispresent(result.errorCode)) {
    log("Listening failed: ",result);
    setverdict(fail);
    stop;
  }
  log("Listening started, result: ",result);
  setverdict(pass);
  vl_connId:= result.connId
  //register message dissector for receiving
  var f_IPL4_getMsgLen fcb_msglen := refers(f_XTDP_getMsgLen);
  f_IPL4_setGetMsgLen(IPL4, vl_connId, fcb_msglen, {})
  
  
  return vl_connId;
}

function f_sayBye(in integer pl_connId) 
runs on MTC  //connId
{
  //say Bye
  var octetstring vl_msgOct :=  enc_XTDP_Message(XTDP_Message:{
      noNamespaceSchemaLocation := "XTDP-Message.xsd",
      choice := {
        xTDP_Bye := "Normal end."
      }
    })
  var ASP_Send asp := {
    connId := pl_connId,
    proto := omit,      
    msg := int2oct(lengthof(vl_msgOct)+4,4) & vl_msgOct
  };
  IPL4.send(asp);
  
  timer t := 5.0; t.start; t.timeout;
  var ASP_Event vl_ipl4Event;
  var XTDP_Message xtdpMsg;
  var integer vl_result := -1;
  var template integer vl_conn := pl_connId
  t.start
  alt {
    []as_result(vl_conn, t, vl_ipl4Event) {
      if(vl_ipl4Event.result.os_error_code == 104) {
        log("The GUI reset the connection");
      }
      if (ispresent(vl_ipl4Event.result.errorCode)) {
        log(%definitionId, ": Port error, giving up: ", vl_ipl4Event.result);
        t.stop;
      } else {
        repeat;
      }
    }
    []as_connClose(t, vl_conn) {
      log("The GUI closed the connection. I also exit.");
      t.stop;
    }
    []as_recvFrom4Test(vl_conn, t, vl_result, xtdpMsg) {
      // as_recvFrom4Test will log the message
      t.stop; t.start; repeat;
    }
    [] t.timeout {
      log(%definitionId, ": Timeout waiting for answer");
    }
  }
}

function f_close(in integer pl_connId) 
runs on MTC  //connId
{
  var Result result:= IPL4asp_PortType.f_IPL4_close(IPL4, pl_connId, {tcp := {}})
  if (ispresent(result.errorCode)) {
    log("Closing failed: ",result.errorCode);
    setverdict(fail);
    stop;
  }
  log("Connection closed: ",result);
  setverdict(pass);
}

function f_sayByeAndCloseWithStop(in integer pl_connId) 
runs on MTC  //connId
{
  //say Bye
  f_sayBye(pl_connId);
  
  //close
  f_close(pl_connId)
  
  //unmap
  unmap(self:IPL4, system:IPL4);
  stop;
}


function f_send(
  in integer pl_connId,
  in template XTDP_Message pl_msg
) runs on MTC {
  if (ischosen(pl_msg.choice.xTDP_Requests)) {v_plainRequest := v_plainRequest+1}
  var octetstring vl_msgOct :=  enc_XTDP_Message(valueof(pl_msg))
  var ASP_Send asp := {
    connId := pl_connId,
    proto := omit,      
    msg := int2oct(lengthof(vl_msgOct)+4,4) & vl_msgOct
  };
  IPL4.send(asp);
}
altstep get_xtdp_message(template integer pl_connId) runs on MTC {
  //var ASP_XTDP xtdp_asp;
  //var integer vl_length := 0, vl_row, vl_column;
  var charstring vl_cell, vl_rowstr, vl_columnstr, widgetRoot;
  
  var ASP_RecvFrom vl_recv;
  var ASP_Event vl_event;
  var XTDP_Message vl_msg;
  [] IPL4.receive(t_recvfrom(pl_connId)) -> value vl_recv {
    log("Communication ASP received: ",vl_recv)
    setverdict(pass);
    var integer vl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
    if (vl_result ==0 ) {
      log("Decoded msg:", vl_msg, " result:", vl_result)         
      setverdict(pass);
    } else {
      log("Unsuccesful decode:", vl_msg, " result:", vl_result)         
      setverdict(fail);
    }
    select( vl_msg )
    {
      case ( t_singleSuccessResp(?) )
      {
        if (tsp_debug_GuiTest) {
          log("GUI reported success for request #", vl_msg.choice.xTDP_Responses.xTDP_Response_list[0].requestId);
        }
        repeat;
      }
      case ( t_singleErrorResp(pl_rqId:=?, pl_argument:=*, pl_errorSource:=?, pl_errorCode:=?, pl_errorMessage:=?) )
      {
        if (tsp_debug_GuiTest) {
          log("GUI reported error for request #", vl_msg.choice.xTDP_Responses.xTDP_Response_list[0].requestId);
        }
        repeat;
      }
      case ( t_snapshotButtonPressed(pl_rqId:=?, pl_wtype:=string, pl_argument:=?, pl_timeout:=*) )
      {
        //f_sendSnapshot();      
        
        if (tsp_debug_GuiTest) {action("Snapshot button pressed...")};
        repeat;
      }
      case else
      {
        log("GUI reported:", vl_msg);
        if (tsp_debug_GuiTest) {action("GUI message is not handled here :-(");};
      }
    }
    repeat; 
  }  
}

altstep as_recvFrom(inout template integer pl_listenConnId, timer pl_Tguard, out integer pl_result) runs on MTC{
  var ASP_RecvFrom vl_recv;
  var XTDP_Message vl_msg;
  [] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
    pl_listenConnId := vl_recv.connId;
    pl_Tguard.stop;            
    log("Communication ASP received: ",vl_recv)
    pl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
    if (pl_result ==0 ) {
      log("Decoded msg:", vl_msg, " result:", pl_result)         
      //var Window vl_window;
      //vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
    } else {
      log("Unsuccesful decode:", vl_msg, " result:", pl_result)
    }
    if(pl_result == 0 and ischosen(vl_msg.choice.xTDP_Responses)) {
      for(var integer i := 0; i < sizeof(vl_msg.choice.xTDP_Responses); i := i + 1) {
        if(vl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
          log("Response #", i, " is not success!");
          setverdict(fail);
        } else {
          log("Response #", i, " is success!");
          setverdict(pass);
        }
      }
    }  
  }
}
altstep as_grokAck(inout template integer pl_listenConnId, timer pl_Tguard) runs on MTC{
  var ASP_RecvFrom vl_recv;
  var XTDP_Message vl_msg;
  var integer vl_result := -1;
  [] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
    pl_listenConnId := vl_recv.connId;
    pl_Tguard.stop;            
    log("Communication ASP received: ",vl_recv)
    vl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), vl_msg);
    if (vl_result ==0 ) {
      log("Decoded msg:", vl_msg, " result:", vl_result)         
      //var Window vl_window;
      //vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
    } else {
      log("Unsuccesful decode:", vl_msg, " result:", vl_result)
      setverdict(fail)
    }
    if(vl_result == 0) {
      if (ischosen(vl_msg.choice.xTDP_Responses)) {
        for(var integer i := 0; i < sizeof(vl_msg.choice.xTDP_Responses); i := i + 1) {
          if(vl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
            log("Response #", i, " is not success!");
            setverdict(fail);
          } else {
            log("Response #", i, " is success!");
            setverdict(pass);
          }
        }
      } else {
        log(%definitionId, ": unhandled msg", vl_msg)
        setverdict(inconc);
      }
    }  
  }
}
altstep as_recvFrom4Test(inout template integer pl_listenConnId, timer pl_Tguard, out integer pl_result, out XTDP_Message pl_msg) runs on MTC{
  var ASP_RecvFrom vl_recv;
  [] IPL4.receive(t_recvfrom(pl_listenConnId)) -> value vl_recv {
    pl_listenConnId := vl_recv.connId;
    pl_Tguard.stop;            
    log("Communication ASP received: ",vl_recv)
    pl_result:= dec_XTDP_Message(f_XTDP_getRawMsg(vl_recv.msg), pl_msg);
    if (pl_result ==0 ) {
      log("Decoded msg:", pl_msg, " result:", pl_result)         
      //var Window vl_window;
      //vl_result := dec_XTDL_Window(char2oct(unichar2char(vl_msg.choice.xTDP_LayoutResponse.elem)), vl_window)
    } else {
      log("Unsuccesful decode:", pl_msg, " result:", pl_result)         
    }
    if(pl_result == 0 and ischosen(pl_msg.choice.xTDP_Responses)) {
      for(var integer i := 0; i < sizeof(pl_msg.choice.xTDP_Responses); i := i + 1) {
        if(pl_msg.choice.xTDP_Responses.xTDP_Response_list[i].responseCode != success) {
          log("Response #", i, " is not success!");
          setverdict(fail);
        } else {
          log("Response #", i, " is success!");
          setverdict(pass);
        }
      }
    }  
  }
}
altstep as_connOpen(timer pl_Tguard, inout template integer pl_clientConnId) runs on MTC{
  var ASP_Event vl_event;
  [] IPL4.receive(t_open(pl_clientConnId)) -> value vl_event{
    log("Event: Result ASP received:", vl_event);
    pl_Tguard.stop;
    pl_clientConnId := vl_event.connOpened.connId;
    
  }
}
altstep as_connClose(timer pl_Tguard, inout template integer pl_connId) runs on MTC{
  var ASP_Event vl_event;
  [] IPL4.receive(t_close(pl_connId)) -> value vl_event{
    log("Event: Connection closed: ",vl_event);
    pl_connId := vl_event.connClosed.connId;
    pl_Tguard.stop
  }
}

altstep as_result(inout template integer pl_listenConnId, timer pl_Tguard, out ASP_Event pl_event) runs on MTC{
  var ASP_Event vl_event;
  [] IPL4.receive(t_res(pl_listenConnId)) -> value vl_event{
    pl_listenConnId := vl_event.result.connId
    pl_event := vl_event;
    log("Event: ", vl_event)
    pl_Tguard.stop;
  }
}

altstep as_defaultSctpAndTimer(template integer pl_listenConnId, timer pl_Tguard) runs on MTC{
  var ASP_Event vl_event;
  [] IPL4.receive(t_sctpEvent) -> value vl_event {
    log("Event: SCTP event arrived: ",vl_event)
    repeat;
  }	  
  [] pl_Tguard.timeout {
    log("timeout:", pl_Tguard);
    setverdict(fail,"timeout:", pl_Tguard);
    stop
  }
}
altstep as_any(inout template integer pl_listenConnId) runs on MTC{
  var ASP_Event vl_event
  var template integer vl_conn := pl_listenConnId;
  var integer vl_result;
  timer dummy;
  [] as_result(vl_conn, dummy, vl_event) {}
  [] as_recvFrom(vl_conn, dummy, vl_result) {}
  [] IPL4.receive {
    log("Unhandled IPL4 ASP has arrived, discarded!")
  }	  
  
}
function f_wait4RecvFrom(in integer pl_connId) runs on MTC {
  timer T
  T.start(30.0);
  var integer vl_result := -1;
  var template integer vl_clientConnId := pl_connId
  alt {
    [] as_recvFrom(vl_clientConnId, T, vl_result) {
      if (vl_result==0){
        setverdict(pass)
      } else {
        setverdict(fail, "Unsuccesful XTDP decode");
      }
    }
  }
}
altstep f_wait4ConnOpened(
  inout template integer pl_serverConnId, 
  inout template integer pl_clientConnId,
  timer T
) runs on MTC {
  var ASP_Event vl_event;
  var integer vl_result;
  
  
  [] as_recvFrom(pl_serverConnId, T, vl_result){
    setverdict(fail);
  }
  
  [] as_result(pl_serverConnId, T, vl_event) {
    log("Event: Result ASP received:", vl_event);
    setverdict(fail);
    stop
  }
  []as_connOpen(T, pl_clientConnId) {
    setverdict(pass);
    T.stop;
  }
  [] as_connClose(T, pl_clientConnId) {
    setverdict(fail,"Event: Connection closed");
    stop
  }
  []as_defaultSctpAndTimer(pl_serverConnId, T){
  }  
}


}  // end of module