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

	"reflect"

)

// unwrapper unwraps the value to the underlying value.

// This is implemented by List and Map.

type unwrapper interface {

	protoUnwrap() interface{}

}

// A Converter coverts to/from Go reflect.Value types and protobuf protoreflect.Value types.

type Converter interface {

	// PBValueOf converts a reflect.Value to a protoreflect.Value.

	// GoValueOf converts a protoreflect.Value to a reflect.Value.

	// IsValidPB returns whether a protoreflect.Value is compatible with this type.

	// IsValidGo returns whether a reflect.Value is compatible with this type.

	IsValidGo(reflect.Value) bool

	// New returns a new field value.

	// For scalars, it returns the default value of the field.

	// For composite types, it returns a new mutable value.

	// Zero returns a new field value.

	// For scalars, it returns the default value of the field.

	// For composite types, it returns an immutable, empty value.

}

// NewConverter matches a Go type with a protobuf field and returns a Converter

// that converts between the two. Enums must be a named int32 kind that

// implements protoreflect.Enum, and messages must be pointer to a named

// struct type that implements protoreflect.ProtoMessage.

//

// This matcher deliberately supports a wider range of Go types than what

// protoc-gen-go historically generated to be able to automatically wrap some

// v1 messages generated by other forks of protoc-gen-go.

	switch {

	case fd.IsList():

		return newListConverter(t, fd)

	case fd.IsMap():

		return newMapConverter(t, fd)

	default:

		return newSingularConverter(t, fd)

	}

	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))

}

var (

	boolType    = reflect.TypeOf(bool(false))

	int32Type   = reflect.TypeOf(int32(0))

	int64Type   = reflect.TypeOf(int64(0))

	uint32Type  = reflect.TypeOf(uint32(0))

	uint64Type  = reflect.TypeOf(uint64(0))

	float32Type = reflect.TypeOf(float32(0))

	float64Type = reflect.TypeOf(float64(0))

	stringType  = reflect.TypeOf(string(""))

	bytesType   = reflect.TypeOf([]byte(nil))

	byteType    = reflect.TypeOf(byte(0))

)

var (

)

			// Default isn't defined for repeated fields.

			return zero

		}

		return fd.Default()

	}

	switch fd.Kind() {

		if t.Kind() == reflect.Bool {

			return &boolConverter{t, defVal(fd, boolZero)}

		}

		if t.Kind() == reflect.Int32 {

			return &int32Converter{t, defVal(fd, int32Zero)}

		}

		if t.Kind() == reflect.Int64 {

			return &int64Converter{t, defVal(fd, int64Zero)}

		}

		if t.Kind() == reflect.Uint32 {

			return &uint32Converter{t, defVal(fd, uint32Zero)}

		}

		if t.Kind() == reflect.Uint64 {

			return &uint64Converter{t, defVal(fd, uint64Zero)}

		}

		if t.Kind() == reflect.Float32 {

			return &float32Converter{t, defVal(fd, float32Zero)}

		}

		if t.Kind() == reflect.Float64 {

			return &float64Converter{t, defVal(fd, float64Zero)}

		}

		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {

			return &stringConverter{t, defVal(fd, stringZero)}

		}

		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {

			return &bytesConverter{t, defVal(fd, bytesZero)}

		}

		// Handle enums, which must be a named int32 type.

		if t.Kind() == reflect.Int32 {

			return newEnumConverter(t, fd)

		}

		return newMessageConverter(t)

	}

	panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))

}

type boolConverter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(v.Bool()).Convert(c.goType)

}

	_, ok := v.Interface().(bool)

	return ok

}

func (c *boolConverter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type int32Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(int32(v.Int())).Convert(c.goType)

}

	_, ok := v.Interface().(int32)

	return ok

}

func (c *int32Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type int64Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(int64(v.Int())).Convert(c.goType)

}

	_, ok := v.Interface().(int64)

	return ok

}

func (c *int64Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type uint32Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(uint32(v.Uint())).Convert(c.goType)

}

	_, ok := v.Interface().(uint32)

	return ok

}

func (c *uint32Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type uint64Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(uint64(v.Uint())).Convert(c.goType)

}

	_, ok := v.Interface().(uint64)

	return ok

}

func (c *uint64Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type float32Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(float32(v.Float())).Convert(c.goType)

}

	_, ok := v.Interface().(float32)

	return ok

}

func (c *float32Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type float64Converter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	return reflect.ValueOf(float64(v.Float())).Convert(c.goType)

}

	_, ok := v.Interface().(float64)

	return ok

}

func (c *float64Converter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type stringConverter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

}

	// pref.Value.String never panics, so we go through an interface

	// conversion here to check the type.

	s := v.Interface().(string)

	if c.goType.Kind() == reflect.Slice && s == "" {

		return reflect.Zero(c.goType) // ensure empty string is []byte(nil)

	}

	return reflect.ValueOf(s).Convert(c.goType)

}

	_, ok := v.Interface().(string)

	return ok

}

func (c *stringConverter) IsValidGo(v reflect.Value) bool {

	return v.IsValid() && v.Type() == c.goType

}

type bytesConverter struct {

	goType reflect.Type

}

	if v.Type() != c.goType {

		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))

	}

	if c.goType.Kind() == reflect.String && v.Len() == 0 {