package yabl

import (
	"encoding/json"
	"log"
	"reflect"
)

var rtSignedAirTemp8BitType = reflect.TypeOf((*SignedAirTemp8BitType)(nil))
var rtConnectedOut8bitType = reflect.TypeOf((*ConnectedOut8bitType)(nil))
var rtForceModeType = reflect.TypeOf((*ForceModeType)(nil))
var rtSignedVoltage12bitType = reflect.TypeOf((*SignedVoltage12bitType)(nil))
var rtDebugSwitchModeType = reflect.TypeOf((*DebugSwitchModeType)(nil))
var rtOtherError4BitType = reflect.TypeOf((*OtherError4BitType)(nil))
var rtContactorModeType = reflect.TypeOf((*ContactorModeType)(nil))
var rtPower14BitType = reflect.TypeOf((*Power14BitType)(nil))
var rtAuthStateType = reflect.TypeOf((*AuthStateType)(nil))
var rtAuthModeType = reflect.TypeOf((*AuthModeType)(nil))
var rtBoardReadyType = reflect.TypeOf((*BoardReadyType)(nil))
var rtBooleanType = reflect.TypeOf((*BooleanType)(nil))
var rtErrorType = reflect.TypeOf((*ErrorType)(nil))
var rtContactorInternalOtherErrorType = reflect.TypeOf((*ContactorInternalOtherErrorType)(nil))
var rtContactorGroupChangedType = reflect.TypeOf((*ContactorGroupChangedType)(nil))
var rtV2GModeType = reflect.TypeOf((*V2GModeType)(nil))
var rtVoltage11BitType = reflect.TypeOf((*Voltage11BitType)(nil))
var rtCurrent10BitType = reflect.TypeOf((*Current10BitType)(nil))
var rtCpLineLevelType = reflect.TypeOf((*CpLineLevelType)(nil))
var rtIsolationStateType = reflect.TypeOf((*IsolationStateType)(nil))
var rtVoltage9BitType = reflect.TypeOf((*Voltage9BitType)(nil))

var fieldHelperPrototypeMap = map[reflect.Type]fHelper{
	rtSignedAirTemp8BitType:           &signedAirTemp8BitTypeHelper{},
	rtConnectedOut8bitType:            &connectedOut8bitTypeHelper{},
	rtForceModeType:                   &forceModeTypeHelper{},
	rtSignedVoltage12bitType:          &signedVoltage12bitTypeHelper{},
	rtDebugSwitchModeType:             &debugSwitchModeTypeHelper{},
	rtOtherError4BitType:              &otherError4BitTypeHelper{},
	rtContactorModeType:               &contactorModeTypeHelper{},
	rtPower14BitType:                  &power14BitTypeHelper{},
	rtAuthStateType:                   &authStateTypeHelper{},
	rtAuthModeType:                    &authModeTypeHelper{},
	rtBoardReadyType:                  &boardReadyTypeHelper{},
	rtBooleanType:                     &booleanTypeHelper{},
	rtErrorType:                       &errorTypeHelper{},
	rtContactorInternalOtherErrorType: &contactorInternalOtherErrorTypeHelper{},
	rtContactorGroupChangedType:       &contactorGroupChangedTypeHelper{},
	rtV2GModeType:                     &v2GModeTypeHelper{},
	rtVoltage11BitType:                &voltage11BitTypeHelper{},
	rtCurrent10BitType:                &current10BitTypeHelper{},
	rtCpLineLevelType:                 &cpLineLevelTypeHelper{},
	rtIsolationStateType:              &isolationStateTypeHelper{},
	rtVoltage9BitType:                 &voltage9BitTypeHelper{},
}

type baseTypeHelper struct {
	rValue *reflect.Value
}

type signedAirTemp8BitTypeHelper struct {
	baseTypeHelper
}
type connectedOut8bitTypeHelper struct {
	baseTypeHelper
}
type forceModeTypeHelper struct {
	baseTypeHelper
}
type signedVoltage12bitTypeHelper struct {
	baseTypeHelper
}
type debugSwitchModeTypeHelper struct {
	baseTypeHelper
}
type otherError4BitTypeHelper struct {
	baseTypeHelper
}
type contactorModeTypeHelper struct {
	baseTypeHelper
}
type power14BitTypeHelper struct {
	baseTypeHelper
}
type authStateTypeHelper struct {
	baseTypeHelper
}
type authModeTypeHelper struct {
	baseTypeHelper
}
type boardReadyTypeHelper struct {
	baseTypeHelper
}
type booleanTypeHelper struct {
	baseTypeHelper
}
type errorTypeHelper struct {
	baseTypeHelper
}
type contactorInternalOtherErrorTypeHelper struct {
	baseTypeHelper
}
type contactorGroupChangedTypeHelper struct {
	baseTypeHelper
}
type v2GModeTypeHelper struct {
	baseTypeHelper
}
type voltage11BitTypeHelper struct {
	baseTypeHelper
}
type current10BitTypeHelper struct {
	baseTypeHelper
}
type cpLineLevelTypeHelper struct {
	baseTypeHelper
}
type isolationStateTypeHelper struct {
	baseTypeHelper
}
type voltage9BitTypeHelper struct {
	baseTypeHelper
}

func (b *baseTypeHelper) setReflectedValue(value *reflect.Value) {
	b.rValue = value
}

func (b *baseTypeHelper) getSize() uint8 {
	panic("Type size not properly determined")
}

func getMask(size uint8) uint64 {
	var mask uint64 = ^(ALL_BITS << size)
	return mask
}

func (s *signedAirTemp8BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(s.getSize()) {
		var v *SignedAirTemp8BitType
		s.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := SignedAirTemp8BitType(frame - 67)
	reflVal := reflect.ValueOf(&value)
	s.rValue.Set(reflVal)
	return &value
}

func (s *signedAirTemp8BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(s.getSize())
	var entity *SignedAirTemp8BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := SignedAirTemp8BitType(val)
		entity = &v
		result = uint64(v+67) & result
	case string:
		v := SignedAirTemp8BitType(0)
		entity = &v
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v+67) & result
	}

	s.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *connectedOut8bitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *ConnectedOut8bitType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ConnectedOut8bitType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *connectedOut8bitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *ConnectedOut8bitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ConnectedOut8bitType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ConnectedOut8bitType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (f *forceModeTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(f.getSize()) {
		var v *ForceModeType
		f.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ForceModeType(frame)
	reflVal := reflect.ValueOf(&value)
	f.rValue.Set(reflVal)
	return &value
}

func (f *forceModeTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(f.getSize())
	var entity *ForceModeType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ForceModeType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ForceModeType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	f.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (s *signedVoltage12bitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(s.getSize()) {
		var v *SignedVoltage12bitType
		s.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := SignedVoltage12bitType(frame - 1000)
	reflVal := reflect.ValueOf(&value)
	s.rValue.Set(reflVal)
	return &value
}

func (s *signedVoltage12bitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(s.getSize())
	var entity *SignedVoltage12bitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := SignedVoltage12bitType(val)
		entity = &v
		result = uint64(v+1000) & result
	case string:
		v := SignedVoltage12bitType(0)
		entity = &v
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v+1000) & result
	}

	s.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (d *debugSwitchModeTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(d.getSize()) {
		var v *DebugSwitchModeType
		d.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := DebugSwitchModeType(frame)
	reflVal := reflect.ValueOf(&value)
	d.rValue.Set(reflVal)
	return &value
}

func (d *debugSwitchModeTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(d.getSize())
	var entity *DebugSwitchModeType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := DebugSwitchModeType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := DebugSwitchModeType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	d.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (o *otherError4BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(o.getSize()) {
		var v *OtherError4BitType
		o.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := OtherError4BitType(frame)
	reflVal := reflect.ValueOf(&value)
	o.rValue.Set(reflVal)
	return &value
}

func (o *otherError4BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(o.getSize())
	var entity *OtherError4BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := OtherError4BitType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := OtherError4BitType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	o.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *contactorModeTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *ContactorModeType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ContactorModeType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *contactorModeTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *ContactorModeType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ContactorModeType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ContactorModeType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (p *power14BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(p.getSize()) {
		var v *Power14BitType
		p.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := Power14BitType(frame * 100)
	reflVal := reflect.ValueOf(&value)
	p.rValue.Set(reflVal)
	return &value
}

func (p *power14BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(p.getSize())
	var entity *Power14BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := Power14BitType(val)
		entity = &v
		result = uint64(v/100) & result
	case string:
		v := Power14BitType(0)
		entity = &v
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v/100) & result
	}

	p.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (a *authStateTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(a.getSize()) {
		var v *AuthStateType
		a.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := AuthStateType(frame)
	reflVal := reflect.ValueOf(&value)
	a.rValue.Set(reflVal)
	return &value
}

func (a *authStateTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(a.getSize())
	var entity *AuthStateType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := AuthStateType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := AuthStateType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	a.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (a *authModeTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(a.getSize()) {
		var v *AuthModeType
		a.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := AuthModeType(frame)
	reflVal := reflect.ValueOf(&value)
	a.rValue.Set(reflVal)
	return &value
}

func (a *authModeTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(a.getSize())
	var entity *AuthModeType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := AuthModeType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := AuthModeType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	a.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (b *boardReadyTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(b.getSize()) {
		var v *BoardReadyType
		b.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := BoardReadyType(frame)
	reflVal := reflect.ValueOf(&value)
	b.rValue.Set(reflVal)
	return &value
}

func (b *boardReadyTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(b.getSize())
	var entity *BoardReadyType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := BoardReadyType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := BoardReadyType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	b.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (b *booleanTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(b.getSize()) {
		var v *BooleanType
		b.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := BooleanType(frame)
	reflVal := reflect.ValueOf(&value)
	b.rValue.Set(reflVal)
	return &value
}

func (b *booleanTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(b.getSize())
	var entity *BooleanType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := BooleanType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := BooleanType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	b.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (e *errorTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(e.getSize()) {
		var v *ErrorType
		e.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ErrorType(frame)
	reflVal := reflect.ValueOf(&value)
	e.rValue.Set(reflVal)
	return &value
}

func (e *errorTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(e.getSize())
	var entity *ErrorType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ErrorType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ErrorType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	e.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *contactorInternalOtherErrorTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *ContactorInternalOtherErrorType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ContactorInternalOtherErrorType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *contactorInternalOtherErrorTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *ContactorInternalOtherErrorType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ContactorInternalOtherErrorType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ContactorInternalOtherErrorType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *contactorGroupChangedTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *ContactorGroupChangedType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := ContactorGroupChangedType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *contactorGroupChangedTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *ContactorGroupChangedType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := ContactorGroupChangedType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := ContactorGroupChangedType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (v *v2GModeTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(v.getSize()) {
		var val *V2GModeType
		v.rValue.Set(reflect.ValueOf(val))
		return nil
	}

	value := V2GModeType(frame)
	reflVal := reflect.ValueOf(&value)
	v.rValue.Set(reflVal)
	return &value
}

func (v *v2GModeTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(v.getSize())
	var entity *V2GModeType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := V2GModeType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := V2GModeType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	v.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (v *voltage11BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(v.getSize()) {
		var val *Voltage11BitType
		v.rValue.Set(reflect.ValueOf(val))
		return nil
	}

	value := Voltage11BitType(frame)
	reflVal := reflect.ValueOf(&value)
	v.rValue.Set(reflVal)
	return &value
}

func (v *voltage11BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(v.getSize())
	var entity *Voltage11BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := Voltage11BitType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := Voltage11BitType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	v.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *current10BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *Current10BitType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := Current10BitType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *current10BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *Current10BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := Current10BitType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := Current10BitType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (c *cpLineLevelTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(c.getSize()) {
		var v *CpLineLevelType
		c.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := CpLineLevelType(frame)
	reflVal := reflect.ValueOf(&value)
	c.rValue.Set(reflVal)
	return &value
}

func (c *cpLineLevelTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(c.getSize())
	var entity *CpLineLevelType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := CpLineLevelType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := CpLineLevelType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	c.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (i *isolationStateTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(i.getSize()) {
		var v *IsolationStateType
		i.rValue.Set(reflect.ValueOf(v))
		return nil
	}

	value := IsolationStateType(frame)
	reflVal := reflect.ValueOf(&value)
	i.rValue.Set(reflVal)
	return &value
}

func (i *isolationStateTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(i.getSize())
	// TODO Implement this
	var entity *IsolationStateType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := IsolationStateType(val)
		entity = &v
		result = uint64(v) & result
	case string:
		v := IsolationStateType(0)
		entity = &v
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64(v) & result
	}

	i.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (v *voltage9BitTypeHelper) fromBus(frame uint64) any {
	if frame == getMask(v.getSize()) {
		var val *Voltage9BitType
		v.rValue.Set(reflect.ValueOf(val))
		return nil
	}

	value := Voltage9BitType(frame)*0.1 - 15
	reflVal := reflect.ValueOf(&value)
	v.rValue.Set(reflVal)
	return &value
}

func (v *voltage9BitTypeHelper) toBus(value any) uint64 {
	var result uint64 = getMask(v.getSize())
	var entity *Voltage9BitType = nil

	switch val := value.(type) {
	case nil:
		// do nothing
	case int:
		v := Voltage9BitType(val)
		entity = &v
		result = uint64((v+15)*10) & result
	case string:
		v := Voltage9BitType(0)
		entity = &v
		// TODO Implement this
		if err := json.Unmarshal([]byte(val), entity); err != nil {
			log.Println(err)
			entity = nil
			break
		}
		result = uint64((v+15)*10) & result
	}

	v.rValue.Set(reflect.ValueOf(entity))
	return result
}

func (s *signedAirTemp8BitTypeHelper) getSize() uint8 {
	return signedAirTemp8BitTypeSize
}

func (c *connectedOut8bitTypeHelper) getSize() uint8 {
	return connectedOut8bitTypeSize
}

func (f *forceModeTypeHelper) getSize() uint8 {
	return forceModeTypeSize
}

func (s *signedVoltage12bitTypeHelper) getSize() uint8 {
	return signedVoltage12bitTypeSize
}

func (d *debugSwitchModeTypeHelper) getSize() uint8 {
	return debugSwitchModeTypeSize
}

func (o *otherError4BitTypeHelper) getSize() uint8 {
	return otherError4BitTypeSize
}

func (c *contactorModeTypeHelper) getSize() uint8 {
	return contactorModeTypeSize
}

func (p *power14BitTypeHelper) getSize() uint8 {
	return power14BitTypeSize
}

func (a *authStateTypeHelper) getSize() uint8 {
	return authStateTypeSize
}

func (a *authModeTypeHelper) getSize() uint8 {
	return authModeTypeSize
}

func (b *boardReadyTypeHelper) getSize() uint8 {
	return boardReadyTypeSize
}

func (b *booleanTypeHelper) getSize() uint8 {
	return booleanTypeSize
}

func (e *errorTypeHelper) getSize() uint8 {
	return errorTypeSize
}

func (c *contactorInternalOtherErrorTypeHelper) getSize() uint8 {
	return contactorInternalOtherErrorTypeSize
}

func (c *contactorGroupChangedTypeHelper) getSize() uint8 {
	return contactorGroupChangedTypeSize
}

func (v *v2GModeTypeHelper) getSize() uint8 {
	return v2GModeTypeSize
}

func (v *voltage11BitTypeHelper) getSize() uint8 {
	return voltage11BitTypeSize
}

func (c *current10BitTypeHelper) getSize() uint8 {
	return current10BitTypeSize
}

func (c *cpLineLevelTypeHelper) getSize() uint8 {
	return cpLineLevelTypeSize
}

func (i *isolationStateTypeHelper) getSize() uint8 {
	return isolationStateTypeSize
}

func (v *voltage9BitTypeHelper) getSize() uint8 {
	return voltage9BitTypeSize
}