/*
==================================================================================
        Copyright (c) 2018-2019 AT&T Intellectual Property.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
==================================================================================
*/
/*
 * sgnb_addition_response.cc
 *
 *  Created on: Aug 22, 2019
 *      Author: sjana
 */

#include <sgnb_addition_response.hpp>

sgnb_addition_response::sgnb_addition_response(void ) {
  

  x2ap_pdu_obj = 0;
  x2ap_pdu_obj = (X2AP_PDU_t * )calloc(1, sizeof(X2AP_PDU_t));
  assert(x2ap_pdu_obj != 0);

  successMsg = 0;
  successMsg = (X2SuccessfulOutcome_t * )calloc(1, sizeof(X2SuccessfulOutcome_t));
  assert(successMsg != 0);

  unsuccessMsg = 0;
  unsuccessMsg = (X2UnsuccessfulOutcome_t * )calloc(1, sizeof(X2UnsuccessfulOutcome_t));
  assert(unsuccessMsg != 0);

  IE_array = 0;
  IE_array = (SgNBAdditionRequestAcknowledge_IEs_t *)calloc(NUM_SGNB_ADDITION_RESPONSE_ACKNOWLEDGE_IES, sizeof(SgNBAdditionRequestAcknowledge_IEs_t));
  assert(IE_array != 0);

  IE_reject_array = 0;
  IE_reject_array = (SgNBAdditionRequestReject_IEs_t *)calloc(NUM_SGNB_ADDITION_RESPONSE_FAILURE_IES, sizeof(SgNBAdditionRequestReject_IEs_t));
  assert(IE_reject_array != 0);
  
  
  erab_admit_array = 0;
  erab_admit_array = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs_t * ) calloc(INITIAL_SIZE, sizeof(E_RABs_ToBeAdded_SgNBAddReq_ItemIEs_t));
  assert(erab_admit_array != 0);
  erab_admit_array_size = INITIAL_SIZE;


  erab_sgnb_present_array = 0;
  erab_sgnb_present_array = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t *) calloc(INITIAL_SIZE, sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t));
  assert(erab_sgnb_present_array != 0);
  erab_sgnb_present_array_size = INITIAL_SIZE;
  
  erab_sgnb_notpresent_array = 0;
  erab_sgnb_notpresent_array = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t *) calloc(INITIAL_SIZE, sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t));
  assert(erab_sgnb_notpresent_array != 0);
  erab_sgnb_notpresent_array_size = INITIAL_SIZE;

  SgNBAdditionRequestAcknowledge_t * sgnb_ack = &(successMsg->value.choice.SgNBAdditionRequestAcknowledge);
  for(int i = 0; i < NUM_SGNB_ADDITION_RESPONSE_ACKNOWLEDGE_IES; i++){
    ASN_SEQUENCE_ADD(&(sgnb_ack->protocolIEs), &(IE_array[i]));
  }
  
  
  SgNBAdditionRequestReject_t * sgnb_reject = &(unsuccessMsg->value.choice.SgNBAdditionRequestReject);
  for(int i = 0; i < NUM_SGNB_ADDITION_RESPONSE_FAILURE_IES; i++){
    ASN_SEQUENCE_ADD(&(sgnb_reject->protocolIEs), &(IE_reject_array[i]));
  }

}

sgnb_addition_response::~sgnb_addition_response(void){

  mdclog_write(MDCLOG_INFO, "Freeing X2AP SgNB Addition Response object memory");

  E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_t  * erabs_toadd_list = &(IE_array[3].value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);
  for(int i = 0; i < erabs_toadd_list->list.size; i++){
    erabs_toadd_list->list.array[i] = 0;
  }
  if (erabs_toadd_list->list.size > 0){
    free(erabs_toadd_list->list.array);
    erabs_toadd_list->list.array = 0;
    erabs_toadd_list->list.size = 0;
    erabs_toadd_list->list.count= 0;
  }
  
  free(erab_sgnb_present_array);
  free(erab_sgnb_notpresent_array);
  free(erab_admit_array);

  SgNBAdditionRequestAcknowledge_t *sgnb_ack  = &(successMsg->value.choice.SgNBAdditionRequestAcknowledge);
  for(int i = 0; i < sgnb_ack->protocolIEs.list.size; i++){
    sgnb_ack->protocolIEs.list.array[i] = 0;
  }

  if (sgnb_ack->protocolIEs.list.size > 0){
    free(sgnb_ack->protocolIEs.list.array);
    sgnb_ack->protocolIEs.list.array = 0;
    sgnb_ack->protocolIEs.list.size = 0;
  }
  
  SgNBAdditionRequestReject_t *sgnb_reject  = &(unsuccessMsg->value.choice.SgNBAdditionRequestReject);
   for(int i = 0; i < sgnb_reject->protocolIEs.list.size; i++){
     sgnb_reject->protocolIEs.list.array[i] = 0;
   }

   if (sgnb_reject->protocolIEs.list.size > 0){
     free(sgnb_reject->protocolIEs.list.array);
     sgnb_reject->protocolIEs.list.array = 0;
     sgnb_reject->protocolIEs.list.size = 0;
   }


  free(IE_array);
  free(IE_reject_array);
  free(successMsg);
  free(unsuccessMsg);

  x2ap_pdu_obj->choice.initiatingMessage = NULL;
  x2ap_pdu_obj->present = X2AP_PDU_PR_NOTHING;
  
  ASN_STRUCT_FREE(asn_DEF_X2AP_PDU, x2ap_pdu_obj);

  mdclog_write(MDCLOG_INFO, "Freed X2AP SgNB Addition Response object memory");
}

bool sgnb_addition_response::set_fields(X2UnsuccessfulOutcome_t * unsuccessMsg, sgnb_addition_helper &sgnb_data){
  
  unsigned ie_index = 0;

  if (unsuccessMsg == 0){
    error_string = "Invalid reference for X2AP Sgnb Addition Reject message in set_fields";
    return false;
  }
  SgNBAdditionRequestReject_IEs_t *ies_sgnb_add_reject;

  ie_index = 0;
  ies_sgnb_add_reject= &IE_reject_array[ie_index];
  ies_sgnb_add_reject->criticality = Criticality_reject;
  ies_sgnb_add_reject->id = ProtocolIE_ID_id_MeNB_UE_X2AP_ID;
  ies_sgnb_add_reject->value.present = SgNBAdditionRequestReject_IEs__value_PR_UE_X2AP_ID;
  ies_sgnb_add_reject->value.choice.UE_X2AP_ID = sgnb_data.menb_ue_x2ap_id;


  ie_index = 1;
  ies_sgnb_add_reject= &IE_reject_array[ie_index];
  ies_sgnb_add_reject->criticality = Criticality_reject;
  ies_sgnb_add_reject->id = ProtocolIE_ID_id_SgNB_UE_X2AP_ID;
  ies_sgnb_add_reject->value.present = SgNBAdditionRequestReject_IEs__value_PR_SgNB_UE_X2AP_ID;
  ies_sgnb_add_reject->value.choice.SgNB_UE_X2AP_ID = sgnb_data.sgnb_ue_x2ap_id;


  ie_index = 2;
  ies_sgnb_add_reject= &IE_reject_array[ie_index];
  ies_sgnb_add_reject->criticality = Criticality_reject;
  ies_sgnb_add_reject->id = ProtocolIE_ID_id_Cause;
  ies_sgnb_add_reject->value.present = SgNBAdditionRequestReject_IEs__value_PR_Cause;
  Cause_t *caus = &ies_sgnb_add_reject->value.choice.Cause;

  switch(sgnb_data.cause)
    {
    case Cause_PR_misc: //Misc
      caus->present = Cause_PR_misc;
      caus->choice.misc = sgnb_data.cause_desc;
      break;
    case Cause_PR_radioNetwork: //radio network
      caus->present = Cause_PR_radioNetwork;
      caus->choice.radioNetwork = sgnb_data.cause_desc;
      break;
    case Cause_PR_protocol : //protocol
      caus->present = Cause_PR_protocol;
      caus->choice.protocol = sgnb_data.cause_desc;
      break;
    case Cause_PR_transport: //transport
      caus->present = Cause_PR_transport;
      caus->choice.transport = sgnb_data.cause_desc;
      break;
      
    default:
      caus->present = Cause_PR_NOTHING;
      break;
    }

  return true;

}


bool sgnb_addition_response::set_fields(X2SuccessfulOutcome_t * successMsg, sgnb_addition_helper &sgnb_data){

  unsigned ie_index = 0;

  if (successMsg == 0){
    error_string = "Invalid reference for X2AP Sgnb Addition Acknowledge message in set_fields";
    return false;
  }

  SgNBAdditionRequestAcknowledge_IEs_t *ies_sgnb_add_ack;

  ie_index = 0;
  ies_sgnb_add_ack= &IE_array[ie_index];
  ies_sgnb_add_ack->criticality = Criticality_reject;
  ies_sgnb_add_ack->id = ProtocolIE_ID_id_MeNB_UE_X2AP_ID;
  ies_sgnb_add_ack->value.present = SgNBAdditionRequestAcknowledge_IEs__value_PR_UE_X2AP_ID;
  ies_sgnb_add_ack->value.choice.UE_X2AP_ID = sgnb_data.menb_ue_x2ap_id;

  
  ie_index = 1;
  ies_sgnb_add_ack= &IE_array[ie_index];
  ies_sgnb_add_ack->criticality = Criticality_reject;
  ies_sgnb_add_ack->id = ProtocolIE_ID_id_SgNB_UE_X2AP_ID;
  ies_sgnb_add_ack->value.present = SgNBAdditionRequestAcknowledge_IEs__value_PR_SgNB_UE_X2AP_ID;
  ies_sgnb_add_ack->value.choice.SgNB_UE_X2AP_ID = sgnb_data.sgnb_ue_x2ap_id;

  ie_index = 2;
  ies_sgnb_add_ack= &IE_array[ie_index];
  ies_sgnb_add_ack->criticality = Criticality_reject;
  ies_sgnb_add_ack->id = ProtocolIE_ID_id_SgNBtoMeNBContainer;
  ies_sgnb_add_ack->value.present = SgNBAdditionRequestAcknowledge_IEs__value_PR_SgNBtoMeNBContainer;
  SgNBtoMeNBContainer_t *container = &ies_sgnb_add_ack->value.choice.SgNBtoMeNBContainer;
  container->buf = sgnb_data.menb_sgnb_container;
  container->size = sgnb_data.menb_sgnb_container_size;

  ie_index = 3;
  ies_sgnb_add_ack = &IE_array[ie_index];
  ies_sgnb_add_ack->criticality = Criticality_reject;
  ies_sgnb_add_ack->id =  ProtocolIE_ID_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList;
  ies_sgnb_add_ack->value.present = SgNBAdditionRequestAcknowledge_IEs__value_PR_E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList;
  E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList_t  * erabs_toadd_list = &(ies_sgnb_add_ack->value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAckList);


  int lcount = sgnb_data.erab_list.size();
  //std::cout <<"Adding " << lcount << " erabs in response" << std::endl;
  
  //resize empty array in constructor
  if (lcount >= erab_admit_array_size){
    erab_admit_array_size = 2*lcount;

    E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs_t * new_ref = 0;
    new_ref = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs_t *)realloc(erab_admit_array, erab_admit_array_size * sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_t));
    assert(new_ref != 0);
    erab_admit_array = new_ref;

    erab_sgnb_present_array_size = 2 * lcount;
    E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t  * new_present = 0;
    new_present = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t  *)realloc(erab_sgnb_present_array, erab_sgnb_present_array_size * sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent_t ));
    assert(new_present != 0);
    erab_sgnb_present_array = new_present;

    erab_sgnb_notpresent_array_size = 2 * lcount;
    E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t  * new_notpresent = 0;
    new_notpresent = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t  *)realloc(erab_sgnb_notpresent_array, erab_sgnb_notpresent_array_size * sizeof(E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent_t ));
    assert(new_notpresent != 0);
    erab_sgnb_notpresent_array = new_notpresent;
  }

  std::vector<struct erab_item> * ref_erab_input  = &(sgnb_data.erab_list);
  erabs_toadd_list->list.count = 0;

  int sgnb_present_index = 0;
  int sgnb_notpresent_index = 0;

  for(unsigned int i = 0; i < lcount; i++){

    erab_admit_array[i].id = ProtocolIE_ID_id_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item ;
    erab_admit_array[i].criticality = Criticality_ignore;
    erab_admit_array[i].value.present =  E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs__value_PR_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item;

    E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_t * erab_item = &(erab_admit_array[i].value.choice.E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item);

    erab_item->e_RAB_ID = (*ref_erab_input)[i].erab_id;
    erab_item->en_DC_ResourceConfiguration.pDCPatSgNB =  (*ref_erab_input)[i].pdcp_at_sgnb;
    erab_item->en_DC_ResourceConfiguration.mCGresources =  (*ref_erab_input)[i].mcg_resources;
    erab_item->en_DC_ResourceConfiguration.sCGresources =  (*ref_erab_input)[i].scg_resources;


    erab_item->resource_configuration.present = (E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR)(*ref_erab_input)[i].sgnb_pdcp_present;
    if( erab_item->resource_configuration.present == E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR_sgNBPDCPpresent){
      
      erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
      erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
      erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;

      erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID.buf = (*ref_erab_input)[i].sgnb_item.gtp_tei;
      erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;

      /* Force all optional parameters that are not set to NULL */
      erab_sgnb_present_array[sgnb_present_index].sgNB_UL_GTP_TEIDatPDCP = NULL;

      /* validate constraints ..*/
      int ret_constr;
      ret_constr = asn_check_constraints(&asn_DEF_GTP_TEI, &erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint.gTP_TEID, errbuf, &errbuf_len);
      if(ret_constr){
	error_string.assign(&errbuf[0], errbuf_len);
	error_string = "Error in constraints for GTP TEID.. Reason = " + error_string;
	return false;
      }

      ret_constr = asn_check_constraints(&asn_DEF_GTPtunnelEndpoint, &erab_sgnb_present_array[sgnb_present_index].s1_DL_GTPtunnelEndpoint, errbuf, &errbuf_len);
      if(ret_constr){
	error_string.assign(&errbuf[0], errbuf_len);
	error_string = "Error in constraints for GTP tunnel endpoint .. Reason = " + error_string;
	return false;
      }

      ret_constr = asn_check_constraints(&asn_DEF_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPpresent, &erab_sgnb_present_array[sgnb_present_index], errbuf, &errbuf_len);
      if(ret_constr){
	error_string.assign(&errbuf[0], errbuf_len);
	error_string = "Error in constraints for E_RABS_ToBeAdded_SgNBAddReq_SgNBPDCPpresent.. Reason = " + error_string;
	return false;
      }

      erab_item->resource_configuration.choice.sgNBPDCPpresent = &erab_sgnb_present_array[sgnb_present_index];
      sgnb_present_index ++;

    }
    else if (erab_item->resource_configuration.present ==  E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item__resource_configuration_PR_sgNBPDCPnotpresent){

      erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.buf = (*ref_erab_input)[i].sgnb_item.transport_layer_addr;
      erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.size = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_size;
      erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.transportLayerAddress.bits_unused  = (*ref_erab_input)[i].sgnb_item.transport_layer_addr_unused;

      erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.gTP_TEID.buf = (unsigned char *)(*ref_erab_input)[i].sgnb_item.gtp_tei;
      erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG.gTP_TEID.size = (*ref_erab_input)[i].sgnb_item.gtp_tei_size;

      erab_sgnb_notpresent_array[sgnb_notpresent_index].secondary_sgNB_DL_GTP_TEIDatSCG = NULL;

      /* validate constraints ..*/
      int ret_constr;
      ret_constr = asn_check_constraints(&asn_DEF_GTPtunnelEndpoint, &erab_sgnb_notpresent_array[sgnb_notpresent_index].sgNB_DL_GTP_TEIDatSCG, errbuf, &errbuf_len);
      if(ret_constr){
	error_string.assign(&errbuf[0], errbuf_len);
	error_string = "Error in constraints for GTP tunnel endpoint .. Reason = " + error_string;
	return false;
      }


      ret_constr = asn_check_constraints(&asn_DEF_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_Item_SgNBPDCPnotpresent, &erab_sgnb_notpresent_array[sgnb_notpresent_index], errbuf, &errbuf_len);
      if(ret_constr){
	error_string.assign(&errbuf[0], errbuf_len);
	error_string = "Error in constraints for E_RABS_ToBeAdded_SgNBAddReq_SgNBPDCPnotpresent.. Reason = " + error_string;
	return false;
      }

      erab_item->resource_configuration.choice.sgNBPDCPnotpresent = &erab_sgnb_notpresent_array[sgnb_notpresent_index]; ;
      sgnb_notpresent_index ++;
    }
    else {
      std::cerr <<"Could not find a pdcp present or not present flag. not adding erab item .." << std::endl;
      continue;
    }

    // check constraint
    int ret_constr = asn_check_constraints(&asn_DEF_E_RABs_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs, &erab_admit_array[i], errbuf, &errbuf_len);
    if(ret_constr){
      error_string.assign(&errbuf[0], errbuf_len);
      error_string = "Error in constraints for E_RABS_Admitted_ToBeAdded_SgNBAddReqAck_ItemIEs.. Reason = " + error_string;
      return false;
    }

    ASN_SEQUENCE_ADD(erabs_toadd_list, &erab_admit_array[i]);
  }

  return true;
}

bool sgnb_addition_response::encode_sgnb_addition_response(unsigned char* data_buf, size_t *data_size, sgnb_addition_helper &sgnb_data, bool sgnb_response)
{

  bool res;
  if(sgnb_response == true){

    x2ap_pdu_obj->present = X2AP_PDU_PR_successfulOutcome;
    x2ap_pdu_obj->choice.successfulOutcome = successMsg;
    
    successMsg->procedureCode = ProcedureCode_id_sgNBAdditionPreparation;
    successMsg->criticality = Criticality_ignore;
    successMsg->value.present = X2SuccessfulOutcome__value_PR_SgNBAdditionRequestAcknowledge;

    res = set_fields(successMsg, sgnb_data);

  } else {

    x2ap_pdu_obj->present = X2AP_PDU_PR_unsuccessfulOutcome;
    x2ap_pdu_obj->choice.unsuccessfulOutcome = unsuccessMsg;


    unsuccessMsg->procedureCode = ProcedureCode_id_sgNBAdditionPreparation;
    unsuccessMsg->criticality = Criticality_ignore;
    unsuccessMsg->value.present = X2UnsuccessfulOutcome__value_PR_SgNBAdditionRequestReject;

    res = set_fields(unsuccessMsg, sgnb_data);
  }

  if (!res){
    return false;
  }
  int ret_constr = asn_check_constraints(&asn_DEF_X2AP_PDU, x2ap_pdu_obj, errbuf, &errbuf_len);
  if(ret_constr){
    error_string.assign(&errbuf[0], errbuf_len);
    error_string = "Error encoding X2AP Sgnb Addition Response  message. Reason = " + error_string;
    return false;
  }

  //xer_fprint(stdout, &asn_DEF_X2AP_PDU, x2ap_pdu_obj);

  asn_enc_rval_t retval = asn_encode_to_buffer(0, ATS_ALIGNED_BASIC_PER, &asn_DEF_X2AP_PDU, x2ap_pdu_obj, data_buf, *data_size);
  if(retval.encoded == -1){
    error_string.assign(strerror(errno));
    return false;
  }

  else {
    if(*data_size < retval.encoded){
      std::stringstream ss;
      ss  <<"Error encoding SgNB Addition Request Response. Reason =  encoded pdu size " << retval.encoded << " exceeds buffer size " << *data_size << std::endl;
      error_string = ss.str();
      return false;
    }
  }

  *data_size = retval.encoded;
  return true;
}