// Copyright 2019 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package impl

import (

	"fmt"

	"reflect"

	"google.golang.org/protobuf/internal/detrand"

	"google.golang.org/protobuf/internal/pragma"

)

type reflectMessageInfo struct {

	// fieldTypes contains the zero value of an enum or message field.

	// For lists, it contains the element type.

	// For maps, it contains the entry value type.

	// denseFields is a subset of fields where:

	//	0 < fieldDesc.Number() < len(denseFields)

	// It provides faster access to the fieldInfo, but may be incomplete.

	denseFields []*fieldInfo

	// rangeInfos is a list of all fields (not belonging to a oneof) and oneofs.

	rangeInfos []interface{} // either *fieldInfo or *oneofInfo

	extensionMap func(pointer) *extensionMap

	nilMessage atomicNilMessage

}

// makeReflectFuncs generates the set of functions to support reflection.

func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {

	mi.makeKnownFieldsFunc(si)

	mi.makeUnknownFieldsFunc(t, si)

	mi.makeExtensionFieldsFunc(t, si)

	mi.makeFieldTypes(si)

}

// makeKnownFieldsFunc generates functions for operations that can be performed

// on each protobuf message field. It takes in a reflect.Type representing the

// Go struct and matches message fields with struct fields.

//

// This code assumes that the struct is well-formed and panics if there are

// any discrepancies.

func (mi *MessageInfo) makeKnownFieldsFunc(si structInfo) {

	md := mi.Desc

	fds := md.Fields()

	for i := 0; i < fds.Len(); i++ {

		fd := fds.Get(i)

		fs := si.fieldsByNumber[fd.Number()]

		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()

		if isOneof {

			fs = si.oneofsByName[fd.ContainingOneof().Name()]

		}

		var fi fieldInfo

		switch {

		case fs.Type == nil:

			fi = fieldInfoForMissing(fd) // never occurs for officially generated message types

		case isOneof:

			fi = fieldInfoForOneof(fd, fs, mi.Exporter, si.oneofWrappersByNumber[fd.Number()])

		case fd.IsMap():

			fi = fieldInfoForMap(fd, fs, mi.Exporter)

		case fd.IsList():

			fi = fieldInfoForList(fd, fs, mi.Exporter)

		case fd.IsWeak():

			fi = fieldInfoForWeakMessage(fd, si.weakOffset)

		case fd.Message() != nil:

			fi = fieldInfoForMessage(fd, fs, mi.Exporter)

		default:

			fi = fieldInfoForScalar(fd, fs, mi.Exporter)

		}

		mi.fields[fd.Number()] = &fi

	}

	for i := 0; i < md.Oneofs().Len(); i++ {

		od := md.Oneofs().Get(i)

		mi.oneofs[od.Name()] = makeOneofInfo(od, si, mi.Exporter)

	}

	mi.denseFields = make([]*fieldInfo, fds.Len()*2)

	for i := 0; i < fds.Len(); i++ {

		if fd := fds.Get(i); int(fd.Number()) < len(mi.denseFields) {

			mi.denseFields[fd.Number()] = mi.fields[fd.Number()]

		}

	}

	for i := 0; i < fds.Len(); {

		fd := fds.Get(i)

		if od := fd.ContainingOneof(); od != nil && !od.IsSynthetic() {

			mi.rangeInfos = append(mi.rangeInfos, mi.oneofs[od.Name()])

			i += od.Fields().Len()

		} else {

			mi.rangeInfos = append(mi.rangeInfos, mi.fields[fd.Number()])

			i++

		}

	}

	// Introduce instability to iteration order, but keep it deterministic.

	if len(mi.rangeInfos) > 1 && detrand.Bool() {

		i := detrand.Intn(len(mi.rangeInfos) - 1)

		mi.rangeInfos[i], mi.rangeInfos[i+1] = mi.rangeInfos[i+1], mi.rangeInfos[i]

	}

}

func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {

	switch {

	case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsAType:

		// Handle as []byte.

			if p.IsNil() {

				return nil

			}

			return *p.Apply(mi.unknownOffset).Bytes()

		}

			if p.IsNil() {

				panic("invalid SetUnknown on nil Message")

			}

			*p.Apply(mi.unknownOffset).Bytes() = b

		}

	case si.unknownOffset.IsValid() && si.unknownType == unknownFieldsBType:

		// Handle as *[]byte.

			if p.IsNil() {

				return nil

			}

			bp := p.Apply(mi.unknownOffset).BytesPtr()

			if *bp == nil {

				return nil

			}

			return **bp

		}

			if p.IsNil() {

				panic("invalid SetUnknown on nil Message")

			}

			bp := p.Apply(mi.unknownOffset).BytesPtr()

			if *bp == nil {

				*bp = new([]byte)

			}

			**bp = b

		}

	default:

			return nil

		}

			if p.IsNil() {

				panic("invalid SetUnknown on nil Message")

			}

		}

	}

}

func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {

	if si.extensionOffset.IsValid() {

		mi.extensionMap = func(p pointer) *extensionMap {

			if p.IsNil() {

				return (*extensionMap)(nil)

			}

			v := p.Apply(si.extensionOffset).AsValueOf(extensionFieldsType)

			return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))

		}

	} else {

		mi.extensionMap = func(pointer) *extensionMap {

			return (*extensionMap)(nil)

		}

	}

}

func (mi *MessageInfo) makeFieldTypes(si structInfo) {

	md := mi.Desc

	fds := md.Fields()

	for i := 0; i < fds.Len(); i++ {

		var ft reflect.Type

		fd := fds.Get(i)

		fs := si.fieldsByNumber[fd.Number()]

		isOneof := fd.ContainingOneof() != nil && !fd.ContainingOneof().IsSynthetic()

		if isOneof {

			fs = si.oneofsByName[fd.ContainingOneof().Name()]

		}

		var isMessage bool

		switch {

		case fs.Type == nil:

			continue // never occurs for officially generated message types

		case isOneof:

			if fd.Enum() != nil || fd.Message() != nil {

				ft = si.oneofWrappersByNumber[fd.Number()].Field(0).Type

			}

		case fd.IsMap():

			if fd.MapValue().Enum() != nil || fd.MapValue().Message() != nil {

				ft = fs.Type.Elem()

			}

			isMessage = fd.MapValue().Message() != nil

		case fd.IsList():

			if fd.Enum() != nil || fd.Message() != nil {

				ft = fs.Type.Elem()

			}

			isMessage = fd.Message() != nil

		case fd.Enum() != nil:

			ft = fs.Type

			if fd.HasPresence() && ft.Kind() == reflect.Ptr {

				ft = ft.Elem()

			}

		case fd.Message() != nil:

			ft = fs.Type

			if fd.IsWeak() {

				ft = nil

			}

			isMessage = true

		}

		if isMessage && ft != nil && ft.Kind() != reflect.Ptr {

			ft = reflect.PtrTo(ft) // never occurs for officially generated message types

		}

		if ft != nil {

			if mi.fieldTypes == nil {

			}

			mi.fieldTypes[fd.Number()] = reflect.Zero(ft).Interface()

		}

	}

}

type extensionMap map[int32]ExtensionField

	if m != nil {

		for _, x := range *m {

			xd := x.Type().TypeDescriptor()

			v := x.Value()

			if xd.IsList() && v.List().Len() == 0 {

				continue

			}

			if !f(xd, v) {

				return

			}

		}

	}

}

	if m == nil {

		return false

	}

	xd := xt.TypeDescriptor()

	x, ok := (*m)[int32(xd.Number())]

	if !ok {

		return false

	}

	switch {

	case xd.IsList():

		return x.Value().List().Len() > 0

	case xd.IsMap():

		return x.Value().Map().Len() > 0

	case xd.Message() != nil:

		return x.Value().Message().IsValid()

	}

	return true

}

	delete(*m, int32(xt.TypeDescriptor().Number()))

}

	xd := xt.TypeDescriptor()

	if m != nil {

		if x, ok := (*m)[int32(xd.Number())]; ok {

			return x.Value()

		}

	}

	return xt.Zero()

}

	xd := xt.TypeDescriptor()

	isValid := true

	switch {

	case !xt.IsValidValue(v):

		isValid = false

	case xd.IsList():

		isValid = v.List().IsValid()

	case xd.IsMap():

		isValid = v.Map().IsValid()

	case xd.Message() != nil:

		isValid = v.Message().IsValid()

	}

	if !isValid {

		panic(fmt.Sprintf("%v: assigning invalid value", xt.TypeDescriptor().FullName()))

	}

	if *m == nil {

		*m = make(map[int32]ExtensionField)

	}

	var x ExtensionField

	x.Set(xt, v)

	(*m)[int32(xd.Number())] = x

}

	xd := xt.TypeDescriptor()

		panic("invalid Mutable on field with non-composite type")

	}

	if x, ok := (*m)[int32(xd.Number())]; ok {

		return x.Value()

	}

	v := xt.New()

	m.Set(xt, v)

	return v

}

// MessageState is a data structure that is nested as the first field in a

// concrete message. It provides a way to implement the ProtoReflect method

// in an allocation-free way without needing to have a shadow Go type generated

// for every message type. This technique only works using unsafe.

//

// Example generated code:

//

//	type M struct {

//		state protoimpl.MessageState

//

//		Field1 int32

//		Field2 string

//		Field3 *BarMessage

//		...

//	}

//

//	func (m *M) ProtoReflect() protoreflect.Message {

//		mi := &file_fizz_buzz_proto_msgInfos[5]

//		if protoimpl.UnsafeEnabled && m != nil {

//			ms := protoimpl.X.MessageStateOf(Pointer(m))

//			if ms.LoadMessageInfo() == nil {

//				ms.StoreMessageInfo(mi)

//			}

//			return ms

//		}

//		return mi.MessageOf(m)

//	}

//

// The MessageState type holds a *MessageInfo, which must be atomically set to

// the message info associated with a given message instance.

// By unsafely converting a *M into a *MessageState, the MessageState object

// has access to all the information needed to implement protobuf reflection.

// It has access to the message info as its first field, and a pointer to the

// MessageState is identical to a pointer to the concrete message value.

//

// Requirements:

type MessageState struct {

	pragma.NoUnkeyedLiterals

	pragma.DoNotCompare

	pragma.DoNotCopy

	atomicMessageInfo *MessageInfo

}

type messageState MessageState

var (

)

// messageDataType is a tuple of a pointer to the message data and

// a pointer to the message type. It is a generalized way of providing a

// reflective view over a message instance. The disadvantage of this approach

// is the need to allocate this tuple of 16B.

type messageDataType struct {

	p  pointer

	mi *MessageInfo

}

type (

	messageReflectWrapper messageDataType

	messageIfaceWrapper   messageDataType

)

var (