/*
 * SPDX-License-Identifier: LicenseRef-CSSL-1.0
 */

/*!
 * \brief ngap pdu encode procedures for gNB
 */

#include "ngap_gNB_encoder.h"
#include <stdint.h>
#include <stdio.h>
#include "ngap_msg_includes.h"
#include "T.h"
#include "asn_application.h"
#include "asn_codecs.h"
#include "assertions.h"
#include "common/utils/T/T.h"
#include "constr_TYPE.h"
#include "ngap_common.h"
#include "utils.h"
#include "xer_encoder.h"

static inline int ngap_gNB_encode_initiating(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
{
  DevAssert(pdu != NULL);

  const NGAP_ProcedureCode_t tmp[] = {NGAP_ProcedureCode_id_NGSetup,
                                      NGAP_ProcedureCode_id_UplinkNASTransport,
                                      NGAP_ProcedureCode_id_UERadioCapabilityInfoIndication,
                                      NGAP_ProcedureCode_id_InitialUEMessage,
                                      NGAP_ProcedureCode_id_NASNonDeliveryIndication,
                                      NGAP_ProcedureCode_id_UEContextReleaseRequest,
                                      NGAP_ProcedureCode_id_PathSwitchRequest,
                                      NGAP_ProcedureCode_id_PDUSessionResourceModifyIndication,
                                      NGAP_ProcedureCode_id_UplinkRANStatusTransfer,
                                      NGAP_ProcedureCode_id_HandoverPreparation,
                                      NGAP_ProcedureCode_id_HandoverCancel,
                                      NGAP_ProcedureCode_id_HandoverNotification,
                                      NGAP_ProcedureCode_id_UplinkUEAssociatedNRPPaTransport,
                                      NGAP_ProcedureCode_id_UplinkNonUEAssociatedNRPPaTransport};
  int i;
  for (i = 0; i < sizeofArray(tmp); i++)
    if (pdu->choice.initiatingMessage->procedureCode == tmp[i])
      break;
  if (i == sizeofArray(tmp)) {
    NGAP_DEBUG("Unknown procedure ID (%d) for initiating message\n", (int)pdu->choice.initiatingMessage->procedureCode);
    return -1;
  }

  asn_encode_to_new_buffer_result_t res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
  AssertFatal(res.result.encoded > 0, "failed to encode NGAP msg\n");
  *buffer = res.buffer;
  *len = res.result.encoded;
  return 0;
}

static inline int ngap_gNB_encode_successfull_outcome(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
{
  DevAssert(pdu != NULL);
  const NGAP_ProcedureCode_t tmp[] = {NGAP_ProcedureCode_id_InitialContextSetup,
                                      NGAP_ProcedureCode_id_UEContextRelease,
                                      NGAP_ProcedureCode_id_PDUSessionResourceSetup,
                                      NGAP_ProcedureCode_id_PDUSessionResourceModify,
                                      NGAP_ProcedureCode_id_PDUSessionResourceRelease,
                                      NGAP_ProcedureCode_id_HandoverResourceAllocation};
  int i;
  for (i = 0; i < sizeofArray(tmp); i++)
    if (pdu->choice.successfulOutcome->procedureCode == tmp[i])
      break;
  if (i == sizeofArray(tmp)) {
    NGAP_WARN("Unknown procedure ID (%ld) for successfull outcome message\n", pdu->choice.successfulOutcome->procedureCode);
    return -1;
  }

  asn_encode_to_new_buffer_result_t res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
  AssertFatal(res.result.encoded > 0, "failed to encode NGAP msg\n");
  *buffer = res.buffer;
  *len = res.result.encoded;
  return 0;
}

static inline int ngap_gNB_encode_unsuccessfull_outcome(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
{
  DevAssert(pdu != NULL);

  const NGAP_ProcedureCode_t id[] = {NGAP_ProcedureCode_id_InitialContextSetup, NGAP_ProcedureCode_id_HandoverResourceAllocation};

  int i;
  for (i = 0; i < sizeofArray(id); i++) {
    if (pdu->choice.unsuccessfulOutcome->procedureCode == id[i]) {
      break;
    }
  }

  if (i == sizeofArray(id)) {
    NGAP_WARN("Unknown procedure ID (%ld) for successful outcome message\n", pdu->choice.successfulOutcome->procedureCode);
    return -1;
  }

  asn_encode_to_new_buffer_result_t res = asn_encode_to_new_buffer(NULL, ATS_ALIGNED_CANONICAL_PER, &asn_DEF_NGAP_NGAP_PDU, pdu);
  AssertFatal(res.result.encoded > 0, "failed to encode NGAP msg\n");
  *buffer = res.buffer;
  *len = res.result.encoded;
  return 0;
}

int ngap_gNB_encode_pdu(NGAP_NGAP_PDU_t *pdu, uint8_t **buffer, uint32_t *len)
{
  int ret = -1;
  DevAssert(pdu != NULL);
  DevAssert(buffer != NULL);
  DevAssert(len != NULL);
  if (LOG_DEBUGFLAG(DEBUG_ASN1)) {
    xer_fprint(stdout, &asn_DEF_NGAP_NGAP_PDU, (void *)pdu);
  }
  switch (pdu->present) {
    case NGAP_NGAP_PDU_PR_initiatingMessage:
      ret = ngap_gNB_encode_initiating(pdu, buffer, len);
      break;

    case NGAP_NGAP_PDU_PR_successfulOutcome:
      ret = ngap_gNB_encode_successfull_outcome(pdu, buffer, len);
      break;

    case NGAP_NGAP_PDU_PR_unsuccessfulOutcome:
      ret = ngap_gNB_encode_unsuccessfull_outcome(pdu, buffer, len);
      break;

    default:
      NGAP_DEBUG("Unknown message outcome (%d) or not implemented", (int)pdu->present);
      return -1;
  }
  return ret;
}
