package object

import (
	"fmt"

	object "github.com/nspcc-dev/neofs-api-go/v2/object/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/refs"
	refsGRPC "github.com/nspcc-dev/neofs-api-go/v2/refs/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/session"
)

func TypeToGRPCField(t Type) object.ObjectType {
	return object.ObjectType(t)
}

func TypeFromGRPCField(t object.ObjectType) Type {
	return Type(t)
}

func MatchTypeToGRPCField(t MatchType) object.MatchType {
	return object.MatchType(t)
}

func MatchTypeFromGRPCField(t object.MatchType) MatchType {
	return MatchType(t)
}

func ShortHeaderToGRPCMessage(h *ShortHeader) *object.ShortHeader {
	if h == nil {
		return nil
	}

	m := new(object.ShortHeader)

	m.SetVersion(
		refs.VersionToGRPCMessage(h.GetVersion()),
	)

	m.SetCreationEpoch(h.GetCreationEpoch())

	m.SetOwnerId(
		refs.OwnerIDToGRPCMessage(h.GetOwnerID()),
	)

	m.SetObjectType(
		TypeToGRPCField(h.GetObjectType()),
	)

	m.SetPayloadLength(h.GetPayloadLength())

	m.SetPayloadHash(
		refs.ChecksumToGRPCMessage(h.GetPayloadHash()),
	)

	m.SetHomomorphicHash(
		refs.ChecksumToGRPCMessage(h.GetHomomorphicHash()),
	)

	return m
}

func ShortHeaderFromGRPCMessage(m *object.ShortHeader) *ShortHeader {
	if m == nil {
		return nil
	}

	h := new(ShortHeader)

	h.SetVersion(
		refs.VersionFromGRPCMessage(m.GetVersion()),
	)

	h.SetCreationEpoch(m.GetCreationEpoch())

	h.SetOwnerID(
		refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
	)

	h.SetObjectType(
		TypeFromGRPCField(m.GetObjectType()),
	)

	h.SetPayloadLength(m.GetPayloadLength())

	h.SetPayloadHash(
		refs.ChecksumFromGRPCMessage(m.GetPayloadHash()),
	)

	h.SetHomomorphicHash(
		refs.ChecksumFromGRPCMessage(m.GetHomomorphicHash()),
	)

	return h
}

func AttributeToGRPCMessage(a *Attribute) *object.Header_Attribute {
	if a == nil {
		return nil
	}

	m := new(object.Header_Attribute)

	m.SetKey(a.GetKey())
	m.SetValue(a.GetValue())

	return m
}

func AttributeFromGRPCMessage(m *object.Header_Attribute) *Attribute {
	if m == nil {
		return nil
	}

	h := new(Attribute)

	h.SetKey(m.GetKey())
	h.SetValue(m.GetValue())

	return h
}

func SplitHeaderToGRPCMessage(h *SplitHeader) *object.Header_Split {
	if h == nil {
		return nil
	}

	m := new(object.Header_Split)

	m.SetParent(
		refs.ObjectIDToGRPCMessage(h.GetParent()),
	)

	m.SetPrevious(
		refs.ObjectIDToGRPCMessage(h.GetPrevious()),
	)

	m.SetParentSignature(
		refs.SignatureToGRPCMessage(h.GetParentSignature()),
	)

	m.SetParentHeader(
		HeaderToGRPCMessage(h.GetParentHeader()),
	)

	children := h.GetChildren()
	childMsg := make([]*refsGRPC.ObjectID, 0, len(children))

	for i := range children {
		childMsg = append(childMsg, refs.ObjectIDToGRPCMessage(children[i]))
	}

	m.SetChildren(childMsg)

	m.SetSplitId(h.GetSplitID())

	return m
}

func SplitHeaderFromGRPCMessage(m *object.Header_Split) *SplitHeader {
	if m == nil {
		return nil
	}

	h := new(SplitHeader)

	h.SetParent(
		refs.ObjectIDFromGRPCMessage(m.GetParent()),
	)

	h.SetPrevious(
		refs.ObjectIDFromGRPCMessage(m.GetPrevious()),
	)

	h.SetParentSignature(
		refs.SignatureFromGRPCMessage(m.GetParentSignature()),
	)

	h.SetParentHeader(
		HeaderFromGRPCMessage(m.GetParentHeader()),
	)

	childMsg := m.GetChildren()
	children := make([]*refs.ObjectID, 0, len(childMsg))

	for i := range childMsg {
		children = append(children, refs.ObjectIDFromGRPCMessage(childMsg[i]))
	}

	h.SetChildren(children)

	h.SetSplitID(m.GetSplitId())

	return h
}

func HeaderToGRPCMessage(h *Header) *object.Header {
	if h == nil {
		return nil
	}

	m := new(object.Header)

	m.SetVersion(
		refs.VersionToGRPCMessage(h.GetVersion()),
	)

	m.SetContainerId(
		refs.ContainerIDToGRPCMessage(h.GetContainerID()),
	)

	m.SetOwnerId(
		refs.OwnerIDToGRPCMessage(h.GetOwnerID()),
	)

	m.SetCreationEpoch(h.GetCreationEpoch())

	m.SetPayloadLength(h.GetPayloadLength())

	m.SetPayloadHash(
		refs.ChecksumToGRPCMessage(h.GetPayloadHash()),
	)

	m.SetHomomorphicHash(
		refs.ChecksumToGRPCMessage(h.GetHomomorphicHash()),
	)

	m.SetObjectType(
		TypeToGRPCField(h.GetObjectType()),
	)

	m.SetSessionToken(
		session.SessionTokenToGRPCMessage(h.GetSessionToken()),
	)

	attr := h.GetAttributes()
	attrMsg := make([]*object.Header_Attribute, 0, len(attr))

	for i := range attr {
		attrMsg = append(attrMsg, AttributeToGRPCMessage(attr[i]))
	}

	m.SetAttributes(attrMsg)

	m.SetSplit(
		SplitHeaderToGRPCMessage(h.GetSplit()),
	)

	return m
}

func HeaderFromGRPCMessage(m *object.Header) *Header {
	if m == nil {
		return nil
	}

	h := new(Header)

	h.SetVersion(
		refs.VersionFromGRPCMessage(m.GetVersion()),
	)

	h.SetContainerID(
		refs.ContainerIDFromGRPCMessage(m.GetContainerId()),
	)

	h.SetOwnerID(
		refs.OwnerIDFromGRPCMessage(m.GetOwnerId()),
	)

	h.SetCreationEpoch(m.GetCreationEpoch())

	h.SetPayloadLength(m.GetPayloadLength())

	h.SetPayloadHash(
		refs.ChecksumFromGRPCMessage(m.GetPayloadHash()),
	)

	h.SetHomomorphicHash(
		refs.ChecksumFromGRPCMessage(m.GetHomomorphicHash()),
	)

	h.SetObjectType(
		TypeFromGRPCField(m.GetObjectType()),
	)

	h.SetSessionToken(
		session.SessionTokenFromGRPCMessage(m.GetSessionToken()),
	)

	attrMsg := m.GetAttributes()
	attr := make([]*Attribute, 0, len(attrMsg))

	for i := range attrMsg {
		attr = append(attr, AttributeFromGRPCMessage(attrMsg[i]))
	}

	h.SetAttributes(attr)

	h.SetSplit(
		SplitHeaderFromGRPCMessage(m.GetSplit()),
	)

	return h
}

func HeaderWithSignatureToGRPCMessage(h *HeaderWithSignature) *object.HeaderWithSignature {
	if h == nil {
		return nil
	}

	m := new(object.HeaderWithSignature)

	m.SetHeader(
		HeaderToGRPCMessage(h.GetHeader()),
	)

	m.SetSignature(
		refs.SignatureToGRPCMessage(h.GetSignature()),
	)

	return m
}

func HeaderWithSignatureFromGRPCMessage(m *object.HeaderWithSignature) *HeaderWithSignature {
	if m == nil {
		return nil
	}

	h := new(HeaderWithSignature)

	h.SetHeader(
		HeaderFromGRPCMessage(m.GetHeader()),
	)

	h.SetSignature(
		refs.SignatureFromGRPCMessage(m.GetSignature()),
	)

	return h
}

func ObjectToGRPCMessage(o *Object) *object.Object {
	if o == nil {
		return nil
	}

	m := new(object.Object)

	m.SetObjectId(
		refs.ObjectIDToGRPCMessage(o.GetObjectID()),
	)

	m.SetSignature(
		refs.SignatureToGRPCMessage(o.GetSignature()),
	)

	m.SetHeader(
		HeaderToGRPCMessage(o.GetHeader()),
	)

	m.SetPayload(o.GetPayload())

	return m
}

func ObjectFromGRPCMessage(m *object.Object) *Object {
	if m == nil {
		return nil
	}

	o := new(Object)

	o.SetObjectID(
		refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
	)

	o.SetSignature(
		refs.SignatureFromGRPCMessage(m.GetSignature()),
	)

	o.SetHeader(
		HeaderFromGRPCMessage(m.GetHeader()),
	)

	o.SetPayload(m.GetPayload())

	return o
}

func SplitInfoToGRPCMessage(s *SplitInfo) *object.SplitInfo {
	if s == nil {
		return nil
	}

	m := new(object.SplitInfo)

	m.SetSplitId(s.GetSplitID())

	m.SetLastPart(
		refs.ObjectIDToGRPCMessage(s.GetLastPart()),
	)

	m.SetLink(
		refs.ObjectIDToGRPCMessage(s.GetLink()),
	)

	return m
}

func SplitInfoFromGRPCMessage(m *object.SplitInfo) *SplitInfo {
	if m == nil {
		return nil
	}

	r := new(SplitInfo)

	r.SetSplitID(m.GetSplitId())

	r.SetLastPart(
		refs.ObjectIDFromGRPCMessage(m.GetLastPart()),
	)

	r.SetLink(
		refs.ObjectIDFromGRPCMessage(m.GetLink()),
	)

	return r
}

func GetRequestBodyToGRPCMessage(r *GetRequestBody) *object.GetRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetRequest_Body)

	m.SetAddress(
		refs.AddressToGRPCMessage(r.GetAddress()),
	)

	m.SetRaw(r.GetRaw())

	return m
}

func GetRequestBodyFromGRPCMessage(m *object.GetRequest_Body) *GetRequestBody {
	if m == nil {
		return nil
	}

	r := new(GetRequestBody)

	r.SetAddress(
		refs.AddressFromGRPCMessage(m.GetAddress()),
	)

	r.SetRaw(m.GetRaw())

	return r
}

func GetRequestToGRPCMessage(r *GetRequest) *object.GetRequest {
	if r == nil {
		return nil
	}

	m := new(object.GetRequest)

	m.SetBody(
		GetRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func GetRequestFromGRPCMessage(m *object.GetRequest) *GetRequest {
	if m == nil {
		return nil
	}

	r := new(GetRequest)

	r.SetBody(
		GetRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func GetObjectPartInitToGRPCMessage(r *GetObjectPartInit) *object.GetResponse_Body_Init {
	if r == nil {
		return nil
	}

	m := new(object.GetResponse_Body_Init)

	m.SetObjectId(
		refs.ObjectIDToGRPCMessage(r.GetObjectID()),
	)

	m.SetSignature(
		refs.SignatureToGRPCMessage(r.GetSignature()),
	)

	m.SetHeader(
		HeaderToGRPCMessage(r.GetHeader()),
	)

	return m
}

func GetObjectPartInitFromGRPCMessage(m *object.GetResponse_Body_Init) *GetObjectPartInit {
	if m == nil {
		return nil
	}

	r := new(GetObjectPartInit)

	r.SetObjectID(
		refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
	)

	r.SetSignature(
		refs.SignatureFromGRPCMessage(m.GetSignature()),
	)

	r.SetHeader(
		HeaderFromGRPCMessage(m.GetHeader()),
	)

	return r
}

func GetObjectPartChunkToGRPCMessage(r *GetObjectPartChunk) *object.GetResponse_Body_Chunk {
	if r == nil {
		return nil
	}

	m := new(object.GetResponse_Body_Chunk)

	m.SetChunk(r.GetChunk())

	return m
}

func GetObjectPartChunkFromGRPCMessage(m *object.GetResponse_Body_Chunk) *GetObjectPartChunk {
	if m == nil {
		return nil
	}

	r := new(GetObjectPartChunk)

	r.SetChunk(m.GetChunk())

	return r
}

func GetResponseBodyToGRPCMessage(r *GetResponseBody) *object.GetResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetResponse_Body)

	switch v := r.GetObjectPart(); t := v.(type) {
	case nil:
	case *GetObjectPartInit:
		m.SetInit(
			GetObjectPartInitToGRPCMessage(t),
		)
	case *GetObjectPartChunk:
		m.SetChunk(
			GetObjectPartChunkToGRPCMessage(t),
		)
	case *SplitInfo:
		m.SetSplitInfo(
			SplitInfoToGRPCMessage(t),
		)
	default:
		panic(fmt.Sprintf("unknown object part %T", t))
	}

	return m
}

func GetResponseBodyFromGRPCMessage(m *object.GetResponse_Body) *GetResponseBody {
	if m == nil {
		return nil
	}

	r := new(GetResponseBody)

	switch v := m.GetObjectPart().(type) {
	case nil:
	case *object.GetResponse_Body_Init_:
		r.SetObjectPart(
			GetObjectPartInitFromGRPCMessage(v.Init),
		)
	case *object.GetResponse_Body_Chunk:
		r.SetObjectPart(
			GetObjectPartChunkFromGRPCMessage(v),
		)
	case *object.GetResponse_Body_SplitInfo:
		r.SetObjectPart(
			SplitInfoFromGRPCMessage(v.SplitInfo),
		)
	default:
		panic(fmt.Sprintf("unknown object part %T", v))
	}

	return r
}

func GetResponseToGRPCMessage(r *GetResponse) *object.GetResponse {
	if r == nil {
		return nil
	}

	m := new(object.GetResponse)

	m.SetBody(
		GetResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func GetResponseFromGRPCMessage(m *object.GetResponse) *GetResponse {
	if m == nil {
		return nil
	}

	r := new(GetResponse)

	r.SetBody(
		GetResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func PutObjectPartInitToGRPCMessage(r *PutObjectPartInit) *object.PutRequest_Body_Init {
	if r == nil {
		return nil
	}

	m := new(object.PutRequest_Body_Init)

	m.SetObjectId(
		refs.ObjectIDToGRPCMessage(r.GetObjectID()),
	)

	m.SetSignature(
		refs.SignatureToGRPCMessage(r.GetSignature()),
	)

	m.SetHeader(
		HeaderToGRPCMessage(r.GetHeader()),
	)

	m.SetCopiesNumber(r.GetCopiesNumber())

	return m
}

func PutObjectPartInitFromGRPCMessage(m *object.PutRequest_Body_Init) *PutObjectPartInit {
	if m == nil {
		return nil
	}

	r := new(PutObjectPartInit)

	r.SetObjectID(
		refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
	)

	r.SetSignature(
		refs.SignatureFromGRPCMessage(m.GetSignature()),
	)

	r.SetHeader(
		HeaderFromGRPCMessage(m.GetHeader()),
	)

	r.SetCopiesNumber(m.GetCopiesNumber())

	return r
}

func PutObjectPartChunkToGRPCMessage(r *PutObjectPartChunk) *object.PutRequest_Body_Chunk {
	if r == nil {
		return nil
	}

	m := new(object.PutRequest_Body_Chunk)

	m.SetChunk(r.GetChunk())

	return m
}

func PutObjectPartChunkFromGRPCMessage(m *object.PutRequest_Body_Chunk) *PutObjectPartChunk {
	if m == nil {
		return nil
	}

	r := new(PutObjectPartChunk)

	r.SetChunk(m.GetChunk())

	return r
}

func PutRequestBodyToGRPCMessage(r *PutRequestBody) *object.PutRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.PutRequest_Body)

	switch v := r.GetObjectPart(); t := v.(type) {
	case nil:
	case *PutObjectPartInit:
		m.SetInit(
			PutObjectPartInitToGRPCMessage(t),
		)
	case *PutObjectPartChunk:
		m.SetChunk(
			PutObjectPartChunkToGRPCMessage(t),
		)
	default:
		panic(fmt.Sprintf("unknown object part %T", t))
	}

	return m
}

func PutRequestBodyFromGRPCMessage(m *object.PutRequest_Body) *PutRequestBody {
	if m == nil {
		return nil
	}

	r := new(PutRequestBody)

	switch v := m.GetObjectPart().(type) {
	case nil:
	case *object.PutRequest_Body_Init_:
		r.SetObjectPart(
			PutObjectPartInitFromGRPCMessage(v.Init),
		)
	case *object.PutRequest_Body_Chunk:
		r.SetObjectPart(
			PutObjectPartChunkFromGRPCMessage(v),
		)
	default:
		panic(fmt.Sprintf("unknown object part %T", v))
	}

	return r
}

func PutRequestToGRPCMessage(r *PutRequest) *object.PutRequest {
	if r == nil {
		return nil
	}

	m := new(object.PutRequest)

	m.SetBody(
		PutRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func PutRequestFromGRPCMessage(m *object.PutRequest) *PutRequest {
	if m == nil {
		return nil
	}

	r := new(PutRequest)

	r.SetBody(
		PutRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func PutResponseBodyToGRPCMessage(r *PutResponseBody) *object.PutResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.PutResponse_Body)

	m.SetObjectId(
		refs.ObjectIDToGRPCMessage(r.GetObjectID()),
	)

	return m
}

func PutResponseBodyFromGRPCMessage(m *object.PutResponse_Body) *PutResponseBody {
	if m == nil {
		return nil
	}

	r := new(PutResponseBody)

	r.SetObjectID(
		refs.ObjectIDFromGRPCMessage(m.GetObjectId()),
	)

	return r
}

func PutResponseToGRPCMessage(r *PutResponse) *object.PutResponse {
	if r == nil {
		return nil
	}

	m := new(object.PutResponse)

	m.SetBody(
		PutResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func PutResponseFromGRPCMessage(m *object.PutResponse) *PutResponse {
	if m == nil {
		return nil
	}

	r := new(PutResponse)

	r.SetBody(
		PutResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func DeleteRequestBodyToGRPCMessage(r *DeleteRequestBody) *object.DeleteRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.DeleteRequest_Body)

	m.SetAddress(
		refs.AddressToGRPCMessage(r.GetAddress()),
	)

	return m
}

func DeleteRequestBodyFromGRPCMessage(m *object.DeleteRequest_Body) *DeleteRequestBody {
	if m == nil {
		return nil
	}

	r := new(DeleteRequestBody)

	r.SetAddress(
		refs.AddressFromGRPCMessage(m.GetAddress()),
	)

	return r
}

func DeleteRequestToGRPCMessage(r *DeleteRequest) *object.DeleteRequest {
	if r == nil {
		return nil
	}

	m := new(object.DeleteRequest)

	m.SetBody(
		DeleteRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func DeleteRequestFromGRPCMessage(m *object.DeleteRequest) *DeleteRequest {
	if m == nil {
		return nil
	}

	r := new(DeleteRequest)

	r.SetBody(
		DeleteRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func DeleteResponseBodyToGRPCMessage(r *DeleteResponseBody) *object.DeleteResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.DeleteResponse_Body)
	m.SetTombstone(
		refs.AddressToGRPCMessage(r.GetTombstone()),
	)

	return m
}

func DeleteResponseBodyFromGRPCMessage(m *object.DeleteResponse_Body) *DeleteResponseBody {
	if m == nil {
		return nil
	}

	r := new(DeleteResponseBody)
	r.SetTombstone(
		refs.AddressFromGRPCMessage(m.GetTombstone()),
	)

	return r
}

func DeleteResponseToGRPCMessage(r *DeleteResponse) *object.DeleteResponse {
	if r == nil {
		return nil
	}

	m := new(object.DeleteResponse)

	m.SetBody(
		DeleteResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func DeleteResponseFromGRPCMessage(m *object.DeleteResponse) *DeleteResponse {
	if m == nil {
		return nil
	}

	r := new(DeleteResponse)

	r.SetBody(
		DeleteResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func HeadRequestBodyToGRPCMessage(r *HeadRequestBody) *object.HeadRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.HeadRequest_Body)

	m.SetAddress(
		refs.AddressToGRPCMessage(r.GetAddress()),
	)

	m.SetMainOnly(r.GetMainOnly())

	m.SetRaw(r.GetRaw())

	return m
}

func HeadRequestBodyFromGRPCMessage(m *object.HeadRequest_Body) *HeadRequestBody {
	if m == nil {
		return nil
	}

	r := new(HeadRequestBody)

	r.SetAddress(
		refs.AddressFromGRPCMessage(m.GetAddress()),
	)

	r.SetMainOnly(m.GetMainOnly())

	r.SetRaw(m.GetRaw())

	return r
}

func HeadRequestToGRPCMessage(r *HeadRequest) *object.HeadRequest {
	if r == nil {
		return nil
	}

	m := new(object.HeadRequest)

	m.SetBody(
		HeadRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func HeadRequestFromGRPCMessage(m *object.HeadRequest) *HeadRequest {
	if m == nil {
		return nil
	}

	r := new(HeadRequest)

	r.SetBody(
		HeadRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func HeadResponseBodyToGRPCMessage(r *HeadResponseBody) *object.HeadResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.HeadResponse_Body)

	switch v := r.GetHeaderPart(); t := v.(type) {
	case nil:
	case *HeaderWithSignature:
		m.SetHeader(
			HeaderWithSignatureToGRPCMessage(t),
		)
	case *ShortHeader:
		m.SetShortHeader(
			ShortHeaderToGRPCMessage(t),
		)
	case *SplitInfo:
		m.SetSplitInfo(
			SplitInfoToGRPCMessage(t),
		)
	default:
		panic(fmt.Sprintf("unknown header part %T", t))
	}

	return m
}

func HeadResponseBodyFromGRPCMessage(m *object.HeadResponse_Body) *HeadResponseBody {
	if m == nil {
		return nil
	}

	r := new(HeadResponseBody)

	switch v := m.GetHead().(type) {
	case nil:
	case *object.HeadResponse_Body_Header:
		r.SetHeaderPart(
			HeaderWithSignatureFromGRPCMessage(v.Header),
		)
	case *object.HeadResponse_Body_ShortHeader:
		r.SetHeaderPart(
			ShortHeaderFromGRPCMessage(v.ShortHeader),
		)
	case *object.HeadResponse_Body_SplitInfo:
		r.SetHeaderPart(
			SplitInfoFromGRPCMessage(v.SplitInfo),
		)
	default:
		panic(fmt.Sprintf("unknown header part %T", v))
	}

	return r
}

func HeadResponseToGRPCMessage(r *HeadResponse) *object.HeadResponse {
	if r == nil {
		return nil
	}

	m := new(object.HeadResponse)

	m.SetBody(
		HeadResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func HeadResponseFromGRPCMessage(m *object.HeadResponse) *HeadResponse {
	if m == nil {
		return nil
	}

	r := new(HeadResponse)

	r.SetBody(
		HeadResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func SearchFilterToGRPCMessage(f *SearchFilter) *object.SearchRequest_Body_Filter {
	if f == nil {
		return nil
	}

	m := new(object.SearchRequest_Body_Filter)

	m.SetMatchType(
		MatchTypeToGRPCField(f.GetMatchType()),
	)

	m.SetKey(f.GetKey())

	m.SetValue(f.GetValue())

	return m
}

func SearchFilterFromGRPCMessage(m *object.SearchRequest_Body_Filter) *SearchFilter {
	if m == nil {
		return nil
	}

	f := new(SearchFilter)

	f.SetMatchType(
		MatchTypeFromGRPCField(m.GetMatchType()),
	)

	f.SetKey(m.GetKey())

	f.SetValue(m.GetValue())

	return f
}

func SearchRequestBodyToGRPCMessage(r *SearchRequestBody) *object.SearchRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.SearchRequest_Body)

	m.SetContainerId(
		refs.ContainerIDToGRPCMessage(r.GetContainerID()),
	)

	m.SetVersion(r.GetVersion())

	filters := r.GetFilters()
	filterMsg := make([]*object.SearchRequest_Body_Filter, 0, len(filters))

	for i := range filters {
		filterMsg = append(filterMsg, SearchFilterToGRPCMessage(filters[i]))
	}

	m.SetFilters(filterMsg)

	return m
}

func SearchRequestBodyFromGRPCMessage(m *object.SearchRequest_Body) *SearchRequestBody {
	if m == nil {
		return nil
	}

	r := new(SearchRequestBody)

	r.SetContainerID(
		refs.ContainerIDFromGRPCMessage(m.GetContainerId()),
	)

	r.SetVersion(m.GetVersion())

	filterMsg := m.GetFilters()
	filters := make([]*SearchFilter, 0, len(filterMsg))

	for i := range filterMsg {
		filters = append(filters, SearchFilterFromGRPCMessage(filterMsg[i]))
	}

	r.SetFilters(filters)

	return r
}

func SearchRequestToGRPCMessage(r *SearchRequest) *object.SearchRequest {
	if r == nil {
		return nil
	}

	m := new(object.SearchRequest)

	m.SetBody(
		SearchRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func SearchRequestFromGRPCMessage(m *object.SearchRequest) *SearchRequest {
	if m == nil {
		return nil
	}

	r := new(SearchRequest)

	r.SetBody(
		SearchRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func SearchResponseBodyToGRPCMessage(r *SearchResponseBody) *object.SearchResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.SearchResponse_Body)

	ids := r.GetIDList()
	idMsg := make([]*refsGRPC.ObjectID, 0, len(ids))

	for i := range ids {
		idMsg = append(idMsg, refs.ObjectIDToGRPCMessage(ids[i]))
	}

	m.SetIdList(idMsg)

	return m
}

func SearchResponseBodyFromGRPCMessage(m *object.SearchResponse_Body) *SearchResponseBody {
	if m == nil {
		return nil
	}

	r := new(SearchResponseBody)

	idMsg := m.GetIdList()
	ids := make([]*refs.ObjectID, 0, len(idMsg))

	for i := range idMsg {
		ids = append(ids, refs.ObjectIDFromGRPCMessage(idMsg[i]))
	}

	r.SetIDList(ids)

	return r
}

func SearchResponseToGRPCMessage(r *SearchResponse) *object.SearchResponse {
	if r == nil {
		return nil
	}

	m := new(object.SearchResponse)

	m.SetBody(
		SearchResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func SearchResponseFromGRPCMessage(m *object.SearchResponse) *SearchResponse {
	if m == nil {
		return nil
	}

	r := new(SearchResponse)

	r.SetBody(
		SearchResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func RangeToGRPCMessage(r *Range) *object.Range {
	if r == nil {
		return nil
	}

	m := new(object.Range)

	m.SetOffset(r.GetOffset())
	m.SetLength(r.GetLength())

	return m
}

func RangeFromGRPCMessage(m *object.Range) *Range {
	if m == nil {
		return nil
	}

	r := new(Range)

	r.SetOffset(m.GetOffset())
	r.SetLength(m.GetLength())

	return r
}

func GetRangeRequestBodyToGRPCMessage(r *GetRangeRequestBody) *object.GetRangeRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeRequest_Body)

	m.SetAddress(
		refs.AddressToGRPCMessage(r.GetAddress()),
	)

	m.SetRange(
		RangeToGRPCMessage(r.GetRange()),
	)

	m.SetRaw(r.GetRaw())

	return m
}

func GetRangeRequestBodyFromGRPCMessage(m *object.GetRangeRequest_Body) *GetRangeRequestBody {
	if m == nil {
		return nil
	}

	r := new(GetRangeRequestBody)

	r.SetAddress(
		refs.AddressFromGRPCMessage(m.GetAddress()),
	)

	r.SetRange(
		RangeFromGRPCMessage(m.GetRange()),
	)

	r.SetRaw(m.GetRaw())

	return r
}

func GetRangeRequestToGRPCMessage(r *GetRangeRequest) *object.GetRangeRequest {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeRequest)

	m.SetBody(
		GetRangeRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func GetRangeRequestFromGRPCMessage(m *object.GetRangeRequest) *GetRangeRequest {
	if m == nil {
		return nil
	}

	r := new(GetRangeRequest)

	r.SetBody(
		GetRangeRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func GetRangePartChunkToGRPCMessage(r *GetRangePartChunk) *object.GetRangeResponse_Body_Chunk {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeResponse_Body_Chunk)

	m.SetChunk(r.GetChunk())

	return m
}

func GetRangePartChunkFromGRPCMessage(m *object.GetRangeResponse_Body_Chunk) *GetRangePartChunk {
	if m == nil {
		return nil
	}

	r := new(GetRangePartChunk)

	r.SetChunk(m.GetChunk())

	return r
}

func GetRangeResponseBodyToGRPCMessage(r *GetRangeResponseBody) *object.GetRangeResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeResponse_Body)

	switch v := r.GetRangePart(); t := v.(type) {
	case nil:
	case *GetRangePartChunk:
		m.SetChunk(
			GetRangePartChunkToGRPCMessage(t),
		)
	case *SplitInfo:
		m.SetSplitInfo(
			SplitInfoToGRPCMessage(t),
		)
	default:
		panic(fmt.Sprintf("unknown get range part %T", t))
	}

	return m
}

func GetRangeResponseBodyFromGRPCMessage(m *object.GetRangeResponse_Body) *GetRangeResponseBody {
	if m == nil {
		return nil
	}

	r := new(GetRangeResponseBody)

	switch v := m.GetRangePart().(type) {
	case nil:
	case *object.GetRangeResponse_Body_Chunk:
		r.SetRangePart(
			GetRangePartChunkFromGRPCMessage(v),
		)
	case *object.GetRangeResponse_Body_SplitInfo:
		r.SetRangePart(
			SplitInfoFromGRPCMessage(v.SplitInfo),
		)
	default:
		panic(fmt.Sprintf("unknown get range part %T", v))
	}

	return r
}

func GetRangeResponseToGRPCMessage(r *GetRangeResponse) *object.GetRangeResponse {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeResponse)

	m.SetBody(
		GetRangeResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func GetRangeResponseFromGRPCMessage(m *object.GetRangeResponse) *GetRangeResponse {
	if m == nil {
		return nil
	}

	r := new(GetRangeResponse)

	r.SetBody(
		GetRangeResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}

func GetRangeHashRequestBodyToGRPCMessage(r *GetRangeHashRequestBody) *object.GetRangeHashRequest_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeHashRequest_Body)

	m.SetAddress(
		refs.AddressToGRPCMessage(r.GetAddress()),
	)

	m.SetSalt(r.GetSalt())

	rngs := r.GetRanges()
	rngMsg := make([]*object.Range, 0, len(rngs))

	for i := range rngs {
		rngMsg = append(rngMsg, RangeToGRPCMessage(rngs[i]))
	}

	m.SetRanges(rngMsg)

	m.SetType(refsGRPC.ChecksumType(r.GetType()))

	return m
}

func GetRangeHashRequestBodyFromGRPCMessage(m *object.GetRangeHashRequest_Body) *GetRangeHashRequestBody {
	if m == nil {
		return nil
	}

	r := new(GetRangeHashRequestBody)

	r.SetAddress(
		refs.AddressFromGRPCMessage(m.GetAddress()),
	)

	r.SetSalt(m.GetSalt())

	rngMsg := m.GetRanges()
	rngs := make([]*Range, 0, len(rngMsg))

	for i := range rngMsg {
		rngs = append(rngs, RangeFromGRPCMessage(rngMsg[i]))
	}

	r.SetRanges(rngs)

	r.SetType(refs.ChecksumType(m.GetType()))

	return r
}

func GetRangeHashRequestToGRPCMessage(r *GetRangeHashRequest) *object.GetRangeHashRequest {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeHashRequest)

	m.SetBody(
		GetRangeHashRequestBodyToGRPCMessage(r.GetBody()),
	)

	session.RequestHeadersToGRPC(r, m)

	return m
}

func GetRangeHashRequestFromGRPCMessage(m *object.GetRangeHashRequest) *GetRangeHashRequest {
	if m == nil {
		return nil
	}

	r := new(GetRangeHashRequest)

	r.SetBody(
		GetRangeHashRequestBodyFromGRPCMessage(m.GetBody()),
	)

	session.RequestHeadersFromGRPC(m, r)

	return r
}

func GetRangeHashResponseBodyToGRPCMessage(r *GetRangeHashResponseBody) *object.GetRangeHashResponse_Body {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeHashResponse_Body)

	m.SetType(refsGRPC.ChecksumType(r.GetType()))

	m.SetHashList(r.GetHashList())

	return m
}

func GetRangeHashResponseBodyFromGRPCMessage(m *object.GetRangeHashResponse_Body) *GetRangeHashResponseBody {
	if m == nil {
		return nil
	}

	r := new(GetRangeHashResponseBody)

	r.SetType(refs.ChecksumType(m.GetType()))

	r.SetHashList(m.GetHashList())

	return r
}

func GetRangeHashResponseToGRPCMessage(r *GetRangeHashResponse) *object.GetRangeHashResponse {
	if r == nil {
		return nil
	}

	m := new(object.GetRangeHashResponse)

	m.SetBody(
		GetRangeHashResponseBodyToGRPCMessage(r.GetBody()),
	)

	session.ResponseHeadersToGRPC(r, m)

	return m
}

func GetRangeHashResponseFromGRPCMessage(m *object.GetRangeHashResponse) *GetRangeHashResponse {
	if m == nil {
		return nil
	}

	r := new(GetRangeHashResponse)

	r.SetBody(
		GetRangeHashResponseBodyFromGRPCMessage(m.GetBody()),
	)

	session.ResponseHeadersFromGRPC(m, r)

	return r
}