// Copyright 2018 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"

	"math"

	"reflect"

	"sync"

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

)

type fieldInfo struct {

	// These fields are used for protobuf reflection support.

	has        func(pointer) bool

	clear      func(pointer)

}

	// This never occurs for generated message types.

	// It implies that a hand-crafted type has missing Go fields

	// for specific protobuf message fields.

	return fieldInfo{

		fieldDesc: fd,

		has: func(p pointer) bool {

			return false

		},

		clear: func(p pointer) {

			panic("missing Go struct field for " + string(fd.FullName()))

		},

			return fd.Default()

		},

			panic("missing Go struct field for " + string(fd.FullName()))

		},

			panic("missing Go struct field for " + string(fd.FullName()))

		},

			panic("missing Go struct field for " + string(fd.FullName()))

		},

			if v := fd.Default(); v.IsValid() {

				return v

			}

			panic("missing Go struct field for " + string(fd.FullName()))

		},

	}

}

	ft := fs.Type

	if ft.Kind() != reflect.Interface {

		panic(fmt.Sprintf("field %v has invalid type: got %v, want interface kind", fd.FullName(), ft))

	}

	if ot.Kind() != reflect.Struct {

		panic(fmt.Sprintf("field %v has invalid type: got %v, want struct kind", fd.FullName(), ot))

	}

	if !reflect.PtrTo(ot).Implements(ft) {

		panic(fmt.Sprintf("field %v has invalid type: %v does not implement %v", fd.FullName(), ot, ft))

	}

	conv := NewConverter(ot.Field(0).Type, fd)

	isMessage := fd.Message() != nil

	// TODO: Implement unsafe fast path?

	fieldOffset := offsetOf(fs, x)

	return fieldInfo{

		// NOTE: The logic below intentionally assumes that oneof fields are

		// well-formatted. That is, the oneof interface never contains a

		// typed nil pointer to one of the wrapper structs.

		fieldDesc: fd,

		has: func(p pointer) bool {

			if p.IsNil() {

				return false

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {

				return false

			}

			return true

		},

		clear: func(p pointer) {

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.IsNil() || rv.Elem().Type().Elem() != ot {

				// NOTE: We intentionally don't check for rv.Elem().IsNil()

				// so that (*OneofWrapperType)(nil) gets cleared to nil.

				return

			}

			rv.Set(reflect.Zero(rv.Type()))

		},

			if p.IsNil() {

				return conv.Zero()

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {

				return conv.Zero()

			}

			rv = rv.Elem().Elem().Field(0)

			return conv.PBValueOf(rv)

		},

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {

				rv.Set(reflect.New(ot))

			}

			rv = rv.Elem().Elem().Field(0)

			rv.Set(conv.GoValueOf(v))

		},

			if !isMessage {

				panic(fmt.Sprintf("field %v with invalid Mutable call on field with non-composite type", fd.FullName()))

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.IsNil() || rv.Elem().Type().Elem() != ot || rv.Elem().IsNil() {

				rv.Set(reflect.New(ot))

			}

			rv = rv.Elem().Elem().Field(0)

			if rv.Kind() == reflect.Ptr && rv.IsNil() {

			}

			return conv.PBValueOf(rv)

		},

			return conv.New().Message()

		},

			return conv.New()

		},

	}

}

	ft := fs.Type

	if ft.Kind() != reflect.Map {

		panic(fmt.Sprintf("field %v has invalid type: got %v, want map kind", fd.FullName(), ft))

	}

	conv := NewConverter(ft, fd)

	// TODO: Implement unsafe fast path?

	fieldOffset := offsetOf(fs, x)

	return fieldInfo{

		fieldDesc: fd,

		has: func(p pointer) bool {

			if p.IsNil() {

				return false

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			return rv.Len() > 0

		},

		clear: func(p pointer) {

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			rv.Set(reflect.Zero(rv.Type()))

		},

			if p.IsNil() {

				return conv.Zero()

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if rv.Len() == 0 {

				return conv.Zero()

			}

			return conv.PBValueOf(rv)

		},

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			pv := conv.GoValueOf(v)

			if pv.IsNil() {

				panic(fmt.Sprintf("map field %v cannot be set with read-only value", fd.FullName()))

			}

			rv.Set(pv)

		},

			v := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if v.IsNil() {

				v.Set(reflect.MakeMap(fs.Type))

			}

			return conv.PBValueOf(v)

		},

			return conv.New()

		},

	}

}

	ft := fs.Type

	if ft.Kind() != reflect.Slice {

		panic(fmt.Sprintf("field %v has invalid type: got %v, want slice kind", fd.FullName(), ft))

	}

	conv := NewConverter(reflect.PtrTo(ft), fd)

	// TODO: Implement unsafe fast path?

	fieldOffset := offsetOf(fs, x)

	return fieldInfo{

		fieldDesc: fd,

		has: func(p pointer) bool {

			if p.IsNil() {

				return false

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			return rv.Len() > 0

		},

		clear: func(p pointer) {

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			rv.Set(reflect.Zero(rv.Type()))

		},

			if p.IsNil() {

				return conv.Zero()

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type)

			if rv.Elem().Len() == 0 {

				return conv.Zero()

			}

			return conv.PBValueOf(rv)

		},

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			pv := conv.GoValueOf(v)

			if pv.IsNil() {

				panic(fmt.Sprintf("list field %v cannot be set with read-only value", fd.FullName()))

			}

			rv.Set(pv.Elem())

		},

			v := p.Apply(fieldOffset).AsValueOf(fs.Type)

			return conv.PBValueOf(v)

		},

			return conv.New()

		},

	}

}

var (

	nilBytes   = reflect.ValueOf([]byte(nil))

	emptyBytes = reflect.ValueOf([]byte{})

)

	ft := fs.Type

	nullable := fd.HasPresence()

	isBytes := ft.Kind() == reflect.Slice && ft.Elem().Kind() == reflect.Uint8

	if nullable {

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

			// This never occurs for generated message types.

			// Despite the protobuf type system specifying presence,

			// the Go field type cannot represent it.

			nullable = false

		}

		if ft.Kind() == reflect.Ptr {

			ft = ft.Elem()

		}

	}

	conv := NewConverter(ft, fd)

	// TODO: Implement unsafe fast path?

	fieldOffset := offsetOf(fs, x)

	return fieldInfo{

		fieldDesc: fd,

		has: func(p pointer) bool {

			if p.IsNil() {

				return false

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if nullable {

				return !rv.IsNil()

			}

			switch rv.Kind() {

			case reflect.Bool:

				return rv.Bool()

			case reflect.Int32, reflect.Int64:

				return rv.Int() != 0

			case reflect.Uint32, reflect.Uint64:

				return rv.Uint() != 0

			case reflect.Float32, reflect.Float64:

				return rv.Float() != 0 || math.Signbit(rv.Float())

			case reflect.String, reflect.Slice:

				return rv.Len() > 0

			default:

				panic(fmt.Sprintf("field %v has invalid type: %v", fd.FullName(), rv.Type())) // should never happen

			}

		},

		clear: func(p pointer) {

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			rv.Set(reflect.Zero(rv.Type()))

		},

			if p.IsNil() {

				return conv.Zero()

			}

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if nullable {

				if rv.IsNil() {

					return conv.Zero()

				}

				if rv.Kind() == reflect.Ptr {

					rv = rv.Elem()

				}

			}

			return conv.PBValueOf(rv)

		},

			rv := p.Apply(fieldOffset).AsValueOf(fs.Type).Elem()

			if nullable && rv.Kind() == reflect.Ptr {

				if rv.IsNil() {

					rv.Set(reflect.New(ft))

				}

				rv = rv.Elem()

			}

			rv.Set(conv.GoValueOf(v))

			if isBytes && rv.Len() == 0 {

				if nullable {

					rv.Set(emptyBytes) // preserve presence

				} else {

					rv.Set(nilBytes) // do not preserve presence

				}

			}

		},

			return conv.New()

		},

	}

}

	if !flags.ProtoLegacy {

		panic("no support for proto1 weak fields")

	}

	var once sync.Once

	lazyInit := func() {

		once.Do(func() {

			messageName := fd.Message().FullName()

			if messageType == nil {

				panic(fmt.Sprintf("weak message %v for field %v is not linked in", messageName, fd.FullName()))

			}

		})

	}

	num := fd.Number()

	return fieldInfo{

		fieldDesc: fd,

		has: func(p pointer) bool {

			if p.IsNil() {

				return false

			}

			_, ok := p.Apply(weakOffset).WeakFields().get(num)

			return ok

		},

		clear: func(p pointer) {

			p.Apply(weakOffset).WeakFields().clear(num)

		},

			lazyInit()