/*
 * Copyright 2019 AT&T Intellectual Property
 * Copyright 2019 Nokia
 *
 * 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.
 */

//
// Created by adi ENZEL on 12/10/19.
//

#ifndef E2_E2BUILDER_H
#define E2_E2BUILDER_H

#include <cstring>
#include <cstdio>
#include <cerrno>
#include <cstdlib>
#include <sys/types.h>
#include <error.h>
#include <mdclog/mdclog.h>
#include <algorithm>


#include <mdclog/mdclog.h>


#include "asn1cFiles/E2AP-PDU.h"
#include "asn1cFiles/InitiatingMessage.h"
#include "asn1cFiles/SuccessfulOutcome.h"
#include "asn1cFiles/UnsuccessfulOutcome.h"

#include "asn1cFiles/ProtocolIE-Field.h"

#include "asn1cFiles/FDD-Info.h"
#include "asn1cFiles/TDD-Info.h"
#include "asn1cFiles/Neighbour-Information.h"


#include "asn1cFiles/constr_TYPE.h"
#include "asn1cFiles/asn_constant.h"

using namespace std;

#define printEntry(type, function) \
    if (mdclog_level_get() >= MDCLOG_DEBUG) { \
        mdclog_write(MDCLOG_DEBUG, "start Test %s , %s", type, function); \
    }


static void checkAndPrint(asn_TYPE_descriptor_t *typeDescriptor, void *data, char *dataType, const char *function) {
    char errbuf[128]; /* Buffer for error message */
    size_t errlen = sizeof(errbuf); /* Size of the buffer */
    if (asn_check_constraints(typeDescriptor, data, errbuf, &errlen) != 0) {
        mdclog_write(MDCLOG_ERR, "%s Constraint validation failed: %s", dataType, errbuf);
    } else if (mdclog_level_get() >= MDCLOG_DEBUG) {
        mdclog_write(MDCLOG_DEBUG, "%s successes function %s", dataType, function);
    }
}

BIT_STRING_t *createBIT_STRING(int size, int unusedBits, uint8_t *data) {
    printEntry("BIT_STRING_t", __func__)
    auto *bitString = (BIT_STRING_t *)calloc(1, sizeof(BIT_STRING_t));
    ASN_STRUCT_RESET(asn_DEF_BIT_STRING, bitString);
    bitString->size = size;
    bitString->bits_unused = unusedBits;
    bitString->buf = (uint8_t *)calloc(1, size);
    // set bits to zero
    data[bitString->size - 1] = ((unsigned)(data[bitString->size - 1] >>
            (unsigned)bitString->bits_unused) << (unsigned)bitString->bits_unused);
    memcpy(bitString->buf, data, size);

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_BIT_STRING, bitString, (char *)"BIT_STRING_t", __func__);
    }

    return bitString;
}


OCTET_STRING_t *createOCTET_STRING(const unsigned char *data, int size) {
    printEntry("OCTET_STRING_t", __func__)
    auto *octs = (PLMN_Identity_t *)calloc(1, sizeof(PLMN_Identity_t));
    ASN_STRUCT_RESET(asn_DEF_OCTET_STRING, octs);
    octs->size = size;
    octs->buf = (uint8_t *)calloc(1, size);
    memcpy(octs->buf, data, size);

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_OCTET_STRING, octs, (char *)"OCTET_STRING_t", __func__);
    }
    return octs;
}


PLMN_Identity_t *createPLMN_ID(const unsigned char *data) {
    printEntry("PLMN_Identity_t", __func__)
    auto *plmnId = (PLMN_Identity_t *)calloc(1, sizeof(PLMN_Identity_t));
    ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, plmnId);
    plmnId->size = 3;
    plmnId->buf = (uint8_t *)calloc(1, 3);
    memcpy(plmnId->buf, data, 3);

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_PLMN_Identity, plmnId, (char *)"PLMN_Identity_t", __func__);
    }
    return plmnId;
}

ENB_ID_t *createENB_ID(ENB_ID_PR enbType, unsigned char *data) {
    printEntry("ENB_ID_t", __func__)
    auto *enb = (ENB_ID_t *)calloc(1, sizeof(ENB_ID_t));
    ASN_STRUCT_RESET(asn_DEF_ENB_ID, enb);

    enb->present = enbType;

    switch (enbType) {
        case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
            enb->choice.macro_eNB_ID.size = 3;
            enb->choice.macro_eNB_ID.bits_unused = 4;

            enb->present = ENB_ID_PR_macro_eNB_ID;

            enb->choice.macro_eNB_ID.buf = (uint8_t *)calloc(1, enb->choice.macro_eNB_ID.size);
            data[enb->choice.macro_eNB_ID.size - 1] = ((unsigned)(data[enb->choice.macro_eNB_ID.size - 1] >>
                    (unsigned)enb->choice.macro_eNB_ID.bits_unused) << (unsigned)enb->choice.macro_eNB_ID.bits_unused);
            memcpy(enb->choice.macro_eNB_ID.buf, data, enb->choice.macro_eNB_ID.size);

            break;
        }
        case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes
            enb->choice.home_eNB_ID.size = 4;
            enb->choice.home_eNB_ID.bits_unused = 4;
            enb->present = ENB_ID_PR_home_eNB_ID;

            enb->choice.home_eNB_ID.buf = (uint8_t *)calloc(1, enb->choice.home_eNB_ID.size);
            data[enb->choice.home_eNB_ID.size - 1] = ((unsigned)(data[enb->choice.home_eNB_ID.size - 1] >>
                    (unsigned)enb->choice.home_eNB_ID.bits_unused) << (unsigned)enb->choice.home_eNB_ID.bits_unused);
            memcpy(enb->choice.home_eNB_ID.buf, data, enb->choice.home_eNB_ID.size);
            break;
        }
        case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes
            enb->choice.short_Macro_eNB_ID.size = 3;
            enb->choice.short_Macro_eNB_ID.bits_unused = 6;
            enb->present = ENB_ID_PR_short_Macro_eNB_ID;

            enb->choice.short_Macro_eNB_ID.buf = (uint8_t *)calloc(1, enb->choice.short_Macro_eNB_ID.size);
            data[enb->choice.short_Macro_eNB_ID.size - 1] = ((unsigned)(data[enb->choice.short_Macro_eNB_ID.size - 1] >>
                    (unsigned)enb->choice.short_Macro_eNB_ID.bits_unused) << (unsigned)enb->choice.short_Macro_eNB_ID.bits_unused);
            memcpy(enb->choice.short_Macro_eNB_ID.buf, data, enb->choice.short_Macro_eNB_ID.size);
            break;
        }
        case ENB_ID_PR_long_Macro_eNB_ID: { // 21
            enb->choice.long_Macro_eNB_ID.size = 3;
            enb->choice.long_Macro_eNB_ID.bits_unused = 3;
            enb->present = ENB_ID_PR_long_Macro_eNB_ID;

            enb->choice.long_Macro_eNB_ID.buf = (uint8_t *)calloc(1, enb->choice.long_Macro_eNB_ID.size);
            data[enb->choice.long_Macro_eNB_ID.size - 1] = ((unsigned)(data[enb->choice.long_Macro_eNB_ID.size - 1] >>
                    (unsigned)enb->choice.long_Macro_eNB_ID.bits_unused) << (unsigned)enb->choice.long_Macro_eNB_ID.bits_unused);
            memcpy(enb->choice.long_Macro_eNB_ID.buf, data, enb->choice.long_Macro_eNB_ID.size);
            break;
        }
        default:
            free(enb);
            return nullptr;
    }

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_ENB_ID, enb, (char *)"ENB_ID_t", __func__);
    }
    return enb;
}

GlobalENB_ID_t *createGlobalENB_ID(PLMN_Identity_t *plmnIdentity, ENB_ID_t *enbId) {
    printEntry("GlobalENB_ID_t", __func__)
    auto *genbId = (GlobalENB_ID_t *)calloc(1, sizeof(GlobalENB_ID_t));
    ASN_STRUCT_RESET(asn_DEF_GlobalENB_ID, genbId);
    memcpy(&genbId->pLMN_Identity, plmnIdentity, sizeof(PLMN_Identity_t));
    memcpy(&genbId->eNB_ID, enbId, sizeof(ENB_ID_t));

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_GlobalENB_ID, genbId, (char *)"GlobalENB_ID_t", __func__);
    }
    return genbId;
}


ECGI_t *CreateECGI(PLMN_Identity_t *plmnIdentity, BIT_STRING_t * eUtran) {
    printEntry("ECGI_t", __func__)
    auto *ecgi = (ECGI_t *)calloc(1, sizeof(ECGI_t));
    ASN_STRUCT_RESET(asn_DEF_ECGI, ecgi);

    memcpy(&ecgi->pLMN_Identity, plmnIdentity, sizeof(PLMN_Identity_t));
    memcpy(&ecgi->eUTRANcellIdentifier, eUtran, sizeof(BIT_STRING_t));

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_ECGI, ecgi, (char *)"ECGI_t", __func__);
    }
    return ecgi;
}

//
//FDD-Info ::= SEQUENCE {
//        uL-EARFCN						EARFCN,
//        dL-EARFCN						EARFCN,
//        uL-Transmission-Bandwidth		Transmission-Bandwidth,
//        dL-Transmission-Bandwidth		Transmission-Bandwidth,
//        iE-Extensions				ProtocolExtensionContainer { {FDD-Info-ExtIEs} } OPTIONAL,
//        ...
//}
//
//FDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
//        { ID id-UL-EARFCNExtension						CRITICALITY reject	EXTENSION EARFCNExtension									PRESENCE optional}|
//        { ID id-DL-EARFCNExtension						CRITICALITY reject	EXTENSION EARFCNExtension									PRESENCE optional}|
//        { ID id-OffsetOfNbiotChannelNumberToDL-EARFCN	CRITICALITY reject	EXTENSION OffsetOfNbiotChannelNumberToEARFCN		PRESENCE optional}|
//        { ID id-OffsetOfNbiotChannelNumberToUL-EARFCN	CRITICALITY reject	EXTENSION OffsetOfNbiotChannelNumberToEARFCN		PRESENCE optional}|
//        { ID id-NRS-NSSS-PowerOffset					CRITICALITY ignore	EXTENSION NRS-NSSS-PowerOffset							PRESENCE optional}|
//        { ID id-NSSS-NumOccasionDifferentPrecoder		CRITICALITY ignore	EXTENSION NSSS-NumOccasionDifferentPrecoder			PRESENCE optional},
//        ...
//}

static FDD_Info_t *create_fdd(long dL_EARFCN,
        long uL_EARFCN,
        e_Transmission_Bandwidth ultb,
        e_Transmission_Bandwidth dltb) {
    printEntry("FDD_Info_t", __func__)
    auto *fdd = (FDD_Info_t *)calloc(1, sizeof(FDD_Info_t));
    ASN_STRUCT_RESET(asn_DEF_FDD_Info, fdd);

    //EARFCN ::= INTEGER (0..maxEARFCN)

    if (dL_EARFCN >= 0 && dL_EARFCN <= maxEARFCN) {
        fdd->dL_EARFCN = dL_EARFCN;
    } else {
        fdd->dL_EARFCN = maxEARFCN;
    }
    if (uL_EARFCN >= 0 && uL_EARFCN <= maxEARFCN) {
        fdd->uL_EARFCN = uL_EARFCN;
    } else {
        fdd->uL_EARFCN = maxEARFCN;
    }

    fdd->uL_Transmission_Bandwidth = ultb;
    fdd->dL_Transmission_Bandwidth = dltb;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_FDD_Info, fdd, (char *)"FDD_Info_t", __func__);
    }

    return fdd;
}

SpecialSubframe_Info_t *createSpecialSubframe_Info(e_CyclicPrefixDL eCyclicPrefixDl,
        e_CyclicPrefixUL eCyclicPrefixUl,
        e_SpecialSubframePatterns eSpecialSubframePatterns) {
    printEntry("SpecialSubframe_Info_t", __func__)
    auto *ssf = (SpecialSubframe_Info_t *)calloc(1, sizeof(SpecialSubframe_Info_t));
    ASN_STRUCT_RESET(asn_DEF_SpecialSubframe_Info, ssf);

    ssf->cyclicPrefixDL = eCyclicPrefixDl;
    ssf->cyclicPrefixUL = eCyclicPrefixUl;
    ssf->specialSubframePatterns = eSpecialSubframePatterns;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_SpecialSubframe_Info, ssf, (char *)"SpecialSubframe_Info_t", __func__);
    }
    return ssf;
}

//TDD-Info ::= SEQUENCE {
//        eARFCN							EARFCN,
//        transmission-Bandwidth			Transmission-Bandwidth,
//        subframeAssignment				SubframeAssignment,
//        specialSubframe-Info			SpecialSubframe-Info,
//        iE-Extensions					ProtocolExtensionContainer { {TDD-Info-ExtIEs} } OPTIONAL,
//        ...
//}
//
//TDD-Info-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
//        { ID id-AdditionalSpecialSubframe-Info			CRITICALITY ignore	EXTENSION AdditionalSpecialSubframe-Info				PRESENCE optional}|
//        { ID id-eARFCNExtension							CRITICALITY reject	EXTENSION EARFCNExtension									PRESENCE optional}|
//        { ID id-AdditionalSpecialSubframeExtension-Info	CRITICALITY ignore	EXTENSION AdditionalSpecialSubframeExtension-Info	PRESENCE optional}|
//        { ID id-OffsetOfNbiotChannelNumberToDL-EARFCN	CRITICALITY reject	EXTENSION OffsetOfNbiotChannelNumberToEARFCN		PRESENCE optional}|
//        { ID id-NBIoT-UL-DL-AlignmentOffset				CRITICALITY reject	EXTENSION NBIoT-UL-DL-AlignmentOffset					PRESENCE optional},
//        ...
//}

static TDD_Info_t *create_Tdd(long eARFCN,
        e_Transmission_Bandwidth tb,
        e_SubframeAssignment sfA,
        SpecialSubframe_Info_t *ssfi) {
    printEntry("TDD_Info_t", __func__)
    auto *tdd = (TDD_Info_t *)calloc(1, sizeof(FDD_Info_t));
    ASN_STRUCT_RESET(asn_DEF_TDD_Info, tdd);

    if (eARFCN >= 0 && eARFCN <= maxEARFCN) {
        tdd->eARFCN = eARFCN;
    } else {
        tdd->eARFCN = maxEARFCN;
    }
    tdd->transmission_Bandwidth = tb;
    tdd->subframeAssignment = sfA;
    memcpy(&tdd->specialSubframe_Info, ssfi, sizeof(SpecialSubframe_Info_t));

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_TDD_Info, tdd, (char *)"TDD_Info_t", __func__);
    }
    return tdd;
}

static EUTRA_Mode_Info_t *createEUTRA_Mode_Info_FDD(FDD_Info_t *fdd) {
    printEntry("EUTRA_Mode_Info_t", __func__)
    auto *eutraModeInfo = (EUTRA_Mode_Info_t *)calloc(1, sizeof(EUTRA_Mode_Info_t));
    ASN_STRUCT_RESET(asn_DEF_EUTRA_Mode_Info, eutraModeInfo);

    eutraModeInfo->present = EUTRA_Mode_Info_PR_fDD;
    eutraModeInfo->choice.fDD = fdd;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_EUTRA_Mode_Info, eutraModeInfo, (char *)"EUTRA_Mode_Info_t", __func__);
    }
    return eutraModeInfo;

}

static EUTRA_Mode_Info_t *createEUTRA_Mode_Info_TDD(TDD_Info_t *tdd) {
    printEntry("EUTRA_Mode_Info_t", __func__)
    auto *eutraModeInfo = (EUTRA_Mode_Info_t *)calloc(1, sizeof(EUTRA_Mode_Info_t));
    ASN_STRUCT_RESET(asn_DEF_EUTRA_Mode_Info, eutraModeInfo);

    eutraModeInfo->present = EUTRA_Mode_Info_PR_tDD;
    eutraModeInfo->choice.tDD = tdd;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_EUTRA_Mode_Info, eutraModeInfo, (char *)"EUTRA_Mode_Info_t", __func__);
    }
    return eutraModeInfo;

}

Neighbour_Information__Member *createNeighbour_Information__Member(ECGI_t *eCGI, long pci, long eARFCN) {
    printEntry("Neighbour_Information__Member", __func__)
    auto *nigborInformation = (Neighbour_Information__Member *)calloc(1, sizeof(Neighbour_Information__Member));
    ASN_STRUCT_RESET(asn_DEF_Neighbour_Information, nigborInformation);

    memcpy(&nigborInformation->eCGI, eCGI, sizeof(ECGI_t));
    nigborInformation->pCI = pci;
    nigborInformation->eARFCN = eARFCN;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_Neighbour_Information, nigborInformation, (char *)"Neighbour_Information__Member", __func__);
    }
    return nigborInformation;
}

void buildNeighbour_InformationVector(Neighbour_Information_t *neighbourInformation, Neighbour_Information__Member *member) {
    ASN_SEQUENCE_ADD(&neighbourInformation->list, member);
}

//ServedCell-Information ::= SEQUENCE {
//        pCI					PCI,
//        cellId				ECGI,
//        tAC					TAC,
//        broadcastPLMNs		BroadcastPLMNs-Item,
//        eUTRA-Mode-Info		EUTRA-Mode-Info,
//        iE-Extensions		ProtocolExtensionContainer { {ServedCell-Information-ExtIEs} } OPTIONAL,
//        ...
//}
//
//ServedCell-Information-ExtIEs X2AP-PROTOCOL-EXTENSION ::= {
//        { ID id-Number-of-Antennaports				CRITICALITY ignore	EXTENSION Number-of-Antennaports					PRESENCE optional}|
//        { ID id-PRACH-Configuration					CRITICALITY ignore	EXTENSION PRACH-Configuration						PRESENCE optional}|
//        { ID id-MBSFN-Subframe-Info					CRITICALITY ignore	EXTENSION MBSFN-Subframe-Infolist				PRESENCE optional}|
//        { ID id-CSG-Id								CRITICALITY ignore	EXTENSION CSG-Id									PRESENCE optional}|
//        { ID id-MBMS-Service-Area-List				CRITICALITY ignore	EXTENSION MBMS-Service-Area-Identity-List		PRESENCE optional}|
//        { ID id-MultibandInfoList					CRITICALITY ignore	EXTENSION MultibandInfoList							PRESENCE optional}|
//        { ID id-FreqBandIndicatorPriority			CRITICALITY ignore	EXTENSION FreqBandIndicatorPriority				PRESENCE optional}|
//        { ID id-BandwidthReducedSI					CRITICALITY ignore	EXTENSION BandwidthReducedSI						PRESENCE optional}|
//        { ID id-ProtectedEUTRAResourceIndication	CRITICALITY ignore	EXTENSION ProtectedEUTRAResourceIndication	PRESENCE optional}|
//        { ID id-BPLMN-ID-Info-EUTRA					CRITICALITY ignore 	EXTENSION BPLMN-ID-Info-EUTRA						PRESENCE optional},
//        ...
//}

/**
 *
 * @param pci
 * @param cellId
 * @param tac
 * @param broadcastPLMNs
 * @param eutranModeInfo
 * @return
 */
ServedCell_Information_t *createServedCellInfo(long pci,
        ECGI_t *cellId,
        TAC_t *tac,
        vector<PLMN_Identity_t> &broadcastPLMNs,
        EUTRA_Mode_Info_t *eutranModeInfo) {

    printEntry("ServedCell_Information_t", __func__)
    auto servedCellinfo = (ServedCell_Information_t *)calloc(1, sizeof(ServedCell_Information_t));
    ASN_STRUCT_RESET(asn_DEF_ServedCell_Information, servedCellinfo);

    servedCellinfo->pCI = pci;
    memcpy(&servedCellinfo->cellId, cellId, sizeof(ECGI_t));
    memcpy(&servedCellinfo->tAC, tac, sizeof(TAC_t));

    for (auto v : broadcastPLMNs) {
        ASN_SEQUENCE_ADD(&servedCellinfo->broadcastPLMNs.list, &v);
    }

    memcpy(&servedCellinfo->eUTRA_Mode_Info, eutranModeInfo, sizeof(EUTRA_Mode_Info_t));

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_ServedCell_Information, servedCellinfo, (char *)"ServedCell_Information_t", __func__);
    }

    return servedCellinfo;
}


ServedCells__Member *createServedCellsMember(ServedCell_Information_t *servedCellInfo, Neighbour_Information_t *neighbourInformation) {
    printEntry("ServedCells__Member", __func__)
    auto servedCellMember = (ServedCells__Member *)calloc(1, sizeof(ServedCells__Member));

    memcpy(&servedCellMember->servedCellInfo, servedCellInfo, sizeof(ServedCell_Information_t));
    servedCellMember->neighbour_Info = neighbourInformation;

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_ServedCells, servedCellMember, (char *)"ServedCells__Member", __func__);
    }

    return servedCellMember;
}

void buildServedCells(ServedCells_t *servedCells, ServedCells__Member *member) {
    ASN_SEQUENCE_ADD(&servedCells->list, member);
}


static void buildInitiatingMessagePDU(E2AP_PDU_t &pdu, InitiatingMessage_t *initMsg) {
    pdu.present = E2AP_PDU_PR_initiatingMessage;
    pdu.choice.initiatingMessage = initMsg;
}

template<typename T>
static void buildInitMsg(InitiatingMessage_t &initMsg,
                         InitiatingMessage__value_PR present,
                         ProcedureCode_t procedureCode,
                         Criticality_t criticality,
                         T *value) {
    initMsg.value.present = present;
    initMsg.procedureCode = procedureCode;
    initMsg.criticality = criticality;

    switch (present) {
        case InitiatingMessage__value_PR_RICsubscriptionRequest: {
            memcpy(&initMsg.value.choice.RICsubscriptionRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_RICsubscriptionDeleteRequest: {
            memcpy(&initMsg.value.choice.RICsubscriptionDeleteRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_RICserviceUpdate: {
            memcpy(&initMsg.value.choice.RICserviceUpdate, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_RICcontrolRequest: {
            memcpy(&initMsg.value.choice.RICcontrolRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_X2SetupRequest: {
            memcpy(&initMsg.value.choice.X2SetupRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ENDCX2SetupRequest: {
            memcpy(&initMsg.value.choice.ENDCX2SetupRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ResourceStatusRequest: {
            memcpy(&initMsg.value.choice.ResourceStatusRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ENBConfigurationUpdate: {
            memcpy(&initMsg.value.choice.ENBConfigurationUpdate, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ENDCConfigurationUpdate: {
            memcpy(&initMsg.value.choice.ENDCConfigurationUpdate, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ResetRequest: {
            memcpy(&initMsg.value.choice.ResetRequest, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_RICindication: {
            memcpy(&initMsg.value.choice.RICindication, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_RICserviceQuery: {
            memcpy(&initMsg.value.choice.RICserviceQuery, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_LoadInformation: {
            memcpy(&initMsg.value.choice.LoadInformation, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_GNBStatusIndication: {
            memcpy(&initMsg.value.choice.GNBStatusIndication, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ResourceStatusUpdate: {
            memcpy(&initMsg.value.choice.ResourceStatusUpdate, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_ErrorIndication: {
            memcpy(&initMsg.value.choice.ErrorIndication, value, sizeof(*value));
            break;
        }
        case InitiatingMessage__value_PR_NOTHING:
        default : {
            break;
        }
    }
}

static void buildSuccsesfulMessagePDU(E2AP_PDU_t &pdu, SuccessfulOutcome_t *succMsg) {
    pdu.present = E2AP_PDU_PR_successfulOutcome;
    pdu.choice.successfulOutcome = succMsg;
}

template<typename T>
static void buildSuccMsg(SuccessfulOutcome_t &succMsg,
                         SuccessfulOutcome__value_PR present,
                         ProcedureCode_t procedureCode,
                         Criticality_t criticality,
                         T *value) {
    succMsg.value.present = present;
    succMsg.procedureCode = procedureCode;
    succMsg.criticality = criticality;

    switch (present) {
        case SuccessfulOutcome__value_PR_RICsubscriptionResponse: {
            memcpy(&succMsg.value.choice.RICsubscriptionResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_RICsubscriptionDeleteResponse: {
            memcpy(&succMsg.value.choice.RICsubscriptionDeleteResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_RICserviceUpdateAcknowledge: {
            memcpy(&succMsg.value.choice.RICserviceUpdateAcknowledge, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_RICcontrolAcknowledge: {
            memcpy(&succMsg.value.choice.RICcontrolAcknowledge, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_X2SetupResponse: {
            memcpy(&succMsg.value.choice.X2SetupResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_ENDCX2SetupResponse: {
            memcpy(&succMsg.value.choice.ENDCX2SetupResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_ResourceStatusResponse: {
            memcpy(&succMsg.value.choice.ResourceStatusResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_ENBConfigurationUpdateAcknowledge: {
            memcpy(&succMsg.value.choice.ENBConfigurationUpdateAcknowledge, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_ENDCConfigurationUpdateAcknowledge: {
            memcpy(&succMsg.value.choice.ENDCConfigurationUpdateAcknowledge, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_ResetResponse: {
            memcpy(&succMsg.value.choice.ResetResponse, value, sizeof(*value));
            break;
        }
        case SuccessfulOutcome__value_PR_NOTHING:
        default:
            break;
    }
}


static void buildUnSucssesfullMessagePDU(E2AP_PDU_t &pdu, UnsuccessfulOutcome_t *unSuccMsg) {
    pdu.present = E2AP_PDU_PR_unsuccessfulOutcome;
    pdu.choice.unsuccessfulOutcome = unSuccMsg;
}

template<typename T>
static void buildUnSuccMsg(UnsuccessfulOutcome_t &unSuccMsg,
                           UnsuccessfulOutcome__value_PR present,
                           ProcedureCode_t procedureCode,
                           Criticality_t criticality,
                           T *value) {
    unSuccMsg.value.present = present;
    unSuccMsg.procedureCode = procedureCode;
    unSuccMsg.criticality = criticality;

    switch (present) {
        case UnsuccessfulOutcome__value_PR_RICsubscriptionFailure: {
            memcpy(&unSuccMsg.value.choice.RICsubscriptionFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_RICsubscriptionDeleteFailure: {
            memcpy(&unSuccMsg.value.choice.RICsubscriptionDeleteFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_RICserviceUpdateFailure: {
            memcpy(&unSuccMsg.value.choice.RICserviceUpdateFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_RICcontrolFailure: {
            memcpy(&unSuccMsg.value.choice.RICcontrolFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_X2SetupFailure: {
            memcpy(&unSuccMsg.value.choice.X2SetupFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_ENDCX2SetupFailure: {
            memcpy(&unSuccMsg.value.choice.ENDCX2SetupFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_ResourceStatusFailure: {
            memcpy(&unSuccMsg.value.choice.ResourceStatusFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_ENBConfigurationUpdateFailure: {
            memcpy(&unSuccMsg.value.choice.ENBConfigurationUpdateFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_ENDCConfigurationUpdateFailure: {
            memcpy(&unSuccMsg.value.choice.ENDCConfigurationUpdateFailure, value, sizeof(*value));
            break;
        }
        case UnsuccessfulOutcome__value_PR_NOTHING:
        default:
            break;
    }
}


static void createPLMN_ID(PLMN_Identity_t &plmnId, const unsigned char *data) {
    //printEntry("PLMN_Identity_t", __func__)
    //PLMN_Identity_t *plmnId = calloc(1, sizeof(PLMN_Identity_t));
    ASN_STRUCT_RESET(asn_DEF_PLMN_Identity, &plmnId);
    plmnId.size = 3;
    plmnId.buf = (uint8_t *) calloc(1, 3);
    memcpy(plmnId.buf, data, 3);

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_PLMN_Identity, &plmnId, (char *) "PLMN_Identity_t", __func__);
    }

}

static void createENB_ID(ENB_ID_t &enb, ENB_ID_PR enbType, unsigned char *data) {
    //printEntry("ENB_ID_t", __func__)
    ASN_STRUCT_RESET(asn_DEF_ENB_ID, &enb);
    enb.present = enbType;
    switch (enbType) {
        case ENB_ID_PR_macro_eNB_ID: { // 20 bit 3 bytes
            enb.choice.macro_eNB_ID.size = 3;
            enb.choice.macro_eNB_ID.bits_unused = 4;

            enb.present = ENB_ID_PR_macro_eNB_ID;

            enb.choice.macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.macro_eNB_ID.size);
            data[enb.choice.macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.macro_eNB_ID.size - 1]
                    >> (unsigned) enb.choice.macro_eNB_ID.bits_unused)
                    << (unsigned) enb.choice.macro_eNB_ID.bits_unused);
            memcpy(enb.choice.macro_eNB_ID.buf, data, enb.choice.macro_eNB_ID.size);

            break;
        }
        case ENB_ID_PR_home_eNB_ID: { // 28 bit 4 bytes
            enb.choice.home_eNB_ID.size = 4;
            enb.choice.home_eNB_ID.bits_unused = 4;
            enb.present = ENB_ID_PR_home_eNB_ID;

            enb.choice.home_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.home_eNB_ID.size);
            data[enb.choice.home_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.home_eNB_ID.size - 1]
                    >> (unsigned) enb.choice.home_eNB_ID.bits_unused)
                    << (unsigned) enb.choice.home_eNB_ID.bits_unused);
            memcpy(enb.choice.home_eNB_ID.buf, data, enb.choice.home_eNB_ID.size);
            break;
        }
        case ENB_ID_PR_short_Macro_eNB_ID: { // 18 bit - 3 bytes
            enb.choice.short_Macro_eNB_ID.size = 3;
            enb.choice.short_Macro_eNB_ID.bits_unused = 6;
            enb.present = ENB_ID_PR_short_Macro_eNB_ID;

            enb.choice.short_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.short_Macro_eNB_ID.size);
            data[enb.choice.short_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.short_Macro_eNB_ID.size - 1]
                    >> (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused)
                    << (unsigned) enb.choice.short_Macro_eNB_ID.bits_unused);
            memcpy(enb.choice.short_Macro_eNB_ID.buf, data, enb.choice.short_Macro_eNB_ID.size);
            break;
        }
        case ENB_ID_PR_long_Macro_eNB_ID: { // 21
            enb.choice.long_Macro_eNB_ID.size = 3;
            enb.choice.long_Macro_eNB_ID.bits_unused = 3;
            enb.present = ENB_ID_PR_long_Macro_eNB_ID;

            enb.choice.long_Macro_eNB_ID.buf = (uint8_t *) calloc(1, enb.choice.long_Macro_eNB_ID.size);
            data[enb.choice.long_Macro_eNB_ID.size - 1] = ((unsigned) (data[enb.choice.long_Macro_eNB_ID.size - 1]
                    >> (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused)
                    << (unsigned) enb.choice.long_Macro_eNB_ID.bits_unused);
            memcpy(enb.choice.long_Macro_eNB_ID.buf, data, enb.choice.long_Macro_eNB_ID.size);
            break;
        }
        default:
            break;
    }

    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_ENB_ID, &enb, (char *) "ENB_ID_t", __func__);
    }
}


static void buildGlobalENB_ID(GlobalENB_ID_t *gnbId,
                              const unsigned char *gnbData,
                              ENB_ID_PR enbType,
                              unsigned char *enbData) {
    createPLMN_ID(gnbId->pLMN_Identity, gnbData);
    createENB_ID(gnbId->eNB_ID, enbType, enbData);
    if (mdclog_level_get() >= MDCLOG_DEBUG) {
        checkAndPrint(&asn_DEF_GlobalENB_ID, gnbId, (char *) "GlobalENB_ID_t", __func__);
    }
}

#endif //E2_E2BUILDER_H