/*
 * Copyright 2018-present Open Networking Foundation

 * 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 omci

import (
	"encoding/hex"
	"errors"
	"fmt"
	"math/rand"
	"strconv"

	"github.com/google/gopacket"
	"github.com/opencord/omci-lib-go/v2"
	me "github.com/opencord/omci-lib-go/v2/generated"
	"github.com/opencord/voltha-protos/v5/go/openolt"
	log "github.com/sirupsen/logrus"
)

func ParseGetRequest(omciPkt gopacket.Packet) (*omci.GetRequest, error) {
	msgLayer := omciPkt.Layer(omci.LayerTypeGetRequest)
	if msgLayer == nil {
		err := "omci Msg layer could not be detected for LayerTypeGetRequest"
		omciLogger.Error(err)
		return nil, errors.New(err)
	}
	msgObj, msgOk := msgLayer.(*omci.GetRequest)
	if !msgOk {
		err := "omci Msg layer could not be assigned for LayerTypeGetRequest"
		omciLogger.Error(err)
		return nil, errors.New(err)
	}
	return msgObj, nil
}

func CreateGetResponse(omciPkt gopacket.Packet, omciMsg *omci.OMCI, onuSn *openolt.SerialNumber, mds uint8,
	activeImageEntityId uint16, committedImageEntityId uint16, standbyImageVersion string, activeImageVersion string,
	committedImageVersion string, onuDown bool) ([]byte, error) {
	msgObj, err := ParseGetRequest(omciPkt)
	if err != nil {
		return nil, err
	}
	omciLogger.WithFields(log.Fields{
		"EntityClass":    msgObj.EntityClass,
		"EntityInstance": msgObj.EntityInstance,
		"AttributeMask":  fmt.Sprintf("%x", msgObj.AttributeMask),
	}).Trace("received-omci-get-request")

	var response *omci.GetResponse
	switch msgObj.EntityClass {
	case me.Onu2GClassID:
		response = createOnu2gResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.OnuGClassID:
		response = createOnugResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuSn)
	case me.SoftwareImageClassID:
		response = createSoftwareImageResponse(msgObj.AttributeMask, msgObj.EntityInstance,
			activeImageEntityId, committedImageEntityId, standbyImageVersion, activeImageVersion, committedImageVersion)
	case me.IpHostConfigDataClassID:
		response = createIpHostResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.VoipConfigDataClassID:
		response = createVoipConfigDataResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.UniGClassID:
		response = createUnigResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
	case me.PhysicalPathTerminationPointEthernetUniClassID:
		response = createPptpEthernetResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
	case me.PhysicalPathTerminationPointPotsUniClassID:
		response = createPptpPotsResponse(msgObj.AttributeMask, msgObj.EntityInstance, onuDown)
	case me.AniGClassID:
		response = createAnigResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.OnuDataClassID:
		response = createOnuDataResponse(msgObj.AttributeMask, msgObj.EntityInstance, mds)
	case me.EthernetFramePerformanceMonitoringHistoryDataUpstreamClassID:
		response = createEthernetFramePerformanceMonitoringHistoryDataUpstreamResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.EthernetFramePerformanceMonitoringHistoryDataDownstreamClassID:
		response = createEthernetFramePerformanceMonitoringHistoryDataDownstreamResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.EthernetPerformanceMonitoringHistoryDataClassID:
		response = createEthernetPerformanceMonitoringHistoryDataResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.FecPerformanceMonitoringHistoryDataClassID:
		response = createFecPerformanceMonitoringHistoryDataResponse(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.GemPortNetworkCtpPerformanceMonitoringHistoryDataClassID:
		response = createGemPortNetworkCtpPerformanceMonitoringHistoryData(msgObj.AttributeMask, msgObj.EntityInstance)
	case me.EthernetFrameExtendedPmClassID,
		me.EthernetFrameExtendedPm64BitClassID:
		response = createEthernetFrameExtendedPmGetResponse(msgObj.EntityClass, msgObj.AttributeMask, msgObj.EntityInstance)
	default:
		omciLogger.WithFields(log.Fields{
			"EntityClass":    msgObj.EntityClass,
			"EntityInstance": msgObj.EntityInstance,
			"AttributeMask":  fmt.Sprintf("%x", msgObj.AttributeMask),
		}).Warnf("do-not-know-how-to-handle-get-request-for-me-class")
		return nil, nil
	}

	pkt, err := Serialize(omci.GetResponseType, response, omciMsg.TransactionID)
	if err != nil {
		omciLogger.WithFields(log.Fields{
			"Err":  err,
			"TxID": strconv.FormatInt(int64(omciMsg.TransactionID), 16),
		}).Error("cannot-Serialize-GetResponse")
		return nil, err
	}

	log.WithFields(log.Fields{
		"TxID": strconv.FormatInt(int64(omciMsg.TransactionID), 16),
		"pkt":  hex.EncodeToString(pkt),
	}).Trace("omci-get-response")

	return pkt, nil
}

func createOnu2gResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {

	managedEntity, meErr := me.NewOnu2G(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:   entityID,
			me.Onu2G_EquipmentId: ToOctets("12345123451234512345", 20),
			me.Onu2G_OpticalNetworkUnitManagementAndControlChannelOmccVersion: 180,
			me.Onu2G_VendorProductCode:                                        0,
			me.Onu2G_SecurityCapability:                                       1,
			me.Onu2G_SecurityMode:                                             1,
			me.Onu2G_TotalPriorityQueueNumber:                                 1,
			me.Onu2G_TotalTrafficSchedulerNumber:                              1,
			me.Onu2G_Deprecated:                                               1,
			me.Onu2G_TotalGemPortIdNumber:                                     32,
			me.Onu2G_Sysuptime:                                                319389947, // NOTE need to be smarter?
			me.Onu2G_ConnectivityCapability:                                   127,
			me.Onu2G_CurrentConnectivityMode:                                  5,
			me.Onu2G_QualityOfServiceQosConfigurationFlexibility:              48,
			me.Onu2G_PriorityQueueScaleFactor:                                 1,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewOnu2G %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass: me.Onu2GClassID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createOnugResponse(attributeMask uint16, entityID uint16, onuSn *openolt.SerialNumber) *omci.GetResponse {

	managedEntity, meErr := me.NewOnuG(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:              entityID,
			me.OnuG_VendorId:                ToOctets("BBSM", 4),
			me.OnuG_Version:                 ToOctets("v0.0.1", 14),
			me.OnuG_SerialNumber:            append(onuSn.VendorId, onuSn.VendorSpecific...),
			me.OnuG_TrafficManagementOption: 0,
			me.OnuG_Deprecated:              0,
			me.OnuG_BatteryBackup:           0,
			me.OnuG_AdministrativeState:     0,
			me.OnuG_OperationalState:        0,
			me.OnuG_OnuSurvivalTime:         10,
			me.OnuG_LogicalOnuId:            ToOctets("BBSM", 24),
			me.OnuG_LogicalPassword:         ToOctets("BBSM", 12),
			me.OnuG_CredentialsStatus:       0,
			me.OnuG_ExtendedTcLayerOptions:  0,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewOnu2G %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass: me.OnuGClassID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}

	//return &omci.GetResponse{
	//	MeBasePacket: omci.MeBasePacket{
	//		EntityClass:    me.OnuGClassID,
	//		EntityInstance: entityID,
	//	},
	//	Attributes: me.AttributeValueMap{
	//
	//	},
	//	Result:        me.Success,
	//	AttributeMask: attributeMask,
	//}
}

func createSoftwareImageResponse(attributeMask uint16, entityInstance uint16, activeImageEntityId uint16,
	committedImageEntityId uint16, standbyImageVersion string, activeImageVersion string, committedImageVersion string) *omci.GetResponse {

	omciLogger.WithFields(log.Fields{
		"EntityInstance": entityInstance,
		"AttributeMask":  attributeMask,
	}).Trace("received-get-software-image-request")

	// Only one image can be active and committed
	committed := 0
	active := 0
	version := standbyImageVersion
	if entityInstance == activeImageEntityId {
		active = 1
		version = activeImageVersion
	}
	if entityInstance == committedImageEntityId {
		committed = 1
		version = committedImageVersion
	}

	imageHash, err := hex.DecodeString(hex.EncodeToString([]byte(version)))
	if err != nil {
		omciLogger.WithFields(log.Fields{
			"entityId":  entityInstance,
			"active":    active,
			"committed": committed,
			"err":       err,
		}).Error("cannot-generate-image-hash")
	}

	// NOTE that we need send the response for the correct ME Instance or the adapter won't process it
	res := &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.SoftwareImageClassID,
			EntityInstance: entityInstance,
		},
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:           0,
			me.SoftwareImage_Version:     ToOctets(version, 14),
			me.SoftwareImage_IsCommitted: committed,
			me.SoftwareImage_IsActive:    active,
			me.SoftwareImage_IsValid:     1,
			me.SoftwareImage_ProductCode: ToOctets("BBSIM-ONU", 25),
			me.SoftwareImage_ImageHash:   imageHash,
		},
		Result:        me.Success,
		AttributeMask: attributeMask,
	}

	omciLogger.WithFields(log.Fields{
		"omciMessage": res,
		"entityId":    entityInstance,
		"active":      active,
		"committed":   committed,
	}).Trace("Reporting SoftwareImage")

	return res
}

func createIpHostResponse(attributeMask uint16, entityInstance uint16) *omci.GetResponse {
	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.IpHostConfigDataClassID,
			EntityInstance: entityInstance,
		},
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:             0,
			me.IpHostConfigData_MacAddress: ToOctets("aabbcc", 6),
		},
		Result:        me.Success,
		AttributeMask: attributeMask,
	}
}

func createVoipConfigDataResponse(attributeMask uint16, entityInstance uint16) *omci.GetResponse {
	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.VoipConfigDataClassID,
			EntityInstance: entityInstance,
		},
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: 0,
			me.VoipConfigData_AvailableSignallingProtocols:      1,
			me.VoipConfigData_SignallingProtocolUsed:            1,
			me.VoipConfigData_AvailableVoipConfigurationMethods: 1,
			me.VoipConfigData_VoipConfigurationMethodUsed:       1,
			me.VoipConfigData_VoipConfigurationAddressPointer:   0xFFFF,
			me.VoipConfigData_VoipConfigurationState:            0,
			me.VoipConfigData_RetrieveProfile:                   0,
			me.VoipConfigData_ProfileVersion:                    0,
		},
		Result:        me.Success,
		AttributeMask: attributeMask,
	}
}

func createUnigResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
	omciAdminState := 1
	if !onuDown {
		omciAdminState = 0
	}
	managedEntity, meErr := me.NewUniG(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:                  entityID,
			me.UniG_Deprecated:                  0,
			me.UniG_AdministrativeState:         omciAdminState,
			me.UniG_ManagementCapability:        0,
			me.UniG_NonOmciManagementIdentifier: 1,
			me.UniG_RelayAgentOptions:           1,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewUniG %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.UniGClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createPptpEthernetResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
	// Valid values for oper_state are 0 (enabled) and 1 (disabled)
	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
	onuAdminState := 1
	if !onuDown {
		onuAdminState = 0
	}
	onuOperState := onuAdminState // For now make the assumption that oper state reflects the admin state
	managedEntity, meErr := me.NewPhysicalPathTerminationPointEthernetUni(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.PhysicalPathTerminationPointEthernetUni_ExpectedType:                  0,
			me.PhysicalPathTerminationPointEthernetUni_SensedType:                    0,
			me.PhysicalPathTerminationPointEthernetUni_AutoDetectionConfiguration:    0,
			me.PhysicalPathTerminationPointEthernetUni_EthernetLoopbackConfiguration: 0,
			me.PhysicalPathTerminationPointEthernetUni_AdministrativeState:           onuAdminState,
			me.PhysicalPathTerminationPointEthernetUni_OperationalState:              onuOperState,
			me.PhysicalPathTerminationPointEthernetUni_ConfigurationInd:              0,
			me.PhysicalPathTerminationPointEthernetUni_MaxFrameSize:                  0,
			me.PhysicalPathTerminationPointEthernetUni_DteOrDceInd:                   0,
			me.PhysicalPathTerminationPointEthernetUni_PauseTime:                     0,
			me.PhysicalPathTerminationPointEthernetUni_BridgedOrIpInd:                0,
			me.PhysicalPathTerminationPointEthernetUni_Arc:                           0,
			me.PhysicalPathTerminationPointEthernetUni_ArcInterval:                   0,
			me.PhysicalPathTerminationPointEthernetUni_PppoeFilter:                   0,
			me.PhysicalPathTerminationPointEthernetUni_PowerControl:                  0,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewPhysicalPathTerminationPointEthernetUni %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.PhysicalPathTerminationPointEthernetUniClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createPptpPotsResponse(attributeMask uint16, entityID uint16, onuDown bool) *omci.GetResponse {
	// Valid values for oper_state are 0 (enabled) and 1 (disabled)
	// Valid values for uni_admin_state are 0 (unlocks) and 1 (locks)
	onuAdminState := 1
	if !onuDown {
		onuAdminState = 0
	}
	onuOperState := onuAdminState // For now make the assumption that oper state reflects the admin state
	managedEntity, meErr := me.NewPhysicalPathTerminationPointPotsUni(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.PhysicalPathTerminationPointPotsUni_AdministrativeState: onuAdminState,
			me.PhysicalPathTerminationPointPotsUni_Deprecated:          0,
			me.PhysicalPathTerminationPointPotsUni_Arc:                 0,
			me.PhysicalPathTerminationPointPotsUni_ArcInterval:         0,
			me.PhysicalPathTerminationPointPotsUni_Impedance:           0,
			me.PhysicalPathTerminationPointPotsUni_TransmissionPath:    0,
			me.PhysicalPathTerminationPointPotsUni_RxGain:              0,
			me.PhysicalPathTerminationPointPotsUni_TxGain:              0,
			me.PhysicalPathTerminationPointPotsUni_OperationalState:    onuOperState,
			me.PhysicalPathTerminationPointPotsUni_HookState:           0,
			me.PhysicalPathTerminationPointPotsUni_PotsHoldoverTime:    0,
			me.PhysicalPathTerminationPointPotsUni_NominalFeedVoltage:  0,
			me.PhysicalPathTerminationPointPotsUni_LossOfSoftswitch:    0,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewPhysicalPathTerminationPointPotsUni %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.PhysicalPathTerminationPointPotsUniClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createEthernetFramePerformanceMonitoringHistoryDataUpstreamResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewEthernetFramePerformanceMonitoringHistoryDataUpstream(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_IntervalEndTime:         0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now.
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_ThresholdData12Id:       0,
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_DropEvents:              rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Octets:                  rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets:                 rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_BroadcastPackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_MulticastPackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_CrcErroredPackets:       rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_UndersizePackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_OversizePackets:         rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets64Octets:         rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets65To127Octets:    rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets128To255Octets:   rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets256To511Octets:   rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets512To1023Octets:  rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataUpstream_Packets1024To1518Octets: rand.Intn(100),
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewEthernetFramePerformanceMonitoringHistoryDataUpstream %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.EthernetFramePerformanceMonitoringHistoryDataUpstreamClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createEthernetFramePerformanceMonitoringHistoryDataDownstreamResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewEthernetFramePerformanceMonitoringHistoryDataDownstream(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_IntervalEndTime:         0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now.
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_ThresholdData12Id:       0,
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_DropEvents:              rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Octets:                  rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets:                 rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_BroadcastPackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_MulticastPackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_CrcErroredPackets:       rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_UndersizePackets:        rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_OversizePackets:         rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets64Octets:         rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets65To127Octets:    rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets128To255Octets:   rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets256To511Octets:   rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets512To1023Octets:  rand.Intn(100),
			me.EthernetFramePerformanceMonitoringHistoryDataDownstream_Packets1024To1518Octets: rand.Intn(100),
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewEthernetFramePerformanceMonitoringHistoryDataDownstream %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.EthernetFramePerformanceMonitoringHistoryDataDownstreamClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createEthernetPerformanceMonitoringHistoryDataResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewEthernetPerformanceMonitoringHistoryData(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.EthernetPerformanceMonitoringHistoryData_IntervalEndTime:                 0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now.
			me.EthernetPerformanceMonitoringHistoryData_ThresholdData12Id:               0,
			me.EthernetPerformanceMonitoringHistoryData_FcsErrors:                       rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_ExcessiveCollisionCounter:       rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_LateCollisionCounter:            rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_FramesTooLong:                   rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_BufferOverflowsOnReceive:        rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_BufferOverflowsOnTransmit:       rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_SingleCollisionFrameCounter:     rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_MultipleCollisionsFrameCounter:  rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_SqeCounter:                      rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_DeferredTransmissionCounter:     rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_InternalMacTransmitErrorCounter: rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_CarrierSenseErrorCounter:        rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_AlignmentErrorCounter:           rand.Intn(100),
			me.EthernetPerformanceMonitoringHistoryData_InternalMacReceiveErrorCounter:  rand.Intn(100),
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewEthernetPerformanceMonitoringHistoryData %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.EthernetPerformanceMonitoringHistoryDataClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createFecPerformanceMonitoringHistoryDataResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewFecPerformanceMonitoringHistoryData(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.FecPerformanceMonitoringHistoryData_IntervalEndTime:        0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now.
			me.FecPerformanceMonitoringHistoryData_ThresholdData12Id:      0,
			me.FecPerformanceMonitoringHistoryData_CorrectedBytes:         rand.Intn(100),
			me.FecPerformanceMonitoringHistoryData_CorrectedCodeWords:     rand.Intn(100),
			me.FecPerformanceMonitoringHistoryData_UncorrectableCodeWords: rand.Intn(100),
			me.FecPerformanceMonitoringHistoryData_TotalCodeWords:         rand.Intn(100),
			me.FecPerformanceMonitoringHistoryData_FecSeconds:             rand.Intn(100),
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewFecPerformanceMonitoringHistoryData %v", meErr.Error())
		return nil
	}

	// FEC History counter fits within single gem payload.
	// No need of the logical we use in other Ethernet History counters or Gem Port History counters

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.FecPerformanceMonitoringHistoryDataClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createGemPortNetworkCtpPerformanceMonitoringHistoryData(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewGemPortNetworkCtpPerformanceMonitoringHistoryData(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID: entityID,
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_IntervalEndTime:         0, // This ideally should increment by 1 every collection interval, but staying 0 for simulation is Ok for now.
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ThresholdData12Id:       0,
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_TransmittedGemFrames:    rand.Intn(100),
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ReceivedGemFrames:       rand.Intn(100),
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_ReceivedPayloadBytes:    rand.Intn(100),
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_TransmittedPayloadBytes: rand.Intn(100),
			me.GemPortNetworkCtpPerformanceMonitoringHistoryData_EncryptionKeyErrors:     rand.Intn(100),
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewGemPortNetworkCtpPerformanceMonitoringHistoryData %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.GemPortNetworkCtpPerformanceMonitoringHistoryDataClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createOnuDataResponse(attributeMask uint16, entityID uint16, mds uint8) *omci.GetResponse {
	managedEntity, meErr := me.NewOnuData(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:     entityID,
			me.OnuData_MibDataSync: mds,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewOnuData %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.OnuDataClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createAnigResponse(attributeMask uint16, entityID uint16) *omci.GetResponse {
	managedEntity, meErr := me.NewAniG(me.ParamData{
		EntityID: entityID,
		Attributes: me.AttributeValueMap{
			me.ManagedEntityID:                  entityID,
			me.AniG_SrIndication:                0,
			me.AniG_TotalTcontNumber:            0,
			me.AniG_GemBlockLength:              0,
			me.AniG_PiggybackDbaReporting:       0,
			me.AniG_Deprecated:                  0,
			me.AniG_SignalFailThreshold:         0,
			me.AniG_SignalDegradeThreshold:      0,
			me.AniG_Arc:                         0,
			me.AniG_ArcInterval:                 0,
			me.AniG_OpticalSignalLevel:          rand.Intn(16000), // generate some random power level than defaulting to 0
			me.AniG_LowerOpticalThreshold:       0,
			me.AniG_UpperOpticalThreshold:       0,
			me.AniG_OnuResponseTime:             0,
			me.AniG_TransmitOpticalLevel:        rand.Intn(16000), // generate some random power level than defaulting to 0
			me.AniG_LowerTransmitPowerThreshold: 0,
			me.AniG_UpperTransmitPowerThreshold: 0,
		},
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewAniG %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    me.AniGClassID,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func createEthernetFrameExtendedPmGetResponse(meClass me.ClassID, attributeMask uint16, entityID uint16) *omci.GetResponse {

	callback := me.NewEthernetFrameExtendedPm
	if meClass != me.EthernetFrameExtendedPmClassID {
		callback = me.NewEthernetFrameExtendedPm64Bit
	}

	//The names of these attributes are left as strings
	//rather than constants of a particular ME because
	//they can be used with both the MEs in the lines above
	attr := me.AttributeValueMap{
		me.ManagedEntityID:       entityID,
		"DropEvents":             100,
		"Octets":                 101,
		"Frames":                 102,
		"BroadcastFrames":        103,
		"MulticastFrames":        104,
		"CrcErroredFrames":       105,
		"UndersizeFrames":        106,
		"OversizeFrames":         107,
		"Frames64Octets":         108,
		"Frames65To127Octets":    109,
		"Frames128To255Octets":   110,
		"Frames256To511Octets":   111,
		"Frames512To1023Octets":  112,
		"Frames1024To1518Octets": 113,
	}
	managedEntity, meErr := callback(me.ParamData{
		EntityID:   entityID,
		Attributes: attr,
	})

	if meErr.GetError() != nil {
		omciLogger.Errorf("NewEthernetFrameExtendedPm %v", meErr.Error())
		return nil
	}

	return &omci.GetResponse{
		MeBasePacket: omci.MeBasePacket{
			EntityClass:    meClass,
			EntityInstance: entityID,
		},
		Attributes:    managedEntity.GetAttributeValueMap(),
		AttributeMask: attributeMask,
		Result:        me.Success,
	}
}

func ToOctets(str string, size int) []byte {
	asciiBytes := []byte(str)

	if len(asciiBytes) < size {
		missing := size - len(asciiBytes)
		for i := 0; i < missing; i++ {
			asciiBytes = append(asciiBytes, []byte{0x00}[0])
		}
	}
	return asciiBytes
}