package goap

type W3SecurityOwnerData struct {
	FullIdType
}

func (actor *W3SecurityOwnerData) GetSelfOrBase() (BaseApChain, bool) {
	return actor.FullIdType.GetSelfOrBase()
}

func (actor *W3SecurityOwnerData) MarshalToMap() map[string]any {
	return actor.FullIdType.MarshalToMapWithName(KEY_W3_SECURITY_OWNER)
}

func ParseW3SecurityOwnerData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseIdTypeWithName(raw, next, KEY_W3_SECURITY_OWNER)
	if err != nil {
		return nil, err
	}
	return &W3SecurityOwnerData{*tmp}, nil
}

// TODO: Handle case with multiple public keys (if allowed, idk if it is)

type W3SecurityPublicKeyData struct {
	Next  BaseApChain
	Id    string
	Owner string
	Key   string
}

func (publickeydata *W3SecurityPublicKeyData) GetSelfOrBase() (BaseApChain, bool) {
	return publickeydata.Next, true
}

func (publickeydata *W3SecurityPublicKeyData) MarshalToMap() map[string]any {
	m := publickeydata.Next.MarshalToMap()
	m[KEY_W3_SECURITY_PUBLICKEY] = []map[string]any{{
		KEY_ID:                       publickeydata.Id,
		KEY_W3_SECURITY_OWNER:        []map[string]any{{KEY_ID: publickeydata.Owner}},
		KEY_W3_SECURITY_PUBLICKEYPEM: []map[string]any{{KEY_VALUE: publickeydata.Key}},
	}}
	return m
}

func ParseW3SecurityPublicKeyData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	rawData1, ok := raw[KEY_W3_SECURITY_PUBLICKEY]
	if !ok {
		return nil, NoRequiredFieldError{KEY_W3_SECURITY_PUBLICKEY}
	}
	data1, ok := rawData1.([]map[string]any)
	if !ok {
		return nil, BadFieldValueError[[]map[string]any]{KEY_W3_SECURITY_PUBLICKEY, rawData1, data1}
	}
	if len(data1) != 1 {
		return nil, BadFieldArrayLengthError{KEY_W3_SECURITY_PUBLICKEY, 1, len(data1)}
	}
	Id, err := ParseIdValue(data1[0])
	if err != nil {
		return nil, err
	}
	rawPem, err := ParseW3SecurityPublicKeyPemData(data1[0], nil)
	if err != nil {
		return nil, err
	}
	rawOwner, err := ParseW3SecurityOwnerData(data1[0], nil)
	if err != nil {
		return nil, err
	}
	owner := rawOwner.(*W3SecurityOwnerData)

	pem := rawPem.(*W3SecurityPublicKeyPemData)
	return &W3SecurityPublicKeyData{
		Next:  next,
		Id:    Id.Id,
		Key:   pem.Value.Value,
		Owner: owner.Id,
	}, nil
}

type W3SecurityPublicKeyPemData struct {
	FullValueType[string]
}

func (namedata *W3SecurityPublicKeyPemData) GetSelfOrBase() (BaseApChain, bool) {
	return namedata.Next, true
}

func (namedata *W3SecurityPublicKeyPemData) MarshalToMap() map[string]any {
	return namedata.MarshalToMapWithName(KEY_W3_SECURITY_PUBLICKEYPEM)
}

func ParseW3SecurityPublicKeyPemData(raw map[string]any, next BaseApChain) (BaseApChain, error) {
	tmp, err := ParseValueTypeWithName[string](raw, next, KEY_W3_SECURITY_PUBLICKEYPEM)
	if err != nil {
		return nil, err
	}
	return &W3SecurityPublicKeyPemData{*tmp}, nil
}