/*
==================================================================================
  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 <e2sm/wrapper.h>
#cgo LDFLAGS: -le2smwrapper
#cgo CFLAGS: -I/usr/local/include/e2sm
*/
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]))

		if indHdrFormat1_C.id_GlobalKPMnode_ID != nil {
			globalKPMnodeID_C := (*C.GlobalKPMnode_ID_t)(indHdrFormat1_C.id_GlobalKPMnode_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
		}

		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{}
	decodedMsg := C.e2sm_decode_ric_indication_message(cptr, C.size_t(len(buffer)))
	if decodedMsg == 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(decodedMsg)

	indMsg.StyleType = int64(decodedMsg.ric_Style_Type)

	indMsg.IndMsgType = int32(decodedMsg.indicationMessage.present)

	if indMsg.IndMsgType == 1 {
		indMsgFormat1 := &IndicationMessageFormat1{}
		indMsgFormat1_C := *(**C.E2SM_KPM_IndicationMessage_Format1_t)(unsafe.Pointer(&decodedMsg.indicationMessage.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.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.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.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.list.array)) + (uintptr)(l)*unsafe.Sizeof(sizeof_PerQCIReportListItemFormat_t)))

									perQCIReport.QCI = int64(perQCIReport_C.qci)

									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{}

				ranContainer.Timestamp.Buf = C.GoBytes(unsafe.Pointer(pmContainer_C.theRANContainer.timestamp.buf), C.int(pmContainer_C.theRANContainer.timestamp.size))
				ranContainer.Timestamp.Size = int(pmContainer_C.theRANContainer.timestamp.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
}