package acl

import (
	acl "github.com/nspcc-dev/neofs-api-go/v2/acl/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/rpc/grpc"
	"github.com/nspcc-dev/neofs-api-go/v2/rpc/message"
)

// RoleToGRPCField converts unified role enum into grpc enum.
func RoleToGRPCField(t Role) acl.Role {
	switch t {
	case RoleUser:
		return acl.Role_USER
	case RoleSystem:
		return acl.Role_SYSTEM
	case RoleOthers:
		return acl.Role_OTHERS
	default:
		return acl.Role_ROLE_UNSPECIFIED
	}
}

// RoleFromGRPCField converts grpc enum into unified role enum.
func RoleFromGRPCField(t acl.Role) Role {
	switch t {
	case acl.Role_USER:
		return RoleUser
	case acl.Role_SYSTEM:
		return RoleSystem
	case acl.Role_OTHERS:
		return RoleOthers
	default:
		return RoleUnknown
	}
}

// OperationToGRPCField converts unified operation enum into grpc enum.
func OperationToGRPCField(t Operation) acl.Operation {
	switch t {
	case OperationPut:
		return acl.Operation_PUT
	case OperationDelete:
		return acl.Operation_DELETE
	case OperationGet:
		return acl.Operation_GET
	case OperationHead:
		return acl.Operation_HEAD
	case OperationSearch:
		return acl.Operation_SEARCH
	case OperationRange:
		return acl.Operation_GETRANGE
	case OperationRangeHash:
		return acl.Operation_GETRANGEHASH
	default:
		return acl.Operation_OPERATION_UNSPECIFIED
	}
}

// OperationFromGRPCField converts grpc enum into unified operation enum.
func OperationFromGRPCField(t acl.Operation) Operation {
	switch t {
	case acl.Operation_PUT:
		return OperationPut
	case acl.Operation_DELETE:
		return OperationDelete
	case acl.Operation_GET:
		return OperationGet
	case acl.Operation_HEAD:
		return OperationHead
	case acl.Operation_SEARCH:
		return OperationSearch
	case acl.Operation_GETRANGE:
		return OperationRange
	case acl.Operation_GETRANGEHASH:
		return OperationRangeHash
	default:
		return OperationUnknown
	}
}

// ActionToGRPCField converts unified action enum into grpc enum.
func ActionToGRPCField(t Action) acl.Action {
	switch t {
	case ActionDeny:
		return acl.Action_DENY
	case ActionAllow:
		return acl.Action_ALLOW
	default:
		return acl.Action_ACTION_UNSPECIFIED
	}
}

// ActionFromGRPCField converts grpc enum into unified action enum.
func ActionFromGRPCField(t acl.Action) Action {
	switch t {
	case acl.Action_DENY:
		return ActionDeny
	case acl.Action_ALLOW:
		return ActionAllow
	default:
		return ActionUnknown
	}
}

// HeaderTypeToGRPCField converts unified header type enum into grpc enum.
func HeaderTypeToGRPCField(t HeaderType) acl.HeaderType {
	switch t {
	case HeaderTypeRequest:
		return acl.HeaderType_REQUEST
	case HeaderTypeObject:
		return acl.HeaderType_OBJECT
	case HeaderTypeService:
		return acl.HeaderType_SERVICE
	default:
		return acl.HeaderType_HEADER_UNSPECIFIED
	}
}

// HeaderTypeFromGRPCField converts grpc enum into unified header type enum.
func HeaderTypeFromGRPCField(t acl.HeaderType) HeaderType {
	switch t {
	case acl.HeaderType_REQUEST:
		return HeaderTypeRequest
	case acl.HeaderType_OBJECT:
		return HeaderTypeObject
	case acl.HeaderType_SERVICE:
		return HeaderTypeService
	default:
		return HeaderTypeUnknown
	}
}

// MatchTypeToGRPCField converts unified match type enum into grpc enum.
func MatchTypeToGRPCField(t MatchType) acl.MatchType {
	switch t {
	case MatchTypeStringEqual:
		return acl.MatchType_STRING_EQUAL
	case MatchTypeStringNotEqual:
		return acl.MatchType_STRING_NOT_EQUAL
	default:
		return acl.MatchType_MATCH_TYPE_UNSPECIFIED
	}
}

// MatchTypeFromGRPCField converts grpc enum into unified match type enum.
func MatchTypeFromGRPCField(t acl.MatchType) MatchType {
	switch t {
	case acl.MatchType_STRING_EQUAL:
		return MatchTypeStringEqual
	case acl.MatchType_STRING_NOT_EQUAL:
		return MatchTypeStringNotEqual
	default:
		return MatchTypeUnknown
	}
}

func (f *HeaderFilter) ToGRPCMessage() grpc.Message {
	var m *acl.EACLRecord_Filter

	if f != nil {
		m = new(acl.EACLRecord_Filter)

		m.SetKey(f.key)
		m.SetValue(f.value)
		m.SetHeader(HeaderTypeToGRPCField(f.hdrType))
		m.SetMatchType(MatchTypeToGRPCField(f.matchType))
	}

	return m
}

func (f *HeaderFilter) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.EACLRecord_Filter)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	f.key = v.GetKey()
	f.value = v.GetValue()
	f.hdrType = HeaderTypeFromGRPCField(v.GetHeaderType())
	f.matchType = MatchTypeFromGRPCField(v.GetMatchType())

	return nil
}

func HeaderFiltersToGRPC(fs []*HeaderFilter) (res []*acl.EACLRecord_Filter) {
	if fs != nil {
		res = make([]*acl.EACLRecord_Filter, 0, len(fs))

		for i := range fs {
			res = append(res, fs[i].ToGRPCMessage().(*acl.EACLRecord_Filter))
		}
	}

	return
}

func HeaderFiltersFromGRPC(fs []*acl.EACLRecord_Filter) (res []*HeaderFilter, err error) {
	if fs != nil {
		res = make([]*HeaderFilter, 0, len(fs))

		for i := range fs {
			var x *HeaderFilter

			if fs[i] != nil {
				x = new(HeaderFilter)

				err = x.FromGRPCMessage(fs[i])
				if err != nil {
					return
				}
			}

			res = append(res, x)
		}
	}

	return
}

func (t *Target) ToGRPCMessage() grpc.Message {
	var m *acl.EACLRecord_Target

	if t != nil {
		m = new(acl.EACLRecord_Target)

		m.SetRole(RoleToGRPCField(t.role))
		m.SetKeys(t.keys)
	}

	return m
}

func (t *Target) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.EACLRecord_Target)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	t.role = RoleFromGRPCField(v.GetRole())
	t.keys = v.GetKeys()

	return nil
}

func TargetsToGRPC(ts []*Target) (res []*acl.EACLRecord_Target) {
	if ts != nil {
		res = make([]*acl.EACLRecord_Target, 0, len(ts))

		for i := range ts {
			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord_Target))
		}
	}

	return
}

func TargetsFromGRPC(fs []*acl.EACLRecord_Target) (res []*Target, err error) {
	if fs != nil {
		res = make([]*Target, 0, len(fs))

		for i := range fs {
			var x *Target

			if fs[i] != nil {
				x = new(Target)

				err = x.FromGRPCMessage(fs[i])
				if err != nil {
					return
				}
			}

			res = append(res, x)
		}
	}

	return
}

func (r *Record) ToGRPCMessage() grpc.Message {
	var m *acl.EACLRecord

	if r != nil {
		m = new(acl.EACLRecord)

		m.SetOperation(OperationToGRPCField(r.op))
		m.SetAction(ActionToGRPCField(r.action))
		m.SetFilters(HeaderFiltersToGRPC(r.filters))
		m.SetTargets(TargetsToGRPC(r.targets))
	}

	return m
}

func (r *Record) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.EACLRecord)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	var err error

	r.filters, err = HeaderFiltersFromGRPC(v.GetFilters())
	if err != nil {
		return err
	}

	r.targets, err = TargetsFromGRPC(v.GetTargets())
	if err != nil {
		return err
	}

	r.op = OperationFromGRPCField(v.GetOperation())
	r.action = ActionFromGRPCField(v.GetAction())

	return nil
}

func RecordsToGRPC(ts []*Record) (res []*acl.EACLRecord) {
	if ts != nil {
		res = make([]*acl.EACLRecord, 0, len(ts))

		for i := range ts {
			res = append(res, ts[i].ToGRPCMessage().(*acl.EACLRecord))
		}
	}

	return
}

func RecordsFromGRPC(fs []*acl.EACLRecord) (res []*Record, err error) {
	if fs != nil {
		res = make([]*Record, 0, len(fs))

		for i := range fs {
			var x *Record

			if fs[i] != nil {
				x = new(Record)

				err = x.FromGRPCMessage(fs[i])
				if err != nil {
					return
				}
			}

			res = append(res, x)
		}
	}

	return
}

func (t *Table) ToGRPCMessage() grpc.Message {
	var m *acl.EACLTable

	if t != nil {
		m = new(acl.EACLTable)

		m.SetVersion(t.version.ToGRPCMessage().(*refsGRPC.Version))
		m.SetContainerId(t.cid.ToGRPCMessage().(*refsGRPC.ContainerID))
		m.SetRecords(RecordsToGRPC(t.records))
	}

	return m
}

func (t *Table) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.EACLTable)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	var err error

	cid := v.GetContainerId()
	if cid == nil {
		t.cid = nil
	} else {
		if t.cid == nil {
			t.cid = new(refs.ContainerID)
		}

		err = t.cid.FromGRPCMessage(cid)
		if err != nil {
			return err
		}
	}

	version := v.GetVersion()
	if version == nil {
		t.version = nil
	} else {
		if t.version == nil {
			t.version = new(refs.Version)
		}

		err = t.version.FromGRPCMessage(version)
		if err != nil {
			return err
		}
	}

	t.records, err = RecordsFromGRPC(v.GetRecords())

	return err
}

func (l *TokenLifetime) ToGRPCMessage() grpc.Message {
	var m *acl.BearerToken_Body_TokenLifetime

	if l != nil {
		m = new(acl.BearerToken_Body_TokenLifetime)

		m.SetExp(l.exp)
		m.SetIat(l.iat)
		m.SetNbf(l.nbf)
	}

	return m
}

func (l *TokenLifetime) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.BearerToken_Body_TokenLifetime)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	l.exp = v.GetExp()
	l.iat = v.GetIat()
	l.nbf = v.GetNbf()

	return nil
}

func (bt *BearerTokenBody) ToGRPCMessage() grpc.Message {
	var m *acl.BearerToken_Body

	if bt != nil {
		m = new(acl.BearerToken_Body)

		m.SetOwnerId(bt.ownerID.ToGRPCMessage().(*refsGRPC.OwnerID))
		m.SetLifetime(bt.lifetime.ToGRPCMessage().(*acl.BearerToken_Body_TokenLifetime))
		m.SetEaclTable(bt.eacl.ToGRPCMessage().(*acl.EACLTable))
	}

	return m
}

func (bt *BearerTokenBody) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.BearerToken_Body)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	var err error

	ownerID := v.GetOwnerId()
	if ownerID == nil {
		bt.ownerID = nil
	} else {
		if bt.ownerID == nil {
			bt.ownerID = new(refs.OwnerID)
		}

		err = bt.ownerID.FromGRPCMessage(ownerID)
		if err != nil {
			return err
		}
	}

	lifetime := v.GetLifetime()
	if lifetime == nil {
		bt.lifetime = nil
	} else {
		if bt.lifetime == nil {
			bt.lifetime = new(TokenLifetime)
		}

		err = bt.lifetime.FromGRPCMessage(lifetime)
		if err != nil {
			return err
		}
	}

	eacl := v.GetEaclTable()
	if eacl == nil {
		bt.eacl = nil
	} else {
		if bt.eacl == nil {
			bt.eacl = new(Table)
		}

		err = bt.eacl.FromGRPCMessage(eacl)
	}

	return err
}

func (bt *BearerToken) ToGRPCMessage() grpc.Message {
	var m *acl.BearerToken

	if bt != nil {
		m = new(acl.BearerToken)

		m.SetBody(bt.body.ToGRPCMessage().(*acl.BearerToken_Body))
		m.SetSignature(bt.sig.ToGRPCMessage().(*refsGRPC.Signature))
	}

	return m
}

func (bt *BearerToken) FromGRPCMessage(m grpc.Message) error {
	v, ok := m.(*acl.BearerToken)
	if !ok {
		return message.NewUnexpectedMessageType(m, v)
	}

	var err error

	body := v.GetBody()
	if body == nil {
		bt.body = nil
	} else {
		if bt.body == nil {
			bt.body = new(BearerTokenBody)
		}

		err = bt.body.FromGRPCMessage(body)
		if err != nil {
			return err
		}
	}

	sig := v.GetSignature()
	if sig == nil {
		bt.sig = nil
	} else {
		if bt.sig == nil {
			bt.sig = new(refs.Signature)
		}

		err = bt.sig.FromGRPCMessage(sig)
	}

	return err
}