ns-o-ran-scp-ric-app-kpimon/control/e2sm.go

/*
==================================================================================
  Copyright (c) 2019 AT&T Intellectual Property.
  Copyright (c) 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.
==================================================================================
*/

package control

/*
#include <libe2proto/wrapper.h>
#cgo LDFLAGS: -le2proto -lm
#cgo CFLAGS: -I/usr/local/include/libe2proto
*/
import "C"

import (
	"bytes"
	"encoding/binary"
	"errors"
	"strconv"
	"unsafe"
)

type E2sm struct {
}

func (c *E2sm) SetEventTriggerDefinition(buffer []byte, eventTriggerCount int, RTPeriods []int64) (newBuffer []byte, err error) {
	cptr := unsafe.Pointer(&buffer[0])
	periods := unsafe.Pointer(&RTPeriods[0])
	size := C.e2sm_encode_ric_event_trigger_definition(cptr, C.size_t(len(buffer)), C.size_t(eventTriggerCount), (*C.long)(periods))
	if size < 0 {
		return make([]byte, 0), errors.New("e2sm wrapper is unable to set EventTriggerDefinition due to wrong or invalid input")
	}
	newBuffer = C.GoBytes(cptr, (C.int(size)+7)/8)
	return
}

func (c *E2sm) SetActionDefinition(buffer []byte, ricStyleType int64) (newBuffer []byte, err error) {
	cptr := unsafe.Pointer(&buffer[0])
	size := C.e2sm_encode_ric_action_definition(cptr, C.size_t(len(buffer)), C.long(ricStyleType))
	if size < 0 {
		return make([]byte, 0), errors.New("e2sm wrapper is unable to set ActionDefinition due to wrong or invalid input")
	}
	newBuffer = C.GoBytes(cptr, (C.int(size)+7)/8)
	return
}

func (c *E2sm) GetIndicationHeader(buffer []byte) (indHdr *IndicationHeader, err error) {
	cptr := unsafe.Pointer(&buffer[0])
	indHdr = &IndicationHeader{}
	decodedHdr := C.e2sm_decode_ric_indication_header(cptr, C.size_t(len(buffer)))
	if decodedHdr == nil {
		return indHdr, errors.New("e2sm wrapper is unable to get IndicationHeader due to wrong or invalid input")
	}
	defer C.e2sm_free_ric_indication_header(decodedHdr)

	indHdr.IndHdrType = int32(decodedHdr.present)
	if indHdr.IndHdrType == 1 {
		indHdrFormat1 := &IndicationHeaderFormat1{}
		indHdrFormat1_C := *(**C.E2SM_KPM_IndicationHeader_Format1_t)(unsafe.Pointer(&decodedHdr.choice[0]))

		// Decode and analysis of GlobalE2node_ID
		if uintptr(unsafe.Pointer(&indHdrFormat1_C.id_GlobalE2node_ID)) != uintptr(0) {
			globalKPMnodeID_C := (C.GlobalE2node_ID_t)(indHdrFormat1_C.id_GlobalE2node_ID)

			indHdrFormat1.GlobalKPMnodeIDType = int32(globalKPMnodeID_C.present)
			if indHdrFormat1.GlobalKPMnodeIDType == 1 {
				globalgNBID := &GlobalKPMnodegNBIDType{}
				globalgNBID_C := *(**C.GlobalKPMnode_gNB_ID_t)(unsafe.Pointer(&globalKPMnodeID_C.choice[0]))

				plmnID_C := globalgNBID_C.global_gNB_ID.plmn_id
				globalgNBID.GlobalgNBID.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID_C.buf), C.int(plmnID_C.size))
				globalgNBID.GlobalgNBID.PlmnID.Size = int(plmnID_C.size)

				globalgNBID_gNBID_C := globalgNBID_C.global_gNB_ID.gnb_id
				globalgNBID.GlobalgNBID.GnbIDType = int(globalgNBID_gNBID_C.present)
				if globalgNBID.GlobalgNBID.GnbIDType == 1 {
					gNBID := &GNBID{}
					gNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalgNBID_gNBID_C.choice[0]))

					gNBID.Buf = C.GoBytes(unsafe.Pointer(gNBID_C.buf), C.int(gNBID_C.size))
					gNBID.Size = int(gNBID_C.size)
					gNBID.BitsUnused = int(gNBID_C.bits_unused)

					globalgNBID.GlobalgNBID.GnbID = gNBID
				}

				if globalgNBID_C.gNB_CU_UP_ID != nil {
					globalgNBID.GnbCUUPID = &Integer{}
					globalgNBID.GnbCUUPID.Buf = C.GoBytes(unsafe.Pointer(globalgNBID_C.gNB_CU_UP_ID.buf), C.int(globalgNBID_C.gNB_CU_UP_ID.size))
					globalgNBID.GnbCUUPID.Size = int(globalgNBID_C.gNB_CU_UP_ID.size)
				}

				if globalgNBID_C.gNB_DU_ID != nil {
					globalgNBID.GnbDUID = &Integer{}
					globalgNBID.GnbDUID.Buf = C.GoBytes(unsafe.Pointer(globalgNBID_C.gNB_DU_ID.buf), C.int(globalgNBID_C.gNB_DU_ID.size))
					globalgNBID.GnbDUID.Size = int(globalgNBID_C.gNB_DU_ID.size)
				}

				indHdrFormat1.GlobalKPMnodeID = globalgNBID
			} else if indHdrFormat1.GlobalKPMnodeIDType == 2 {
				globalengNBID := &GlobalKPMnodeengNBIDType{}
				globalengNBID_C := *(**C.GlobalKPMnode_en_gNB_ID_t)(unsafe.Pointer(&globalKPMnodeID_C.choice[0]))

				plmnID_C := globalengNBID_C.global_gNB_ID.pLMN_Identity
				globalengNBID.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID_C.buf), C.int(plmnID_C.size))
				globalengNBID.PlmnID.Size = int(plmnID_C.size)

				globalengNBID_gNBID_C := globalengNBID_C.global_gNB_ID.gNB_ID
				globalengNBID.GnbIDType = int(globalengNBID_gNBID_C.present)
				if globalengNBID.GnbIDType == 1 {
					engNBID := &ENGNBID{}
					engNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalengNBID_gNBID_C.choice[0]))

					engNBID.Buf = C.GoBytes(unsafe.Pointer(engNBID_C.buf), C.int(engNBID_C.size))
					engNBID.Size = int(engNBID_C.size)
					engNBID.BitsUnused = int(engNBID_C.bits_unused)

					globalengNBID.GnbID = engNBID
				}

				indHdrFormat1.GlobalKPMnodeID = globalengNBID
			} else if indHdrFormat1.GlobalKPMnodeIDType == 3 {
				globalngeNBID := &GlobalKPMnodengeNBIDType{}
				globalngeNBID_C := *(**C.GlobalKPMnode_ng_eNB_ID_t)(unsafe.Pointer(&globalKPMnodeID_C.choice[0]))

				plmnID_C := globalngeNBID_C.global_ng_eNB_ID.plmn_id
				globalngeNBID.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID_C.buf), C.int(plmnID_C.size))
				globalngeNBID.PlmnID.Size = int(plmnID_C.size)

				globalngeNBID_eNBID_C := globalngeNBID_C.global_ng_eNB_ID.enb_id
				globalngeNBID.EnbIDType = int(globalngeNBID_eNBID_C.present)
				if globalngeNBID.EnbIDType == 1 {
					ngeNBID := &NGENBID_Macro{}
					ngeNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalngeNBID_eNBID_C.choice[0]))

					ngeNBID.Buf = C.GoBytes(unsafe.Pointer(ngeNBID_C.buf), C.int(ngeNBID_C.size))
					ngeNBID.Size = int(ngeNBID_C.size)
					ngeNBID.BitsUnused = int(ngeNBID_C.bits_unused)

					globalngeNBID.EnbID = ngeNBID
				} else if globalngeNBID.EnbIDType == 2 {
					ngeNBID := &NGENBID_ShortMacro{}
					ngeNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalngeNBID_eNBID_C.choice[0]))

					ngeNBID.Buf = C.GoBytes(unsafe.Pointer(ngeNBID_C.buf), C.int(ngeNBID_C.size))
					ngeNBID.Size = int(ngeNBID_C.size)
					ngeNBID.BitsUnused = int(ngeNBID_C.bits_unused)

					globalngeNBID.EnbID = ngeNBID
				} else if globalngeNBID.EnbIDType == 3 {
					ngeNBID := &NGENBID_LongMacro{}
					ngeNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalngeNBID_eNBID_C.choice[0]))

					ngeNBID.Buf = C.GoBytes(unsafe.Pointer(ngeNBID_C.buf), C.int(ngeNBID_C.size))
					ngeNBID.Size = int(ngeNBID_C.size)
					ngeNBID.BitsUnused = int(ngeNBID_C.bits_unused)

					globalngeNBID.EnbID = ngeNBID
				}

				indHdrFormat1.GlobalKPMnodeID = globalngeNBID
			} else if indHdrFormat1.GlobalKPMnodeIDType == 4 {
				globaleNBID := &GlobalKPMnodeeNBIDType{}
				globaleNBID_C := *(**C.GlobalKPMnode_eNB_ID_t)(unsafe.Pointer(&globalKPMnodeID_C.choice[0]))

				plmnID_C := globaleNBID_C.global_eNB_ID.pLMN_Identity
				globaleNBID.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID_C.buf), C.int(plmnID_C.size))
				globaleNBID.PlmnID.Size = int(plmnID_C.size)

				globaleNBID_eNBID_C := globaleNBID_C.global_eNB_ID.eNB_ID
				globaleNBID.EnbIDType = int(globaleNBID_eNBID_C.present)
				if globaleNBID.EnbIDType == 1 {
					eNBID := &ENBID_Macro{}
					eNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globaleNBID_eNBID_C.choice[0]))

					eNBID.Buf = C.GoBytes(unsafe.Pointer(eNBID_C.buf), C.int(eNBID_C.size))
					eNBID.Size = int(eNBID_C.size)
					eNBID.BitsUnused = int(eNBID_C.bits_unused)

					globaleNBID.EnbID = eNBID
				} else if globaleNBID.EnbIDType == 2 {
					eNBID := &ENBID_Home{}
					eNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globaleNBID_eNBID_C.choice[0]))

					eNBID.Buf = C.GoBytes(unsafe.Pointer(eNBID_C.buf), C.int(eNBID_C.size))
					eNBID.Size = int(eNBID_C.size)
					eNBID.BitsUnused = int(eNBID_C.bits_unused)

					globaleNBID.EnbID = eNBID
				} else if globaleNBID.EnbIDType == 3 {
					eNBID := &ENBID_ShortMacro{}
					eNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globaleNBID_eNBID_C.choice[0]))

					eNBID.Buf = C.GoBytes(unsafe.Pointer(eNBID_C.buf), C.int(eNBID_C.size))
					eNBID.Size = int(eNBID_C.size)
					eNBID.BitsUnused = int(eNBID_C.bits_unused)

					globaleNBID.EnbID = eNBID
				} else if globaleNBID.EnbIDType == 4 {
					eNBID := &ENBID_LongMacro{}
					eNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globaleNBID_eNBID_C.choice[0]))

					eNBID.Buf = C.GoBytes(unsafe.Pointer(eNBID_C.buf), C.int(eNBID_C.size))
					eNBID.Size = int(eNBID_C.size)
					eNBID.BitsUnused = int(eNBID_C.bits_unused)

					globaleNBID.EnbID = eNBID
				}

				indHdrFormat1.GlobalKPMnodeID = globaleNBID
			}
		} else {
			indHdrFormat1.GlobalKPMnodeIDType = 0
		}

		// Decode and analysis of CollectionStartTime
		if uintptr(unsafe.Pointer(&indHdrFormat1_C.collectionStartTime)) != uintptr(0) {
			indHdrFormat1.CollectionStartTime = &OctetString{}

			indHdrFormat1.CollectionStartTime.Buf = C.GoBytes(unsafe.Pointer(indHdrFormat1_C.collectionStartTime.buf), C.int(indHdrFormat1_C.collectionStartTime.size))
			indHdrFormat1.CollectionStartTime.Size = int(indHdrFormat1_C.collectionStartTime.size)
		}

		// if indHdrFormat1_C.nRCGI != nil {
		// 	indHdrFormat1.NRCGI = &NRCGIType{}

		// 	plmnID := indHdrFormat1_C.nRCGI.pLMN_Identity
		// 	indHdrFormat1.NRCGI.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID.buf), C.int(plmnID.size))
		// 	indHdrFormat1.NRCGI.PlmnID.Size = int(plmnID.size)

		// 	nRCellID := indHdrFormat1_C.nRCGI.nRCellIdentity
		// 	indHdrFormat1.NRCGI.NRCellID.Buf = C.GoBytes(unsafe.Pointer(nRCellID.buf), C.int(nRCellID.size))
		// 	indHdrFormat1.NRCGI.NRCellID.Size = int(nRCellID.size)
		// 	indHdrFormat1.NRCGI.NRCellID.BitsUnused = int(nRCellID.bits_unused)
		// }

		// if indHdrFormat1_C.pLMN_Identity != nil {
		// 	indHdrFormat1.PlmnID = &OctetString{}

		// 	indHdrFormat1.PlmnID.Buf = C.GoBytes(unsafe.Pointer(indHdrFormat1_C.pLMN_Identity.buf), C.int(indHdrFormat1_C.pLMN_Identity.size))
		// 	indHdrFormat1.PlmnID.Size = int(indHdrFormat1_C.pLMN_Identity.size)
		// }

		// if indHdrFormat1_C.sliceID != nil {
		// 	indHdrFormat1.SliceID = &SliceIDType{}

		// 	sST := indHdrFormat1_C.sliceID.sST
		// 	indHdrFormat1.SliceID.SST.Buf = C.GoBytes(unsafe.Pointer(sST.buf), C.int(sST.size))
		// 	indHdrFormat1.SliceID.SST.Size = int(sST.size)

		// 	if indHdrFormat1_C.sliceID.sD != nil {
		// 		indHdrFormat1.SliceID.SD = &OctetString{}

		// 		sD := indHdrFormat1_C.sliceID.sD
		// 		indHdrFormat1.SliceID.SD.Buf = C.GoBytes(unsafe.Pointer(sD.buf), C.int(sD.size))
		// 		indHdrFormat1.SliceID.SD.Size = int(sD.size)
		// 	}
		// }

		// if indHdrFormat1_C.fiveQI != nil {
		// 	indHdrFormat1.FiveQI = int64(*indHdrFormat1_C.fiveQI)
		// } else {
		// 	indHdrFormat1.FiveQI = -1
		// }

		// if indHdrFormat1_C.qci != nil {
		// 	indHdrFormat1.Qci = int64(*indHdrFormat1_C.qci)
		// } else {
		// 	indHdrFormat1.Qci = -1
		// }

		// if indHdrFormat1_C.message_Type != nil {
		// 	indHdrFormat1.UeMessageType = int32(*indHdrFormat1_C.message_Type)
		// } else {
		// 	indHdrFormat1.UeMessageType = -1
		// }

		// if indHdrFormat1_C.gNB_DU_ID != nil {
		// 	indHdrFormat1.GnbDUID = &Integer{}

		// 	indHdrFormat1.GnbDUID.Buf = C.GoBytes(unsafe.Pointer(indHdrFormat1_C.gNB_DU_ID.buf), C.int(indHdrFormat1_C.gNB_DU_ID.size))
		// 	indHdrFormat1.GnbDUID.Size = int(indHdrFormat1_C.gNB_DU_ID.size)
		// }

		// if indHdrFormat1_C.gNB_Name != nil {
		// 	indHdrFormat1.GnbNameType = int32(indHdrFormat1_C.gNB_Name.present)
		// 	if indHdrFormat1.GnbNameType == 1 {
		// 		gNBName := &GNB_DU_Name{}
		// 		gNBName_C := (*C.GNB_DU_Name_t)(unsafe.Pointer(&indHdrFormat1_C.gNB_Name.choice[0]))

		// 		gNBName.Buf = C.GoBytes(unsafe.Pointer(gNBName_C.buf), C.int(gNBName_C.size))
		// 		gNBName.Size = int(gNBName_C.size)

		// 		indHdrFormat1.GnbName = gNBName
		// 	} else if indHdrFormat1.GnbNameType == 2 {
		// 		gNBName := &GNB_CU_CP_Name{}
		// 		gNBName_C := (*C.GNB_CU_CP_Name_t)(unsafe.Pointer(&indHdrFormat1_C.gNB_Name.choice[0]))

		// 		gNBName.Buf = C.GoBytes(unsafe.Pointer(gNBName_C.buf), C.int(gNBName_C.size))
		// 		gNBName.Size = int(gNBName_C.size)

		// 		indHdrFormat1.GnbName = gNBName
		// 	} else if indHdrFormat1.GnbNameType == 3 {
		// 		gNBName := &GNB_CU_UP_Name{}
		// 		gNBName_C := (*C.GNB_CU_UP_Name_t)(unsafe.Pointer(&indHdrFormat1_C.gNB_Name.choice[0]))

		// 		gNBName.Buf = C.GoBytes(unsafe.Pointer(gNBName_C.buf), C.int(gNBName_C.size))
		// 		gNBName.Size = int(gNBName_C.size)

		// 		indHdrFormat1.GnbName = gNBName
		// 	}
		// } else {
		// 	indHdrFormat1.GnbNameType = -1
		// }

		// if indHdrFormat1_C.global_GNB_ID != nil {
		// 	indHdrFormat1.GlobalgNBID = &GlobalgNBIDType{}

		// 	plmnID_C := indHdrFormat1_C.global_GNB_ID.plmn_id
		// 	indHdrFormat1.GlobalgNBID.PlmnID.Buf = C.GoBytes(unsafe.Pointer(plmnID_C.buf), C.int(plmnID_C.size))
		// 	indHdrFormat1.GlobalgNBID.PlmnID.Size = int(plmnID_C.size)

		// 	globalgNBID_gNBID_C := indHdrFormat1_C.global_GNB_ID.gnb_id
		// 	indHdrFormat1.GlobalgNBID.GnbIDType = int(globalgNBID_gNBID_C.present)
		// 	if indHdrFormat1.GlobalgNBID.GnbIDType == 1 {
		// 		gNBID := &GNBID{}
		// 		gNBID_C := (*C.BIT_STRING_t)(unsafe.Pointer(&globalgNBID_gNBID_C.choice[0]))

		// 		gNBID.Buf = C.GoBytes(unsafe.Pointer(gNBID_C.buf), C.int(gNBID_C.size))
		// 		gNBID.Size = int(gNBID_C.size)
		// 		gNBID.BitsUnused = int(gNBID_C.bits_unused)

		// 		indHdrFormat1.GlobalgNBID.GnbID = gNBID
		// 	}
		// }

		indHdr.IndHdr = indHdrFormat1
	} else {
		return indHdr, errors.New("Unknown RIC Indication Header type")
	}

	return
}

func (c *E2sm) GetIndicationMessage(buffer []byte) (indMsg *IndicationMessage, err error) {
	cptr := unsafe.Pointer(&buffer[0])
	indMsg = &IndicationMessage{}
	decodedIndicationMsg := C.e2sm_decode_ric_indication_message(cptr, C.size_t(len(buffer)))
	if decodedIndicationMsg == nil {
		return indMsg, errors.New("e2sm wrapper is unable to get IndicationMessage due to wrong or invalid input")
	}
	defer C.e2sm_free_ric_indication_message(decodedIndicationMsg)

	// indMsg.StyleType = int64(decodedIndicationMsg.ric_Style_Type)

	indMsg.IndMsgType = int32(decodedIndicationMsg.present)

	if indMsg.IndMsgType == 1 {
		indMsgFormat1 := &IndicationMessageFormat1{}
		indMsgFormat1_C := *(**C.E2SM_KPM_IndicationMessage_Format1_t)(unsafe.Pointer(&decodedIndicationMsg.choice[0]))

		indMsgFormat1.PMContainerCount = int(indMsgFormat1_C.pm_Containers.list.count)
		for i := 0; i < indMsgFormat1.PMContainerCount; i++ {
			pmContainer := &indMsgFormat1.PMContainers[i]
			var sizeof_PM_Containers_List_t *C.PM_Containers_List_t
			pmContainer_C := *(**C.PM_Containers_List_t)(unsafe.Pointer(uintptr(unsafe.Pointer(indMsgFormat1_C.pm_Containers.list.array)) + (uintptr)(i)*unsafe.Sizeof(sizeof_PM_Containers_List_t)))

			if pmContainer_C.performanceContainer != nil {
				pfContainer := &PFContainerType{}

				pfContainer.ContainerType = int32(pmContainer_C.performanceContainer.present)

				if pfContainer.ContainerType == 1 {
					oDU_PF := &ODUPFContainerType{}
					oDU_PF_C := *(**C.ODU_PF_Container_t)(unsafe.Pointer(&pmContainer_C.performanceContainer.choice[0]))

					oDU_PF.CellResourceReportCount = int(oDU_PF_C.cellResourceReportList.list.count)
					for j := 0; j < oDU_PF.CellResourceReportCount; j++ {
						cellResourceReport := &oDU_PF.CellResourceReports[j]
						var sizeof_CellResourceReportListItem_t *C.CellResourceReportListItem_t
						cellResourceReport_C := *(**C.CellResourceReportListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(oDU_PF_C.cellResourceReportList.list.array)) + (uintptr)(j)*unsafe.Sizeof(sizeof_CellResourceReportListItem_t)))

						cellResourceReport.NRCGI.PlmnID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.pLMN_Identity.buf), C.int(cellResourceReport_C.nRCGI.pLMN_Identity.size))
						cellResourceReport.NRCGI.PlmnID.Size = int(cellResourceReport_C.nRCGI.pLMN_Identity.size)

						cellResourceReport.NRCGI.NRCellID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.nRCellIdentity.buf), C.int(cellResourceReport_C.nRCGI.nRCellIdentity.size))
						cellResourceReport.NRCGI.NRCellID.Size = int(cellResourceReport_C.nRCGI.nRCellIdentity.size)
						cellResourceReport.NRCGI.NRCellID.BitsUnused = int(cellResourceReport_C.nRCGI.nRCellIdentity.bits_unused)

						if cellResourceReport_C.dl_TotalofAvailablePRBs != nil {
							cellResourceReport.TotalofAvailablePRBs.DL = int64(*cellResourceReport_C.dl_TotalofAvailablePRBs)
						} else {
							cellResourceReport.TotalofAvailablePRBs.DL = -1
						}

						if cellResourceReport_C.ul_TotalofAvailablePRBs != nil {
							cellResourceReport.TotalofAvailablePRBs.UL = int64(*cellResourceReport_C.ul_TotalofAvailablePRBs)
						} else {
							cellResourceReport.TotalofAvailablePRBs.UL = -1
						}

						cellResourceReport.ServedPlmnPerCellCount = int(cellResourceReport_C.servedPlmnPerCellList.list.count)
						for k := 0; k < cellResourceReport.ServedPlmnPerCellCount; k++ {
							servedPlmnPerCell := cellResourceReport.ServedPlmnPerCells[k]
							var sizeof_ServedPlmnPerCellListItem_t *C.ServedPlmnPerCellListItem_t
							servedPlmnPerCell_C := *(**C.ServedPlmnPerCellListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cellResourceReport_C.servedPlmnPerCellList.list.array)) + (uintptr)(k)*unsafe.Sizeof(sizeof_ServedPlmnPerCellListItem_t)))

							servedPlmnPerCell.PlmnID.Buf = C.GoBytes(unsafe.Pointer(servedPlmnPerCell_C.pLMN_Identity.buf), C.int(servedPlmnPerCell_C.pLMN_Identity.size))
							servedPlmnPerCell.PlmnID.Size = int(servedPlmnPerCell_C.pLMN_Identity.size)

							if servedPlmnPerCell_C.du_PM_5GC != nil {
								duPM5GC := &DUPM5GCContainerType{}
								duPM5GC_C := (*C.FGC_DU_PM_Container_t)(servedPlmnPerCell_C.du_PM_5GC)

								duPM5GC.SlicePerPlmnPerCellCount = int(duPM5GC_C.slicePerPlmnPerCellList.list.count)
								for l := 0; l < duPM5GC.SlicePerPlmnPerCellCount; l++ {
									slicePerPlmnPerCell := &duPM5GC.SlicePerPlmnPerCells[l]
									var sizeof_SlicePerPlmnPerCellListItem_t *C.SlicePerPlmnPerCellListItem_t
									slicePerPlmnPerCell_C := *(**C.SlicePerPlmnPerCellListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(duPM5GC_C.slicePerPlmnPerCellList.list.array)) + (uintptr)(l)*unsafe.Sizeof(sizeof_SlicePerPlmnPerCellListItem_t)))

									slicePerPlmnPerCell.SliceID.SST.Buf = C.GoBytes(unsafe.Pointer(slicePerPlmnPerCell_C.sliceID.sST.buf), C.int(slicePerPlmnPerCell_C.sliceID.sST.size))
									slicePerPlmnPerCell.SliceID.SST.Size = int(slicePerPlmnPerCell_C.sliceID.sST.size)

									if slicePerPlmnPerCell_C.sliceID.sD != nil {
										slicePerPlmnPerCell.SliceID.SD = &OctetString{}
										slicePerPlmnPerCell.SliceID.SD.Buf = C.GoBytes(unsafe.Pointer(slicePerPlmnPerCell_C.sliceID.sD.buf), C.int(slicePerPlmnPerCell_C.sliceID.sD.size))
										slicePerPlmnPerCell.SliceID.SD.Size = int(slicePerPlmnPerCell_C.sliceID.sD.size)
									}

									slicePerPlmnPerCell.FQIPERSlicesPerPlmnPerCellCount = int(slicePerPlmnPerCell_C.fQIPERSlicesPerPlmnPerCellList.list.count)
									for m := 0; m < slicePerPlmnPerCell.FQIPERSlicesPerPlmnPerCellCount; m++ {
										fQIPerSlicesPerPlmnPerCell := &slicePerPlmnPerCell.FQIPERSlicesPerPlmnPerCells[m]
										var sizeof_FQIPERSlicesPerPlmnPerCellListItem_t *C.FQIPERSlicesPerPlmnPerCellListItem_t
										fQIPerSlicesPerPlmnPerCell_C := *(**C.FQIPERSlicesPerPlmnPerCellListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(slicePerPlmnPerCell_C.fQIPERSlicesPerPlmnPerCellList.list.array)) + (uintptr)(m)*unsafe.Sizeof(sizeof_FQIPERSlicesPerPlmnPerCellListItem_t)))

										fQIPerSlicesPerPlmnPerCell.FiveQI = int64(fQIPerSlicesPerPlmnPerCell_C.fiveQI)

										if fQIPerSlicesPerPlmnPerCell_C.dl_PRBUsage != nil {
											fQIPerSlicesPerPlmnPerCell.PrbUsage.DL = int64(*fQIPerSlicesPerPlmnPerCell_C.dl_PRBUsage)
										} else {
											fQIPerSlicesPerPlmnPerCell.PrbUsage.DL = -1
										}

										if fQIPerSlicesPerPlmnPerCell_C.ul_PRBUsage != nil {
											fQIPerSlicesPerPlmnPerCell.PrbUsage.UL = int64(*fQIPerSlicesPerPlmnPerCell_C.ul_PRBUsage)
										} else {
											fQIPerSlicesPerPlmnPerCell.PrbUsage.UL = -1
										}
									}
								}

								servedPlmnPerCell.DUPM5GC = duPM5GC
							}

							if servedPlmnPerCell_C.du_PM_EPC != nil {
								duPMEPC := &DUPMEPCContainerType{}
								duPMEPC_C := (*C.EPC_DU_PM_Container_t)(servedPlmnPerCell_C.du_PM_EPC)

								duPMEPC.PerQCIReportCount = int(duPMEPC_C.perQCIReportList_du.list.count)
								for l := 0; l < duPMEPC.PerQCIReportCount; l++ {
									perQCIReport := &duPMEPC.PerQCIReports[l]
									var sizeof_PerQCIReportListItem_t *C.PerQCIReportListItem_t
									perQCIReport_C := *(**C.PerQCIReportListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(duPMEPC_C.perQCIReportList_du.list.array)) + (uintptr)(l)*unsafe.Sizeof(sizeof_PerQCIReportListItem_t)))

									perQCIReport.QCI = int64(perQCIReport_C.qci)

									if perQCIReport_C.dl_PRBUsage != nil {
										perQCIReport.PrbUsage.DL = int64(*perQCIReport_C.dl_PRBUsage)
									} else {
										perQCIReport.PrbUsage.DL = -1
									}

									if perQCIReport_C.ul_PRBUsage != nil {
										perQCIReport.PrbUsage.UL = int64(*perQCIReport_C.ul_PRBUsage)
									} else {
										perQCIReport.PrbUsage.UL = -1
									}
								}

								servedPlmnPerCell.DUPMEPC = duPMEPC
							}
						}
					}

					pfContainer.Container = oDU_PF
				} else if pfContainer.ContainerType == 2 {
					oCU_CP_PF := &OCUCPPFContainerType{}
					oCU_CP_PF_C := *(**C.OCUCP_PF_Container_t)(unsafe.Pointer(&pmContainer_C.performanceContainer.choice[0]))

					// if oCU_CP_PF_C.gNB_CU_CP_Name != nil {
					// 	oCU_CP_PF.GNBCUCPName = &PrintableString{}
					// 	oCU_CP_PF.GNBCUCPName.Buf = C.GoBytes(unsafe.Pointer(oCU_CP_PF_C.gNB_CU_CP_Name.buf), C.int(oCU_CP_PF_C.gNB_CU_CP_Name.size))
					// 	oCU_CP_PF.GNBCUCPName.Size = int(oCU_CP_PF_C.gNB_CU_CP_Name.size)
					// }

					if oCU_CP_PF_C.cu_CP_Resource_Status.numberOfActive_UEs != nil {
						oCU_CP_PF.CUCPResourceStatus.NumberOfActiveUEs = int64(*oCU_CP_PF_C.cu_CP_Resource_Status.numberOfActive_UEs)
					}

					pfContainer.Container = oCU_CP_PF
				} else if pfContainer.ContainerType == 3 {
					oCU_UP_PF := &OCUUPPFContainerType{}
					oCU_UP_PF_C := *(**C.OCUUP_PF_Container_t)(unsafe.Pointer(&pmContainer_C.performanceContainer.choice[0]))

					// if oCU_UP_PF_C.gNB_CU_UP_Name != nil {
					// 	oCU_UP_PF.GNBCUUPName = &PrintableString{}
					// 	oCU_UP_PF.GNBCUUPName.Buf = C.GoBytes(unsafe.Pointer(oCU_UP_PF_C.gNB_CU_UP_Name.buf), C.int(oCU_UP_PF_C.gNB_CU_UP_Name.size))
					// 	oCU_UP_PF.GNBCUUPName.Size = int(oCU_UP_PF_C.gNB_CU_UP_Name.size)
					// }

					oCU_UP_PF.CUUPPFContainerItemCount = int(oCU_UP_PF_C.pf_ContainerList.list.count)
					for j := 0; j < oCU_UP_PF.CUUPPFContainerItemCount; j++ {
						cuUPPFContainer := &oCU_UP_PF.CUUPPFContainerItems[j]
						var sizeof_PF_ContainerListItem_t *C.PF_ContainerListItem_t
						cuUPPFContainer_C := *(**C.PF_ContainerListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(oCU_UP_PF_C.pf_ContainerList.list.array)) + (uintptr)(j)*unsafe.Sizeof(sizeof_PF_ContainerListItem_t)))

						cuUPPFContainer.InterfaceType = int64(cuUPPFContainer_C.interface_type)

						cuUPPFContainer.OCUUPPMContainer.CUUPPlmnCount = int(cuUPPFContainer_C.o_CU_UP_PM_Container.plmnList.list.count)
						for k := 0; k < cuUPPFContainer.OCUUPPMContainer.CUUPPlmnCount; k++ {
							cuUPPlmn := &cuUPPFContainer.OCUUPPMContainer.CUUPPlmns[k]
							var sizeof_PlmnID_List_t *C.PlmnID_List_t
							cuUPPlmn_C := *(**C.PlmnID_List_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cuUPPFContainer_C.o_CU_UP_PM_Container.plmnList.list.array)) + (uintptr)(k)*unsafe.Sizeof(sizeof_PlmnID_List_t)))

							cuUPPlmn.PlmnID.Buf = C.GoBytes(unsafe.Pointer(cuUPPlmn_C.pLMN_Identity.buf), C.int(cuUPPlmn_C.pLMN_Identity.size))
							cuUPPlmn.PlmnID.Size = int(cuUPPlmn_C.pLMN_Identity.size)

							if cuUPPlmn_C.cu_UP_PM_5GC != nil {
								cuUPPM5GC := &CUUPPM5GCType{}
								cuUPPM5GC_C := (*C.FGC_CUUP_PM_Format_t)(cuUPPlmn_C.cu_UP_PM_5GC)

								cuUPPM5GC.SliceToReportCount = int(cuUPPM5GC_C.sliceToReportList.list.count)
								for l := 0; l < cuUPPM5GC.SliceToReportCount; l++ {
									sliceToReport := &cuUPPM5GC.SliceToReports[l]
									var sizeof_SliceToReportListItem_t *C.SliceToReportListItem_t
									sliceToReport_C := *(**C.SliceToReportListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cuUPPM5GC_C.sliceToReportList.list.array)) + (uintptr)(l)*unsafe.Sizeof(sizeof_SliceToReportListItem_t)))

									sliceToReport.SliceID.SST.Buf = C.GoBytes(unsafe.Pointer(sliceToReport_C.sliceID.sST.buf), C.int(sliceToReport_C.sliceID.sST.size))
									sliceToReport.SliceID.SST.Size = int(sliceToReport_C.sliceID.sST.size)

									if sliceToReport_C.sliceID.sD != nil {
										sliceToReport.SliceID.SD = &OctetString{}
										sliceToReport.SliceID.SD.Buf = C.GoBytes(unsafe.Pointer(sliceToReport_C.sliceID.sD.buf), C.int(sliceToReport_C.sliceID.sD.size))
										sliceToReport.SliceID.SD.Size = int(sliceToReport_C.sliceID.sD.size)
									}

									sliceToReport.FQIPERSlicesPerPlmnCount = int(sliceToReport_C.fQIPERSlicesPerPlmnList.list.count)
									for m := 0; m < sliceToReport.FQIPERSlicesPerPlmnCount; m++ {
										fQIPerSlicesPerPlmn := &sliceToReport.FQIPERSlicesPerPlmns[m]
										var sizeof_FQIPERSlicesPerPlmnListItem_t *C.FQIPERSlicesPerPlmnListItem_t
										fQIPerSlicesPerPlmn_C := *(**C.FQIPERSlicesPerPlmnListItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(sliceToReport_C.fQIPERSlicesPerPlmnList.list.array)) + (uintptr)(m)*unsafe.Sizeof(sizeof_FQIPERSlicesPerPlmnListItem_t)))

										fQIPerSlicesPerPlmn.FiveQI = int64(fQIPerSlicesPerPlmn_C.fiveQI)

										if fQIPerSlicesPerPlmn_C.pDCPBytesDL != nil {
											fQIPerSlicesPerPlmn.PDCPBytesDL = &Integer{}
											fQIPerSlicesPerPlmn.PDCPBytesDL.Buf = C.GoBytes(unsafe.Pointer(fQIPerSlicesPerPlmn_C.pDCPBytesDL.buf), C.int(fQIPerSlicesPerPlmn_C.pDCPBytesDL.size))
											fQIPerSlicesPerPlmn.PDCPBytesDL.Size = int(fQIPerSlicesPerPlmn_C.pDCPBytesDL.size)
										}

										if fQIPerSlicesPerPlmn_C.pDCPBytesUL != nil {
											fQIPerSlicesPerPlmn.PDCPBytesUL = &Integer{}
											fQIPerSlicesPerPlmn.PDCPBytesUL.Buf = C.GoBytes(unsafe.Pointer(fQIPerSlicesPerPlmn_C.pDCPBytesUL.buf), C.int(fQIPerSlicesPerPlmn_C.pDCPBytesUL.size))
											fQIPerSlicesPerPlmn.PDCPBytesUL.Size = int(fQIPerSlicesPerPlmn_C.pDCPBytesUL.size)
										}
									}
								}

								cuUPPlmn.CUUPPM5GC = cuUPPM5GC
							}

							if cuUPPlmn_C.cu_UP_PM_EPC != nil {
								cuUPPMEPC := &CUUPPMEPCType{}
								cuUPPMEPC_C := (*C.EPC_CUUP_PM_Format_t)(cuUPPlmn_C.cu_UP_PM_EPC)

								cuUPPMEPC.CUUPPMEPCPerQCIReportCount = int(cuUPPMEPC_C.perQCIReportList_cuup.list.count)
								for l := 0; l < cuUPPMEPC.CUUPPMEPCPerQCIReportCount; l++ {
									perQCIReport := &cuUPPMEPC.CUUPPMEPCPerQCIReports[l]
									var sizeof_PerQCIReportListItemFormat_t *C.PerQCIReportListItemFormat_t
									perQCIReport_C := *(**C.PerQCIReportListItemFormat_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cuUPPMEPC_C.perQCIReportList_cuup.list.array)) + (uintptr)(l)*unsafe.Sizeof(sizeof_PerQCIReportListItemFormat_t)))

									perQCIReport.QCI = int64(perQCIReport_C.drbqci)

									if perQCIReport_C.pDCPBytesDL != nil {
										perQCIReport.PDCPBytesDL = &Integer{}
										perQCIReport.PDCPBytesDL.Buf = C.GoBytes(unsafe.Pointer(perQCIReport_C.pDCPBytesDL.buf), C.int(perQCIReport_C.pDCPBytesDL.size))
										perQCIReport.PDCPBytesDL.Size = int(perQCIReport_C.pDCPBytesDL.size)
									}

									if perQCIReport_C.pDCPBytesUL != nil {
										perQCIReport.PDCPBytesUL = &Integer{}
										perQCIReport.PDCPBytesUL.Buf = C.GoBytes(unsafe.Pointer(perQCIReport_C.pDCPBytesUL.buf), C.int(perQCIReport_C.pDCPBytesUL.size))
										perQCIReport.PDCPBytesUL.Size = int(perQCIReport_C.pDCPBytesUL.size)
									}
								}

								cuUPPlmn.CUUPPMEPC = cuUPPMEPC
							}
						}
					}

					pfContainer.Container = oCU_UP_PF
				} else {
					return indMsg, errors.New("Unknown PF Container type")
				}

				pmContainer.PFContainer = pfContainer
			}

			if pmContainer_C.theRANContainer != nil {
				ranContainer := &RANContainerType{}

				// TODO: parse correctly Octect String
				// ranContainer.Buf = C.GoBytes(unsafe.Pointer(pmContainer_C.theRANContainer), C.int(pmContainer_C.theRANContainer.size))
				// ranContainer.Size = int(pmContainer_C.theRANContainer.size)

				// ranContainer.ContainerType = int32(pmContainer_C.theRANContainer.reportContainer.present)

				// if ranContainer.ContainerType == 1 {
				// 	oDU_UE := &DUUsageReportType{}
				// 	oDU_UE_C := *(**C.DU_Usage_Report_Per_UE_t)(unsafe.Pointer(&pmContainer_C.theRANContainer.reportContainer.choice[0]))

				// 	oDU_UE.CellResourceReportItemCount = int(oDU_UE_C.cellResourceReportList.list.count)
				// 	for j := 0; j < oDU_UE.CellResourceReportItemCount; j++ {
				// 		cellResourceReport := &oDU_UE.CellResourceReportItems[j]
				// 		var sizeof_DU_Usage_Report_CellResourceReportItem_t *C.DU_Usage_Report_CellResourceReportItem_t
				// 		cellResourceReport_C := *(**C.DU_Usage_Report_CellResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(oDU_UE_C.cellResourceReportList.list.array)) + (uintptr)(j)*unsafe.Sizeof(sizeof_DU_Usage_Report_CellResourceReportItem_t)))

				// 		cellResourceReport.NRCGI.PlmnID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.pLMN_Identity.buf), C.int(cellResourceReport_C.nRCGI.pLMN_Identity.size))
				// 		cellResourceReport.NRCGI.PlmnID.Size = int(cellResourceReport_C.nRCGI.pLMN_Identity.size)

				// 		cellResourceReport.NRCGI.NRCellID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.nRCellIdentity.buf), C.int(cellResourceReport_C.nRCGI.nRCellIdentity.size))
				// 		cellResourceReport.NRCGI.NRCellID.Size = int(cellResourceReport_C.nRCGI.nRCellIdentity.size)
				// 		cellResourceReport.NRCGI.NRCellID.BitsUnused = int(cellResourceReport_C.nRCGI.nRCellIdentity.bits_unused)

				// 		cellResourceReport.UeResourceReportItemCount = int(cellResourceReport_C.ueResourceReportList.list.count)
				// 		for k := 0; k < cellResourceReport.UeResourceReportItemCount; k++ {
				// 			ueResourceReport := &cellResourceReport.UeResourceReportItems[k]
				// 			var sizeof_DU_Usage_Report_UeResourceReportItem_t *C.DU_Usage_Report_UeResourceReportItem_t
				// 			ueResourceReport_C := *(**C.DU_Usage_Report_UeResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cellResourceReport_C.ueResourceReportList.list.array)) + (uintptr)(k)*unsafe.Sizeof(sizeof_DU_Usage_Report_UeResourceReportItem_t)))

				// 			ueResourceReport.CRNTI.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.c_RNTI.buf), C.int(ueResourceReport_C.c_RNTI.size))
				// 			ueResourceReport.CRNTI.Size = int(ueResourceReport_C.c_RNTI.size)

				// 			if ueResourceReport_C.dl_PRBUsage != nil {
				// 				ueResourceReport.PRBUsageDL = int64(*ueResourceReport_C.dl_PRBUsage)
				// 			} else {
				// 				ueResourceReport.PRBUsageDL = -1
				// 			}

				// 			if ueResourceReport_C.ul_PRBUsage != nil {
				// 				ueResourceReport.PRBUsageUL = int64(*ueResourceReport_C.ul_PRBUsage)
				// 			} else {
				// 				ueResourceReport.PRBUsageUL = -1
				// 			}
				// 		}
				// 	}

				// 	ranContainer.Container = oDU_UE
				// } else if ranContainer.ContainerType == 2 {
				// 	oCU_CP_UE := &CUCPUsageReportType{}
				// 	oCU_CP_UE_C := *(**C.CU_CP_Usage_Report_Per_UE_t)(unsafe.Pointer(&pmContainer_C.theRANContainer.reportContainer.choice[0]))

				// 	oCU_CP_UE.CellResourceReportItemCount = int(oCU_CP_UE_C.cellResourceReportList.list.count)
				// 	for j := 0; j < oCU_CP_UE.CellResourceReportItemCount; j++ {
				// 		cellResourceReport := &oCU_CP_UE.CellResourceReportItems[j]
				// 		var sizeof_CU_CP_Usage_Report_CellResourceReportItem_t *C.CU_CP_Usage_Report_CellResourceReportItem_t
				// 		cellResourceReport_C := *(**C.CU_CP_Usage_Report_CellResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(oCU_CP_UE_C.cellResourceReportList.list.array)) + (uintptr)(j)*unsafe.Sizeof(sizeof_CU_CP_Usage_Report_CellResourceReportItem_t)))

				// 		cellResourceReport.NRCGI.PlmnID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.pLMN_Identity.buf), C.int(cellResourceReport_C.nRCGI.pLMN_Identity.size))
				// 		cellResourceReport.NRCGI.PlmnID.Size = int(cellResourceReport_C.nRCGI.pLMN_Identity.size)

				// 		cellResourceReport.NRCGI.NRCellID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.nRCellIdentity.buf), C.int(cellResourceReport_C.nRCGI.nRCellIdentity.size))
				// 		cellResourceReport.NRCGI.NRCellID.Size = int(cellResourceReport_C.nRCGI.nRCellIdentity.size)
				// 		cellResourceReport.NRCGI.NRCellID.BitsUnused = int(cellResourceReport_C.nRCGI.nRCellIdentity.bits_unused)

				// 		cellResourceReport.UeResourceReportItemCount = int(cellResourceReport_C.ueResourceReportList.list.count)
				// 		for k := 0; k < cellResourceReport.UeResourceReportItemCount; k++ {
				// 			ueResourceReport := &cellResourceReport.UeResourceReportItems[k]
				// 			var sizeof_CU_CP_Usage_Report_UeResourceReportItem_t *C.CU_CP_Usage_Report_UeResourceReportItem_t
				// 			ueResourceReport_C := *(**C.CU_CP_Usage_Report_UeResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cellResourceReport_C.ueResourceReportList.list.array)) + (uintptr)(k)*unsafe.Sizeof(sizeof_CU_CP_Usage_Report_UeResourceReportItem_t)))

				// 			ueResourceReport.CRNTI.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.c_RNTI.buf), C.int(ueResourceReport_C.c_RNTI.size))
				// 			ueResourceReport.CRNTI.Size = int(ueResourceReport_C.c_RNTI.size)

				// 			if ueResourceReport_C.serving_Cell_RF_Type != nil {
				// 				ueResourceReport.ServingCellRF = &OctetString{}
				// 				ueResourceReport.ServingCellRF.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.serving_Cell_RF_Type.buf), C.int(ueResourceReport_C.serving_Cell_RF_Type.size))
				// 				ueResourceReport.ServingCellRF.Size = int(ueResourceReport_C.serving_Cell_RF_Type.size)
				// 			}

				// 			if ueResourceReport_C.neighbor_Cell_RF != nil {
				// 				ueResourceReport.NeighborCellRF = &OctetString{}
				// 				ueResourceReport.NeighborCellRF.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.neighbor_Cell_RF.buf), C.int(ueResourceReport_C.neighbor_Cell_RF.size))
				// 				ueResourceReport.NeighborCellRF.Size = int(ueResourceReport_C.neighbor_Cell_RF.size)
				// 			}
				// 		}
				// 	}

				// 	ranContainer.Container = oCU_CP_UE
				// } else if ranContainer.ContainerType == 3 {
				// 	oCU_UP_UE := &CUUPUsageReportType{}
				// 	oCU_UP_UE_C := *(**C.CU_UP_Usage_Report_Per_UE_t)(unsafe.Pointer(&pmContainer_C.theRANContainer.reportContainer.choice[0]))

				// 	oCU_UP_UE.CellResourceReportItemCount = int(oCU_UP_UE_C.cellResourceReportList.list.count)
				// 	for j := 0; j < oCU_UP_UE.CellResourceReportItemCount; j++ {
				// 		cellResourceReport := &oCU_UP_UE.CellResourceReportItems[j]
				// 		var sizeof_CU_UP_Usage_Report_CellResourceReportItem_t *C.CU_UP_Usage_Report_CellResourceReportItem_t
				// 		cellResourceReport_C := *(**C.CU_UP_Usage_Report_CellResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(oCU_UP_UE_C.cellResourceReportList.list.array)) + (uintptr)(j)*unsafe.Sizeof(sizeof_CU_UP_Usage_Report_CellResourceReportItem_t)))

				// 		cellResourceReport.NRCGI.PlmnID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.pLMN_Identity.buf), C.int(cellResourceReport_C.nRCGI.pLMN_Identity.size))
				// 		cellResourceReport.NRCGI.PlmnID.Size = int(cellResourceReport_C.nRCGI.pLMN_Identity.size)

				// 		cellResourceReport.NRCGI.NRCellID.Buf = C.GoBytes(unsafe.Pointer(cellResourceReport_C.nRCGI.nRCellIdentity.buf), C.int(cellResourceReport_C.nRCGI.nRCellIdentity.size))
				// 		cellResourceReport.NRCGI.NRCellID.Size = int(cellResourceReport_C.nRCGI.nRCellIdentity.size)
				// 		cellResourceReport.NRCGI.NRCellID.BitsUnused = int(cellResourceReport_C.nRCGI.nRCellIdentity.bits_unused)

				// 		cellResourceReport.UeResourceReportItemCount = int(cellResourceReport_C.ueResourceReportList.list.count)
				// 		for k := 0; k < cellResourceReport.UeResourceReportItemCount; k++ {
				// 			ueResourceReport := &cellResourceReport.UeResourceReportItems[k]
				// 			var sizeof_CU_UP_Usage_Report_UeResourceReportItem_t *C.CU_UP_Usage_Report_UeResourceReportItem_t
				// 			ueResourceReport_C := *(**C.CU_UP_Usage_Report_UeResourceReportItem_t)(unsafe.Pointer((uintptr)(unsafe.Pointer(cellResourceReport_C.ueResourceReportList.list.array)) + (uintptr)(k)*unsafe.Sizeof(sizeof_CU_UP_Usage_Report_UeResourceReportItem_t)))

				// 			ueResourceReport.CRNTI.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.c_RNTI.buf), C.int(ueResourceReport_C.c_RNTI.size))
				// 			ueResourceReport.CRNTI.Size = int(ueResourceReport_C.c_RNTI.size)

				// 			if ueResourceReport_C.pDCPBytesDL != nil {
				// 				ueResourceReport.PDCPBytesDL = &Integer{}
				// 				ueResourceReport.PDCPBytesDL.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.pDCPBytesDL.buf), C.int(ueResourceReport_C.pDCPBytesDL.size))
				// 				ueResourceReport.PDCPBytesDL.Size = int(ueResourceReport_C.pDCPBytesDL.size)
				// 			}

				// 			if ueResourceReport_C.pDCPBytesUL != nil {
				// 				ueResourceReport.PDCPBytesUL = &Integer{}
				// 				ueResourceReport.PDCPBytesUL.Buf = C.GoBytes(unsafe.Pointer(ueResourceReport_C.pDCPBytesUL.buf), C.int(ueResourceReport_C.pDCPBytesUL.size))
				// 				ueResourceReport.PDCPBytesUL.Size = int(ueResourceReport_C.pDCPBytesUL.size)
				// 			}
				// 		}
				// 	}

				// 	ranContainer.Container = oCU_UP_UE
				// } else {
				// 	return indMsg, errors.New("Unknown RAN Container type")
				// }

				pmContainer.RANContainer = ranContainer
			}
		}

		indMsg.IndMsg = indMsgFormat1
	} else {
		return indMsg, errors.New("Unknown RIC Indication Message Format")
	}

	return
}

func (c *E2sm) ParseNRCGI(nRCGI NRCGIType) (CellID string, err error) {
	var plmnID OctetString
	var nrCellID BitString

	plmnID = nRCGI.PlmnID
	CellID, _ = c.ParsePLMNIdentity(plmnID.Buf, plmnID.Size)

	nrCellID = nRCGI.NRCellID

	if plmnID.Size != 3 || nrCellID.Size != 5 {
		return "", errors.New("Invalid input: illegal length of NRCGI")
	}

	var former []uint8 = make([]uint8, 3)
	var latter []uint8 = make([]uint8, 6)

	former[0] = nrCellID.Buf[0] >> 4
	former[1] = nrCellID.Buf[0] & 0xf
	former[2] = nrCellID.Buf[1] >> 4
	latter[0] = nrCellID.Buf[1] & 0xf
	latter[1] = nrCellID.Buf[2] >> 4
	latter[2] = nrCellID.Buf[2] & 0xf
	latter[3] = nrCellID.Buf[3] >> 4
	latter[4] = nrCellID.Buf[3] & 0xf
	latter[5] = nrCellID.Buf[4] >> uint(nrCellID.BitsUnused)

	CellID = CellID + strconv.Itoa(int(former[0])) + strconv.Itoa(int(former[1])) + strconv.Itoa(int(former[2])) + strconv.Itoa(int(latter[0])) + strconv.Itoa(int(latter[1])) + strconv.Itoa(int(latter[2])) + strconv.Itoa(int(latter[3])) + strconv.Itoa(int(latter[4])) + strconv.Itoa(int(latter[5]))

	return
}

func (c *E2sm) ParsePLMNIdentity(buffer []byte, size int) (PlmnID string, err error) {
	if size != 3 {
		return "", errors.New("Invalid input: illegal length of PlmnID")
	}

	var mcc []uint8 = make([]uint8, 3)
	var mnc []uint8 = make([]uint8, 3)

	mcc[0] = buffer[0] >> 4
	mcc[1] = buffer[0] & 0xf
	mcc[2] = buffer[1] >> 4
	mnc[0] = buffer[1] & 0xf
	mnc[1] = buffer[2] >> 4
	mnc[2] = buffer[2] & 0xf

	if mnc[0] == 0xf {
		PlmnID = strconv.Itoa(int(mcc[0])) + strconv.Itoa(int(mcc[1])) + strconv.Itoa(int(mcc[2])) + strconv.Itoa(int(mnc[1])) + strconv.Itoa(int(mnc[2]))
	} else {
		PlmnID = strconv.Itoa(int(mcc[0])) + strconv.Itoa(int(mcc[1])) + strconv.Itoa(int(mcc[2])) + strconv.Itoa(int(mnc[0])) + strconv.Itoa(int(mnc[1])) + strconv.Itoa(int(mnc[2]))
	}

	return
}

func (c *E2sm) ParseSliceID(sliceID SliceIDType) (combined int32, err error) {
	if sliceID.SST.Size != 1 || (sliceID.SD != nil && sliceID.SD.Size != 3) {
		return 0, errors.New("Invalid input: illegal length of sliceID")
	}

	var temp uint8
	var sst int32
	var sd int32

	byteBuffer := bytes.NewBuffer(sliceID.SST.Buf)
	binary.Read(byteBuffer, binary.BigEndian, &temp)
	sst = int32(temp)

	if sliceID.SD == nil {
		combined = sst << 24
	} else {
		for i := 0; i < sliceID.SD.Size; i++ {
			byteBuffer = bytes.NewBuffer(sliceID.SD.Buf[i : i+1])
			binary.Read(byteBuffer, binary.BigEndian, &temp)
			sd = sd*256 + int32(temp)
		}
		combined = sst<<24 + sd
	}

	return
}

func (c *E2sm) ParseInteger(buffer []byte, size int) (value int64, err error) {
	var temp uint8
	var byteBuffer *bytes.Buffer

	for i := 0; i < size; i++ {
		byteBuffer = bytes.NewBuffer(buffer[i : i+1])
		binary.Read(byteBuffer, binary.BigEndian, &temp)
		value = value*256 + int64(temp)
	}

	return
}

func (c *E2sm) ParseTimestamp(buffer []byte, size int) (timestamp *Timestamp, err error) {
	var temp uint8
	var byteBuffer *bytes.Buffer
	var index int
	var sec int64
	var nsec int64

	for index := 0; index < size-8; index++ {
		byteBuffer = bytes.NewBuffer(buffer[index : index+1])
		binary.Read(byteBuffer, binary.BigEndian, &temp)
		sec = sec*256 + int64(temp)
	}

	for index = size - 8; index < size; index++ {
		byteBuffer = bytes.NewBuffer(buffer[index : index+1])
		binary.Read(byteBuffer, binary.BigEndian, &temp)
		nsec = nsec*256 + int64(temp)
	}

	timestamp = &Timestamp{TVsec: sec, TVnsec: nsec}
	return
}