// Copyright 2024 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 reflection_test

import (
	"fmt"
	"reflect"
	"testing"

	testopenpb "google.golang.org/protobuf/internal/testprotos/testeditions"
	"google.golang.org/protobuf/reflect/protoreflect"
	"google.golang.org/protobuf/runtime/protoiface"
	"google.golang.org/protobuf/testing/prototest"
)

func Test(t *testing.T) {
	t.Skip()
	for _, m := range []protoreflect.ProtoMessage{
		&testopenpb.TestAllTypes{},
	} {
		t.Run(fmt.Sprintf("%T", m), func(t *testing.T) {
			prototest.Message{}.Test(t, m.ProtoReflect().Type())
		})
	}
}

// What follows is infrastructure for a complicated but useful set of tests
// of different views of a message.
//
// Every Protobuf message can be accessed in at least two ways:
//
//   - m:                a concrete open, hybrid or opaque message
//   - m.ProtoReflect(): reflective view of the message
//
// A mutation to one representation must be reflected in the others.
//
// To test the various views of a message, we construct an implementations of
// the protoreflect.Message interface for each. The simplest is the canonical
// reflective view provided by the ProtoReflect method. In addition, for each
// concrete representation we create another view backed by that concrete API.
// (i.e., m.ProtoReflect().KnownFields().Get(1) directly translates to a call
// to m.GetFieldOne().)
//
// Finally, we construct a "shadow" view in which read operations are backed
// by one implementation and write operations by another.
//
// Each of these various views may then be passed to the prototest package
// for validation.
//
// This approach separates the decision of what behaviors to test from the
// implementations being tested; new validation tests added to prototest
// apply to all the various views without additional effort. The disadvantage
// is that there is quite a bit of per-message boilerplate required.
//
// We could attempt to reduce that boilerplate by use of reflection or code
// generation, but both approaches replace simple-but-repetitive code with
// something quite complex. Since the purpose of all this is to test the
// complex, general-purpose canonical implementation, the simple approach
// is safer.

// Field numbers for the test messages.
var (
	largeMessageDesc protoreflect.MessageDescriptor = (&testopenpb.TestManyMessageFieldsMessage{}).ProtoReflect().Descriptor()

	largeFieldF1   = largeMessageDesc.Fields().ByName("f1").Number()
	largeFieldF2   = largeMessageDesc.Fields().ByName("f2").Number()
	largeFieldF3   = largeMessageDesc.Fields().ByName("f3").Number()
	largeFieldF4   = largeMessageDesc.Fields().ByName("f4").Number()
	largeFieldF5   = largeMessageDesc.Fields().ByName("f5").Number()
	largeFieldF6   = largeMessageDesc.Fields().ByName("f6").Number()
	largeFieldF7   = largeMessageDesc.Fields().ByName("f7").Number()
	largeFieldF8   = largeMessageDesc.Fields().ByName("f8").Number()
	largeFieldF9   = largeMessageDesc.Fields().ByName("f9").Number()
	largeFieldF10  = largeMessageDesc.Fields().ByName("f10").Number()
	largeFieldF11  = largeMessageDesc.Fields().ByName("f11").Number()
	largeFieldF12  = largeMessageDesc.Fields().ByName("f12").Number()
	largeFieldF13  = largeMessageDesc.Fields().ByName("f13").Number()
	largeFieldF14  = largeMessageDesc.Fields().ByName("f14").Number()
	largeFieldF15  = largeMessageDesc.Fields().ByName("f15").Number()
	largeFieldF16  = largeMessageDesc.Fields().ByName("f16").Number()
	largeFieldF17  = largeMessageDesc.Fields().ByName("f17").Number()
	largeFieldF18  = largeMessageDesc.Fields().ByName("f18").Number()
	largeFieldF19  = largeMessageDesc.Fields().ByName("f19").Number()
	largeFieldF20  = largeMessageDesc.Fields().ByName("f20").Number()
	largeFieldF21  = largeMessageDesc.Fields().ByName("f21").Number()
	largeFieldF22  = largeMessageDesc.Fields().ByName("f22").Number()
	largeFieldF23  = largeMessageDesc.Fields().ByName("f23").Number()
	largeFieldF24  = largeMessageDesc.Fields().ByName("f24").Number()
	largeFieldF25  = largeMessageDesc.Fields().ByName("f25").Number()
	largeFieldF26  = largeMessageDesc.Fields().ByName("f26").Number()
	largeFieldF27  = largeMessageDesc.Fields().ByName("f27").Number()
	largeFieldF28  = largeMessageDesc.Fields().ByName("f28").Number()
	largeFieldF29  = largeMessageDesc.Fields().ByName("f29").Number()
	largeFieldF30  = largeMessageDesc.Fields().ByName("f30").Number()
	largeFieldF31  = largeMessageDesc.Fields().ByName("f31").Number()
	largeFieldF32  = largeMessageDesc.Fields().ByName("f32").Number()
	largeFieldF33  = largeMessageDesc.Fields().ByName("f33").Number()
	largeFieldF34  = largeMessageDesc.Fields().ByName("f34").Number()
	largeFieldF35  = largeMessageDesc.Fields().ByName("f35").Number()
	largeFieldF36  = largeMessageDesc.Fields().ByName("f36").Number()
	largeFieldF37  = largeMessageDesc.Fields().ByName("f37").Number()
	largeFieldF38  = largeMessageDesc.Fields().ByName("f38").Number()
	largeFieldF39  = largeMessageDesc.Fields().ByName("f39").Number()
	largeFieldF40  = largeMessageDesc.Fields().ByName("f40").Number()
	largeFieldF41  = largeMessageDesc.Fields().ByName("f41").Number()
	largeFieldF42  = largeMessageDesc.Fields().ByName("f42").Number()
	largeFieldF43  = largeMessageDesc.Fields().ByName("f43").Number()
	largeFieldF44  = largeMessageDesc.Fields().ByName("f44").Number()
	largeFieldF45  = largeMessageDesc.Fields().ByName("f45").Number()
	largeFieldF46  = largeMessageDesc.Fields().ByName("f46").Number()
	largeFieldF47  = largeMessageDesc.Fields().ByName("f47").Number()
	largeFieldF48  = largeMessageDesc.Fields().ByName("f48").Number()
	largeFieldF49  = largeMessageDesc.Fields().ByName("f49").Number()
	largeFieldF50  = largeMessageDesc.Fields().ByName("f50").Number()
	largeFieldF51  = largeMessageDesc.Fields().ByName("f51").Number()
	largeFieldF52  = largeMessageDesc.Fields().ByName("f52").Number()
	largeFieldF53  = largeMessageDesc.Fields().ByName("f53").Number()
	largeFieldF54  = largeMessageDesc.Fields().ByName("f54").Number()
	largeFieldF55  = largeMessageDesc.Fields().ByName("f55").Number()
	largeFieldF56  = largeMessageDesc.Fields().ByName("f56").Number()
	largeFieldF57  = largeMessageDesc.Fields().ByName("f57").Number()
	largeFieldF58  = largeMessageDesc.Fields().ByName("f58").Number()
	largeFieldF59  = largeMessageDesc.Fields().ByName("f59").Number()
	largeFieldF60  = largeMessageDesc.Fields().ByName("f60").Number()
	largeFieldF61  = largeMessageDesc.Fields().ByName("f61").Number()
	largeFieldF62  = largeMessageDesc.Fields().ByName("f62").Number()
	largeFieldF63  = largeMessageDesc.Fields().ByName("f63").Number()
	largeFieldF64  = largeMessageDesc.Fields().ByName("f64").Number()
	largeFieldF65  = largeMessageDesc.Fields().ByName("f65").Number()
	largeFieldF66  = largeMessageDesc.Fields().ByName("f66").Number()
	largeFieldF67  = largeMessageDesc.Fields().ByName("f67").Number()
	largeFieldF68  = largeMessageDesc.Fields().ByName("f68").Number()
	largeFieldF69  = largeMessageDesc.Fields().ByName("f69").Number()
	largeFieldF70  = largeMessageDesc.Fields().ByName("f70").Number()
	largeFieldF71  = largeMessageDesc.Fields().ByName("f71").Number()
	largeFieldF72  = largeMessageDesc.Fields().ByName("f72").Number()
	largeFieldF73  = largeMessageDesc.Fields().ByName("f73").Number()
	largeFieldF74  = largeMessageDesc.Fields().ByName("f74").Number()
	largeFieldF75  = largeMessageDesc.Fields().ByName("f75").Number()
	largeFieldF76  = largeMessageDesc.Fields().ByName("f76").Number()
	largeFieldF77  = largeMessageDesc.Fields().ByName("f77").Number()
	largeFieldF78  = largeMessageDesc.Fields().ByName("f78").Number()
	largeFieldF79  = largeMessageDesc.Fields().ByName("f79").Number()
	largeFieldF80  = largeMessageDesc.Fields().ByName("f80").Number()
	largeFieldF81  = largeMessageDesc.Fields().ByName("f81").Number()
	largeFieldF82  = largeMessageDesc.Fields().ByName("f82").Number()
	largeFieldF83  = largeMessageDesc.Fields().ByName("f83").Number()
	largeFieldF84  = largeMessageDesc.Fields().ByName("f84").Number()
	largeFieldF85  = largeMessageDesc.Fields().ByName("f85").Number()
	largeFieldF86  = largeMessageDesc.Fields().ByName("f86").Number()
	largeFieldF87  = largeMessageDesc.Fields().ByName("f87").Number()
	largeFieldF88  = largeMessageDesc.Fields().ByName("f88").Number()
	largeFieldF89  = largeMessageDesc.Fields().ByName("f89").Number()
	largeFieldF90  = largeMessageDesc.Fields().ByName("f90").Number()
	largeFieldF91  = largeMessageDesc.Fields().ByName("f91").Number()
	largeFieldF92  = largeMessageDesc.Fields().ByName("f92").Number()
	largeFieldF93  = largeMessageDesc.Fields().ByName("f93").Number()
	largeFieldF94  = largeMessageDesc.Fields().ByName("f94").Number()
	largeFieldF95  = largeMessageDesc.Fields().ByName("f95").Number()
	largeFieldF96  = largeMessageDesc.Fields().ByName("f96").Number()
	largeFieldF97  = largeMessageDesc.Fields().ByName("f97").Number()
	largeFieldF98  = largeMessageDesc.Fields().ByName("f98").Number()
	largeFieldF99  = largeMessageDesc.Fields().ByName("f99").Number()
	largeFieldF100 = largeMessageDesc.Fields().ByName("f100").Number()
)

var (
	messageDesc protoreflect.MessageDescriptor = (&testopenpb.TestAllTypes{}).ProtoReflect().Descriptor()

	fieldSingularInt32       = messageDesc.Fields().ByName("singular_int32").Number()
	fieldSingularInt64       = messageDesc.Fields().ByName("singular_int64").Number()
	fieldSingularUint32      = messageDesc.Fields().ByName("singular_uint32").Number()
	fieldSingularUint64      = messageDesc.Fields().ByName("singular_uint64").Number()
	fieldSingularSint32      = messageDesc.Fields().ByName("singular_sint32").Number()
	fieldSingularSint64      = messageDesc.Fields().ByName("singular_sint64").Number()
	fieldSingularFixed32     = messageDesc.Fields().ByName("singular_fixed32").Number()
	fieldSingularFixed64     = messageDesc.Fields().ByName("singular_fixed64").Number()
	fieldSingularSfixed32    = messageDesc.Fields().ByName("singular_sfixed32").Number()
	fieldSingularSfixed64    = messageDesc.Fields().ByName("singular_sfixed64").Number()
	fieldSingularFloat       = messageDesc.Fields().ByName("singular_float").Number()
	fieldSingularDouble      = messageDesc.Fields().ByName("singular_double").Number()
	fieldSingularBool        = messageDesc.Fields().ByName("singular_bool").Number()
	fieldSingularString      = messageDesc.Fields().ByName("singular_string").Number()
	fieldSingularBytes       = messageDesc.Fields().ByName("singular_bytes").Number()
	fieldSingularNestedEnum  = messageDesc.Fields().ByName("singular_nested_enum").Number()
	fieldSingularForeignEnum = messageDesc.Fields().ByName("singular_foreign_enum").Number()
	fieldSingularImportEnum  = messageDesc.Fields().ByName("singular_import_enum").Number()

	fieldOptionalInt32             = messageDesc.Fields().ByName("optional_int32").Number()
	fieldOptionalInt64             = messageDesc.Fields().ByName("optional_int64").Number()
	fieldOptionalUint32            = messageDesc.Fields().ByName("optional_uint32").Number()
	fieldOptionalUint64            = messageDesc.Fields().ByName("optional_uint64").Number()
	fieldOptionalSint32            = messageDesc.Fields().ByName("optional_sint32").Number()
	fieldOptionalSint64            = messageDesc.Fields().ByName("optional_sint64").Number()
	fieldOptionalFixed32           = messageDesc.Fields().ByName("optional_fixed32").Number()
	fieldOptionalFixed64           = messageDesc.Fields().ByName("optional_fixed64").Number()
	fieldOptionalSfixed32          = messageDesc.Fields().ByName("optional_sfixed32").Number()
	fieldOptionalSfixed64          = messageDesc.Fields().ByName("optional_sfixed64").Number()
	fieldOptionalFloat             = messageDesc.Fields().ByName("optional_float").Number()
	fieldOptionalDouble            = messageDesc.Fields().ByName("optional_double").Number()
	fieldOptionalBool              = messageDesc.Fields().ByName("optional_bool").Number()
	fieldOptionalString            = messageDesc.Fields().ByName("optional_string").Number()
	fieldOptionalBytes             = messageDesc.Fields().ByName("optional_bytes").Number()
	fieldOptionalGroup             = messageDesc.Fields().ByName("optionalgroup").Number()
	fieldOptionalNestedMessage     = messageDesc.Fields().ByName("optional_nested_message").Number()
	fieldOptionalForeignMessage    = messageDesc.Fields().ByName("optional_foreign_message").Number()
	fieldOptionalImportMessage     = messageDesc.Fields().ByName("optional_import_message").Number()
	fieldOptionalNestedEnum        = messageDesc.Fields().ByName("optional_nested_enum").Number()
	fieldOptionalForeignEnum       = messageDesc.Fields().ByName("optional_foreign_enum").Number()
	fieldOptionalImportEnum        = messageDesc.Fields().ByName("optional_import_enum").Number()
	fieldOptionalLazyNestedMessage = messageDesc.Fields().ByName("optional_lazy_nested_message").Number()
	fieldNotGroupLikeDelimited     = messageDesc.Fields().ByName("not_group_like_delimited").Number()

	fieldRepeatedInt32          = messageDesc.Fields().ByName("repeated_int32").Number()
	fieldRepeatedInt64          = messageDesc.Fields().ByName("repeated_int64").Number()
	fieldRepeatedUint32         = messageDesc.Fields().ByName("repeated_uint32").Number()
	fieldRepeatedUint64         = messageDesc.Fields().ByName("repeated_uint64").Number()
	fieldRepeatedSint32         = messageDesc.Fields().ByName("repeated_sint32").Number()
	fieldRepeatedSint64         = messageDesc.Fields().ByName("repeated_sint64").Number()
	fieldRepeatedFixed32        = messageDesc.Fields().ByName("repeated_fixed32").Number()
	fieldRepeatedFixed64        = messageDesc.Fields().ByName("repeated_fixed64").Number()
	fieldRepeatedSfixed32       = messageDesc.Fields().ByName("repeated_sfixed32").Number()
	fieldRepeatedSfixed64       = messageDesc.Fields().ByName("repeated_sfixed64").Number()
	fieldRepeatedFloat          = messageDesc.Fields().ByName("repeated_float").Number()
	fieldRepeatedDouble         = messageDesc.Fields().ByName("repeated_double").Number()
	fieldRepeatedBool           = messageDesc.Fields().ByName("repeated_bool").Number()
	fieldRepeatedString         = messageDesc.Fields().ByName("repeated_string").Number()
	fieldRepeatedBytes          = messageDesc.Fields().ByName("repeated_bytes").Number()
	fieldRepeatedGroup          = messageDesc.Fields().ByName("repeatedgroup").Number()
	fieldRepeatedNestedMessage  = messageDesc.Fields().ByName("repeated_nested_message").Number()
	fieldRepeatedForeignMessage = messageDesc.Fields().ByName("repeated_foreign_message").Number()
	fieldRepeatedImportMessage  = messageDesc.Fields().ByName("repeated_importmessage").Number()
	fieldRepeatedNestedEnum     = messageDesc.Fields().ByName("repeated_nested_enum").Number()
	fieldRepeatedForeignEnum    = messageDesc.Fields().ByName("repeated_foreign_enum").Number()
	fieldRepeatedImportEnum     = messageDesc.Fields().ByName("repeated_importenum").Number()

	fieldMapInt32Int32          = messageDesc.Fields().ByName("map_int32_int32").Number()
	fieldMapInt64Int64          = messageDesc.Fields().ByName("map_int64_int64").Number()
	fieldMapUint32Uint32        = messageDesc.Fields().ByName("map_uint32_uint32").Number()
	fieldMapUint64Uint64        = messageDesc.Fields().ByName("map_uint64_uint64").Number()
	fieldMapSint32Sint32        = messageDesc.Fields().ByName("map_sint32_sint32").Number()
	fieldMapSint64Sint64        = messageDesc.Fields().ByName("map_sint64_sint64").Number()
	fieldMapFixed32Fixed32      = messageDesc.Fields().ByName("map_fixed32_fixed32").Number()
	fieldMapFixed64Fixed64      = messageDesc.Fields().ByName("map_fixed64_fixed64").Number()
	fieldMapSfixed32Sfixed32    = messageDesc.Fields().ByName("map_sfixed32_sfixed32").Number()
	fieldMapSfixed64Sfixed64    = messageDesc.Fields().ByName("map_sfixed64_sfixed64").Number()
	fieldMapInt32Float          = messageDesc.Fields().ByName("map_int32_float").Number()
	fieldMapInt32Double         = messageDesc.Fields().ByName("map_int32_double").Number()
	fieldMapBoolBool            = messageDesc.Fields().ByName("map_bool_bool").Number()
	fieldMapStringString        = messageDesc.Fields().ByName("map_string_string").Number()
	fieldMapStringBytes         = messageDesc.Fields().ByName("map_string_bytes").Number()
	fieldMapStringNestedMessage = messageDesc.Fields().ByName("map_string_nested_message").Number()
	fieldMapStringNestedEnum    = messageDesc.Fields().ByName("map_string_nested_enum").Number()

	fieldDefaultInt32       = messageDesc.Fields().ByName("default_int32").Number()
	fieldDefaultInt64       = messageDesc.Fields().ByName("default_int64").Number()
	fieldDefaultUint32      = messageDesc.Fields().ByName("default_uint32").Number()
	fieldDefaultUint64      = messageDesc.Fields().ByName("default_uint64").Number()
	fieldDefaultSint32      = messageDesc.Fields().ByName("default_sint32").Number()
	fieldDefaultSint64      = messageDesc.Fields().ByName("default_sint64").Number()
	fieldDefaultFixed32     = messageDesc.Fields().ByName("default_fixed32").Number()
	fieldDefaultFixed64     = messageDesc.Fields().ByName("default_fixed64").Number()
	fieldDefaultSfixed32    = messageDesc.Fields().ByName("default_sfixed32").Number()
	fieldDefaultSfixed64    = messageDesc.Fields().ByName("default_sfixed64").Number()
	fieldDefaultFloat       = messageDesc.Fields().ByName("default_float").Number()
	fieldDefaultDouble      = messageDesc.Fields().ByName("default_double").Number()
	fieldDefaultBool        = messageDesc.Fields().ByName("default_bool").Number()
	fieldDefaultString      = messageDesc.Fields().ByName("default_string").Number()
	fieldDefaultBytes       = messageDesc.Fields().ByName("default_bytes").Number()
	fieldDefaultNestedEnum  = messageDesc.Fields().ByName("default_nested_enum").Number()
	fieldDefaultForeignEnum = messageDesc.Fields().ByName("default_foreign_enum").Number()

	fieldOneofUint32         = messageDesc.Fields().ByName("oneof_uint32").Number()
	fieldOneofNestedMessage  = messageDesc.Fields().ByName("oneof_nested_message").Number()
	fieldOneofString         = messageDesc.Fields().ByName("oneof_string").Number()
	fieldOneofBytes          = messageDesc.Fields().ByName("oneof_bytes").Number()
	fieldOneofBool           = messageDesc.Fields().ByName("oneof_bool").Number()
	fieldOneofUint64         = messageDesc.Fields().ByName("oneof_uint64").Number()
	fieldOneofFloat          = messageDesc.Fields().ByName("oneof_float").Number()
	fieldOneofDouble         = messageDesc.Fields().ByName("oneof_double").Number()
	fieldOneofEnum           = messageDesc.Fields().ByName("oneof_enum").Number()
	fieldOneofGroup          = messageDesc.Fields().ByName("oneofgroup").Number()
	fieldOneofOptionalUint32 = messageDesc.Fields().ByName("oneof_optional_uint32").Number()
)

// testMessageType is an implementation of protoreflect.MessageType.
type testMessageType struct {
	protoreflect.MessageDescriptor
	new func() protoreflect.Message
}

func (m *testMessageType) New() protoreflect.Message                  { return m.new() }
func (m *testMessageType) Zero() protoreflect.Message                 { return m.new() }
func (m *testMessageType) GoType() reflect.Type                       { panic("unimplemented") }
func (m *testMessageType) Descriptor() protoreflect.MessageDescriptor { return m.MessageDescriptor }

// testProtoMessage adapts the concrete API for a message to the ProtoReflect interface.
type testProtoMessage struct {
	m     protoreflect.ProtoMessage
	md    protoreflect.MessageDescriptor
	new   func() protoreflect.Message
	has   func(protoreflect.FieldNumber) bool
	get   func(protoreflect.FieldNumber) any
	set   func(protoreflect.FieldNumber, any)
	clear func(protoreflect.FieldNumber)
}

func (m *testProtoMessage) ProtoReflect() protoreflect.Message { return (*testMessage)(m) }

// testMessage implements protoreflect.Message.
type testMessage testProtoMessage

func (m *testMessage) Interface() protoreflect.ProtoMessage       { return (*testProtoMessage)(m) }
func (m *testMessage) ProtoMethods() *protoiface.Methods          { return nil }
func (m *testMessage) Descriptor() protoreflect.MessageDescriptor { return m.md }
func (m *testMessage) Type() protoreflect.MessageType             { return &testMessageType{m.md, m.new} }
func (m *testMessage) New() protoreflect.Message                  { return m.new() }
func (m *testMessage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	fields := m.md.Fields()
	for i := 0; i < fields.Len(); i++ {
		fd := fields.Get(i)
		if !m.Has(fd) {
			continue
		}
		if !f(fd, m.Get(fd)) {
			break
		}
	}
}
func (m *testMessage) Has(fd protoreflect.FieldDescriptor) bool {
	return m.has(fd.Number())
}
func (m *testMessage) Clear(fd protoreflect.FieldDescriptor) {
	m.clear(fd.Number())
}
func (m *testMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
	num := fd.Number()
	switch {
	case fd.IsMap():
		if !m.has(num) {
			return protoreflect.ValueOfMap(&testMap{reflect.Zero(reflect.TypeOf(m.get(num))), fd})
		}
		return protoreflect.ValueOfMap(&testMap{reflect.ValueOf(m.get(num)), fd})
	case fd.IsList():
		if !m.has(num) {
			return protoreflect.ValueOfList(&zeroList{reflect.TypeOf(m.get(num)).Elem(), fd})
		}
		return protoreflect.ValueOfList(&testList{m: (*testProtoMessage)(m), fd: fd})
	case fd.Message() != nil:
		if !m.has(fd.Number()) {
			return protoreflect.Value{}
		}
	}
	return singularValueOf(m.get(num))
}
func (m *testMessage) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
	num := fd.Number()
	switch {
	case fd.IsMap():
		if !v.Map().IsValid() {
			panic("set with invalid map")
		}
		m.set(num, v.Map().(*testMap).val.Interface())
	case fd.IsList():
		if !v.List().IsValid() {
			panic("set with invalid list")
		}
		m.set(num, v.List().(*testList).field().Interface())
	case fd.Message() != nil:
		i := v.Message().Interface()
		if p, ok := i.(*testProtoMessage); ok {
			i = p.m
		}
		m.set(num, i)
	default:
		m.set(num, v.Interface())
	}
}
func (m *testMessage) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	num := fd.Number()
	if !m.Has(fd) && (fd.IsMap() || fd.IsList() || fd.Message() != nil) {
		switch {
		case fd.IsMap():
			typ := reflect.ValueOf(m.get(num)).Type()
			m.set(num, reflect.MakeMap(typ).Interface())
			return protoreflect.ValueOfMap(&testMap{reflect.ValueOf(m.get(num)), fd})
		case fd.IsList():
			return protoreflect.ValueOfList(&testList{m: (*testProtoMessage)(m), fd: fd})
		case fd.Message() != nil:
			typ := reflect.ValueOf(m.get(num)).Type()
			m.set(num, reflect.New(typ.Elem()).Interface())
		}
	}
	return m.Get(fd)
}
func (m *testMessage) NewMessage(fd protoreflect.FieldDescriptor) protoreflect.Message {
	return singularValueOf(m.NewField(fd)).Message()
}
func (m *testMessage) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	num := fd.Number()
	switch {
	case fd.IsMap():
		typ := reflect.ValueOf(m.get(num)).Type()
		return protoreflect.ValueOf(&testMap{reflect.MakeMap(typ), fd})
	case fd.IsList():
		typ := reflect.ValueOf(m.get(num)).Type()
		return protoreflect.ValueOf(&testList{val: reflect.Zero(typ), fd: fd})
	case fd.Message() != nil:
		typ := reflect.ValueOf(m.get(num)).Type()
		return singularValueOf(reflect.New(typ.Elem()).Interface())
	default:
		// Obtain the default value of the field by creating an empty message
		// and calling the getter.
		n := m.new().(*testMessage)
		return singularValueOf(n.get(num))
	}
}
func (m *testMessage) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	for i := 0; i < od.Fields().Len(); i++ {
		fd := od.Fields().Get(i)
		if m.has(fd.Number()) {
			return fd
		}
	}
	return nil
}
func (m *testMessage) GetUnknown() protoreflect.RawFields {
	return m.m.ProtoReflect().GetUnknown()
}
func (m *testMessage) SetUnknown(raw protoreflect.RawFields) {
	m.m.ProtoReflect().SetUnknown(raw)
}
func (m *testMessage) IsValid() bool {
	return !reflect.ValueOf(m.m).IsNil()
}

func singularValueOf(v any) protoreflect.Value {
	switch v := v.(type) {
	case protoreflect.ProtoMessage:
		return protoreflect.ValueOf(v.ProtoReflect())
	case protoreflect.Enum:
		return protoreflect.ValueOf(v.Number())
	default:
		return protoreflect.ValueOf(v)
	}
}

// testList implements protoreflect.List over a concrete slice of values.
type testList struct {
	m   *testProtoMessage
	val reflect.Value
	fd  protoreflect.FieldDescriptor
}

func (x *testList) field() reflect.Value {
	if x.m == nil {
		return x.val
	}
	return reflect.ValueOf(x.m.get(x.fd.Number()))
}
func (x *testList) setField(v reflect.Value) {
	if x.m == nil {
		x.val = v
		return
	}
	x.m.set(x.fd.Number(), v.Interface())
}
func (x *testList) Len() int { return x.field().Len() }
func (x *testList) Get(n int) protoreflect.Value {
	return singularValueOf(x.field().Index(n).Interface())
}
func (x *testList) Set(n int, v protoreflect.Value) {
	switch x.fd.Kind() {
	case protoreflect.MessageKind, protoreflect.GroupKind:
		x.field().Index(n).Set(reflect.ValueOf(v.Message().Interface()))
	case protoreflect.EnumKind:
		x.field().Index(n).SetInt(int64(v.Enum()))
	default:
		x.field().Index(n).Set(reflect.ValueOf(v.Interface()))
	}
}
func (x *testList) Append(v protoreflect.Value) {
	f := x.field()
	x.setField(reflect.Append(f, reflect.Zero(f.Type().Elem())))
	x.Set(f.Len(), v)
}
func (x *testList) AppendMutable() protoreflect.Value {
	if x.fd.Message() == nil {
		panic("invalid AppendMutable on list with non-message value type")
	}
	v := x.NewElement()
	x.Append(v)
	return v
}
func (x *testList) Truncate(n int) {
	x.setField(x.field().Slice(0, n))
}
func (x *testList) NewMessage() protoreflect.Message {
	return x.NewElement().Message()
}
func (x *testList) NewElement() protoreflect.Value {
	// For enums, List.NewElement returns the first enum value.
	if ee := newEnumElement(x.fd); ee.IsValid() {
		return ee
	}
	var v reflect.Value
	typ := x.field().Type().Elem()
	if typ.Kind() == reflect.Ptr {
		v = reflect.New(typ.Elem())
	} else {
		v = reflect.Zero(typ)
	}
	return singularValueOf(v.Interface())
}
func (x *testList) IsValid() bool {
	return true
}

func newEnumElement(fd protoreflect.FieldDescriptor) protoreflect.Value {
	if fd.Kind() != protoreflect.EnumKind {
		return protoreflect.Value{}
	}
	if val := fd.Enum().Values(); val.Len() > 0 {
		return protoreflect.ValueOfEnum(val.Get(0).Number())
	}
	return protoreflect.Value{}
}

// testList implements protoreflect.List over a concrete slice of values.
type zeroList struct {
	typ reflect.Type
	fd  protoreflect.FieldDescriptor
}

func (x *zeroList) Len() int                          { return 0 }
func (x *zeroList) Get(n int) protoreflect.Value      { panic("get on zero list") }
func (x *zeroList) Set(n int, v protoreflect.Value)   { panic("set on zero list") }
func (x *zeroList) Append(v protoreflect.Value)       { panic("append on zero list") }
func (x *zeroList) AppendMutable() protoreflect.Value { panic("append on zero list") }
func (x *zeroList) Truncate(n int)                    { panic("truncate on zero list") }
func (x *zeroList) NewMessage() protoreflect.Message {
	return x.NewElement().Message()
}
func (x *zeroList) NewElement() protoreflect.Value {
	// For enums, List.NewElement returns the first enum value.
	if ee := newEnumElement(x.fd); ee.IsValid() {
		return ee
	}
	var v reflect.Value
	if x.typ.Kind() == reflect.Ptr {
		v = reflect.New(x.typ.Elem())
	} else {
		v = reflect.Zero(x.typ)
	}
	return singularValueOf(v.Interface())
}
func (x *zeroList) IsValid() bool {
	return false
}

// testMap implements a protoreflect.Map over a concrete map.
type testMap struct {
	val reflect.Value
	fd  protoreflect.FieldDescriptor
}

func (x *testMap) key(k protoreflect.MapKey) reflect.Value { return reflect.ValueOf(k.Interface()) }
func (x *testMap) valueToProto(v reflect.Value) protoreflect.Value {
	if !v.IsValid() {
		return protoreflect.Value{}
	}
	switch x.fd.Message().Fields().ByNumber(2).Kind() {
	case protoreflect.MessageKind, protoreflect.GroupKind:
		return protoreflect.ValueOf(v.Interface().(protoreflect.ProtoMessage).ProtoReflect())
	case protoreflect.EnumKind:
		return protoreflect.ValueOf(protoreflect.EnumNumber(v.Int()))
	default:
		return protoreflect.ValueOf(v.Interface())
	}
}
func (x *testMap) Len() int                       { return x.val.Len() }
func (x *testMap) Has(k protoreflect.MapKey) bool { return x.val.MapIndex(x.key(k)).IsValid() }
func (x *testMap) Get(k protoreflect.MapKey) protoreflect.Value {
	return x.valueToProto(x.val.MapIndex(x.key(k)))
}
func (x *testMap) Set(k protoreflect.MapKey, v protoreflect.Value) {
	f := x.val
	switch x.fd.MapValue().Kind() {
	case protoreflect.MessageKind, protoreflect.GroupKind:
		f.SetMapIndex(x.key(k), reflect.ValueOf(v.Message().Interface()))
	case protoreflect.EnumKind:
		rv := reflect.New(f.Type().Elem()).Elem()
		rv.SetInt(int64(v.Enum()))
		f.SetMapIndex(x.key(k), rv)
	default:
		f.SetMapIndex(x.key(k), reflect.ValueOf(v.Interface()))
	}
}
func (x *testMap) Mutable(k protoreflect.MapKey) protoreflect.Value {
	if x.fd.MapValue().Message() == nil {
		panic("invalid Mutable on map with non-message value type")
	}
	v := x.Get(k)
	if !v.IsValid() {
		v = x.NewValue()
		x.Set(k, v)
	}
	return v
}
func (x *testMap) Clear(k protoreflect.MapKey) { x.val.SetMapIndex(x.key(k), reflect.Value{}) }
func (x *testMap) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
	iter := x.val.MapRange()
	for iter.Next() {
		if !f(protoreflect.ValueOf(iter.Key().Interface()).MapKey(), x.valueToProto(iter.Value())) {
			return
		}
	}
}
func (x *testMap) NewMessage() protoreflect.Message {
	return x.NewValue().Message()
}
func (x *testMap) NewValue() protoreflect.Value {
	var v reflect.Value
	if x.fd.MapValue().Message() != nil {
		v = reflect.New(x.val.Type().Elem().Elem())
	} else {
		v = reflect.Zero(x.val.Type().Elem())
	}
	return singularValueOf(v.Interface())
}
func (x *testMap) IsValid() bool {
	return !x.val.IsNil()
}

// A shadow message is a wrapper around two protoreflect.Message implementations
// presenting different views of the same underlying data. Read operations
// are directed to one implementation and write operations to the other.

// shadowProtoMessage implements protoreflect.ProtoMessage as a shadow.
type shadowProtoMessage struct {
	get, set protoreflect.Message
	new      func() (get, set protoreflect.ProtoMessage)
}

func newShadow(newf func() (get, set protoreflect.ProtoMessage)) protoreflect.ProtoMessage {
	get, set := newf()
	return &shadowProtoMessage{
		get.ProtoReflect(),
		set.ProtoReflect(),
		newf,
	}
}

func (m *shadowProtoMessage) ProtoReflect() protoreflect.Message { return (*shadowMessage)(m) }

// shadowMessage implements protoreflect.Message as a shadow.
type shadowMessage shadowProtoMessage

func (m *shadowMessage) Interface() protoreflect.ProtoMessage       { return (*shadowProtoMessage)(m) }
func (m *shadowMessage) ProtoMethods() *protoiface.Methods          { return nil }
func (m *shadowMessage) Descriptor() protoreflect.MessageDescriptor { return m.get.Descriptor() }
func (m *shadowMessage) Type() protoreflect.MessageType {
	return &testMessageType{m.Descriptor(), m.New}
}
func (m *shadowMessage) New() protoreflect.Message {
	get, set := m.new()
	return &shadowMessage{
		get: get.ProtoReflect(),
		set: set.ProtoReflect(),
		new: m.new,
	}
}

// TODO: Implement these.
func (m *shadowMessage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
	m.get.Range(func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
		return f(fd, m.Get(fd))
	})
}
func (m *shadowMessage) Has(fd protoreflect.FieldDescriptor) bool {
	return m.get.Has(fd)
}
func (m *shadowMessage) Clear(fd protoreflect.FieldDescriptor) {
	m.set.Clear(fd)
}
func (m *shadowMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
	v := m.get.Get(fd)
	switch {
	case fd.IsList():
		return protoreflect.ValueOfList(&shadowList{v.List(), m.set.Get(fd).List()})
	case fd.IsMap():
		return protoreflect.ValueOfMap(&shadowMap{v.Map(), m.set.Get(fd).Map()})
	default:
		return v
	}
}
func (m *shadowMessage) Set(fd protoreflect.FieldDescriptor, v protoreflect.Value) {
	switch x := v.Interface().(type) {
	case *shadowList:
		m.set.Set(fd, protoreflect.ValueOf(x.set))
	case *shadowMap:
		m.set.Set(fd, protoreflect.ValueOf(x.set))
	default:
		m.set.Set(fd, v)
	}
}
func (m *shadowMessage) Mutable(fd protoreflect.FieldDescriptor) protoreflect.Value {
	v := m.get.Mutable(fd)
	switch {
	case fd.IsList():
		return protoreflect.ValueOf(&shadowList{v.List(), m.set.Mutable(fd).List()})
	case fd.IsMap():
		return protoreflect.ValueOf(&shadowMap{v.Map(), m.set.Mutable(fd).Map()})
	default:
		return v
	}
}
func (m *shadowMessage) NewMessage(fd protoreflect.FieldDescriptor) protoreflect.Message {
	return m.NewField(fd).Message()
}
func (m *shadowMessage) NewField(fd protoreflect.FieldDescriptor) protoreflect.Value {
	return m.set.NewField(fd)
}
func (m *shadowMessage) WhichOneof(od protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
	return m.get.WhichOneof(od)
}
func (m *shadowMessage) GetUnknown() protoreflect.RawFields {
	return m.get.GetUnknown()
}
func (m *shadowMessage) SetUnknown(raw protoreflect.RawFields) {
	m.set.SetUnknown(raw)
}
func (m *shadowMessage) IsValid() bool {
	return m.get.IsValid()
}

// shadowList implements protoreflect.List as a shadow.
type shadowList struct {
	get, set protoreflect.List
}

func (x *shadowList) Len() int                          { return x.get.Len() }
func (x *shadowList) Get(n int) protoreflect.Value      { return x.get.Get(n) }
func (x *shadowList) Set(n int, v protoreflect.Value)   { x.set.Set(n, v) }
func (x *shadowList) Append(v protoreflect.Value)       { x.set.Append(v) }
func (x *shadowList) AppendMutable() protoreflect.Value { return x.set.AppendMutable() }
func (x *shadowList) Truncate(n int)                    { x.set.Truncate(n) }
func (x *shadowList) NewMessage() protoreflect.Message  { return x.set.NewElement().Message() }
func (x *shadowList) NewElement() protoreflect.Value    { return x.set.NewElement() }
func (x *shadowList) IsValid() bool                     { return x.get.IsValid() }

// shadowMap implements protoreflect.Map as a shadow.
type shadowMap struct {
	get, set protoreflect.Map
}

func (x *shadowMap) Len() int                                                   { return x.get.Len() }
func (x *shadowMap) Has(k protoreflect.MapKey) bool                             { return x.get.Has(k) }
func (x *shadowMap) Get(k protoreflect.MapKey) protoreflect.Value               { return x.get.Get(k) }
func (x *shadowMap) Set(k protoreflect.MapKey, v protoreflect.Value)            { x.set.Set(k, v) }
func (x *shadowMap) Mutable(k protoreflect.MapKey) protoreflect.Value           { return x.set.Mutable(k) }
func (x *shadowMap) Clear(k protoreflect.MapKey)                                { x.set.Clear(k) }
func (x *shadowMap) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) { x.get.Range(f) }
func (x *shadowMap) NewMessage() protoreflect.Message                           { return x.set.NewValue().Message() }
func (x *shadowMap) NewValue() protoreflect.Value                               { return x.set.NewValue() }
func (x *shadowMap) IsValid() bool                                              { return x.get.IsValid() }