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

import (
	"reflect"
	"sync"
	"testing"

	"google.golang.org/protobuf/internal/encoding/pack"
	"google.golang.org/protobuf/proto"

	testpb "google.golang.org/protobuf/internal/testprotos/test"
	test3pb "google.golang.org/protobuf/internal/testprotos/test3"
)

func TestMerge(t *testing.T) {
	tests := []struct {
		desc string
		dst  proto.Message
		src  proto.Message
		want proto.Message

		// If provided, mutator is run on src after merging.
		// It reports whether a mutation is expected to be observable in dst
		// if Shallow is enabled.
		mutator func(proto.Message) bool
	}{{
		desc: "merge from nil message",
		dst:  new(testpb.TestAllTypes),
		src:  (*testpb.TestAllTypes)(nil),
		want: new(testpb.TestAllTypes),
	}, {
		desc: "clone a large message",
		dst:  new(testpb.TestAllTypes),
		src: &testpb.TestAllTypes{
			OptionalInt64:      proto.Int64(0),
			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(1).Enum(),
			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
				A: proto.Int32(100),
			},
			RepeatedSfixed32: []int32{1, 2, 3},
			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
				{A: proto.Int32(200)},
				{A: proto.Int32(300)},
			},
			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
				"fizz": 400,
				"buzz": 500,
			},
			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
				"foo": {A: proto.Int32(600)},
				"bar": {A: proto.Int32(700)},
			},
			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
				&testpb.TestAllTypes_NestedMessage{
					A: proto.Int32(800),
				},
			},
		},
		want: &testpb.TestAllTypes{
			OptionalInt64:      proto.Int64(0),
			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(1).Enum(),
			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
				A: proto.Int32(100),
			},
			RepeatedSfixed32: []int32{1, 2, 3},
			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
				{A: proto.Int32(200)},
				{A: proto.Int32(300)},
			},
			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
				"fizz": 400,
				"buzz": 500,
			},
			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
				"foo": {A: proto.Int32(600)},
				"bar": {A: proto.Int32(700)},
			},
			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
				&testpb.TestAllTypes_NestedMessage{
					A: proto.Int32(800),
				},
			},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			*m.OptionalInt64++
			*m.OptionalNestedEnum++
			*m.OptionalNestedMessage.A++
			m.RepeatedSfixed32[0]++
			*m.RepeatedNestedMessage[0].A++
			delete(m.MapStringNestedEnum, "fizz")
			*m.MapStringNestedMessage["foo"].A++
			*m.OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage.A++
			return true
		},
	}, {
		desc: "merge bytes",
		dst: &testpb.TestAllTypes{
			OptionalBytes:  []byte{1, 2, 3},
			RepeatedBytes:  [][]byte{{1, 2}, {3, 4}},
			MapStringBytes: map[string][]byte{"alpha": {1, 2, 3}},
		},
		src: &testpb.TestAllTypes{
			OptionalBytes:  []byte{4, 5, 6},
			RepeatedBytes:  [][]byte{{5, 6}, {7, 8}},
			MapStringBytes: map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
		},
		want: &testpb.TestAllTypes{
			OptionalBytes:  []byte{4, 5, 6},
			RepeatedBytes:  [][]byte{{1, 2}, {3, 4}, {5, 6}, {7, 8}},
			MapStringBytes: map[string][]byte{"alpha": {4, 5, 6}, "bravo": {1, 2, 3}},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			m.OptionalBytes[0]++
			m.RepeatedBytes[0][0]++
			m.MapStringBytes["alpha"][0]++
			return true
		},
	}, {
		desc: "merge singular fields",
		dst: &testpb.TestAllTypes{
			OptionalInt32:      proto.Int32(1),
			OptionalInt64:      proto.Int64(1),
			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(10).Enum(),
			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
				A: proto.Int32(100),
				Corecursive: &testpb.TestAllTypes{
					OptionalInt64: proto.Int64(1000),
				},
			},
		},
		src: &testpb.TestAllTypes{
			OptionalInt64:      proto.Int64(2),
			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(20).Enum(),
			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
				A: proto.Int32(200),
			},
		},
		want: &testpb.TestAllTypes{
			OptionalInt32:      proto.Int32(1),
			OptionalInt64:      proto.Int64(2),
			OptionalNestedEnum: testpb.TestAllTypes_NestedEnum(20).Enum(),
			OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
				A: proto.Int32(200),
				Corecursive: &testpb.TestAllTypes{
					OptionalInt64: proto.Int64(1000),
				},
			},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			*m.OptionalInt64++
			*m.OptionalNestedEnum++
			*m.OptionalNestedMessage.A++
			return false // scalar mutations are not observable in shallow copy
		},
	}, {
		desc: "merge list fields",
		dst: &testpb.TestAllTypes{
			RepeatedSfixed32: []int32{1, 2, 3},
			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
				{A: proto.Int32(100)},
				{A: proto.Int32(200)},
			},
		},
		src: &testpb.TestAllTypes{
			RepeatedSfixed32: []int32{4, 5, 6},
			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
				{A: proto.Int32(300)},
				{A: proto.Int32(400)},
			},
		},
		want: &testpb.TestAllTypes{
			RepeatedSfixed32: []int32{1, 2, 3, 4, 5, 6},
			RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{
				{A: proto.Int32(100)},
				{A: proto.Int32(200)},
				{A: proto.Int32(300)},
				{A: proto.Int32(400)},
			},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			m.RepeatedSfixed32[0]++
			*m.RepeatedNestedMessage[0].A++
			return true
		},
	}, {
		desc: "merge map fields",
		dst: &testpb.TestAllTypes{
			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
				"fizz": 100,
				"buzz": 200,
				"guzz": 300,
			},
			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
				"foo": {A: proto.Int32(400)},
			},
		},
		src: &testpb.TestAllTypes{
			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
				"fizz": 1000,
				"buzz": 2000,
			},
			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
				"foo": {A: proto.Int32(3000)},
				"bar": {},
			},
		},
		want: &testpb.TestAllTypes{
			MapStringNestedEnum: map[string]testpb.TestAllTypes_NestedEnum{
				"fizz": 1000,
				"buzz": 2000,
				"guzz": 300,
			},
			MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{
				"foo": {A: proto.Int32(3000)},
				"bar": {},
			},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			delete(m.MapStringNestedEnum, "fizz")
			m.MapStringNestedMessage["bar"].A = proto.Int32(1)
			return true
		},
	}, {
		desc: "merge oneof message fields",
		dst: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
				&testpb.TestAllTypes_NestedMessage{
					A: proto.Int32(100),
				},
			},
		},
		src: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
				&testpb.TestAllTypes_NestedMessage{
					Corecursive: &testpb.TestAllTypes{
						OptionalInt64: proto.Int64(1000),
					},
				},
			},
		},
		want: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofNestedMessage{
				&testpb.TestAllTypes_NestedMessage{
					A: proto.Int32(100),
					Corecursive: &testpb.TestAllTypes{
						OptionalInt64: proto.Int64(1000),
					},
				},
			},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			*m.OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage.Corecursive.OptionalInt64++
			return true
		},
	}, {
		desc: "merge oneof scalar fields",
		dst: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofUint32{100},
		},
		src: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofFloat{3.14152},
		},
		want: &testpb.TestAllTypes{
			OneofField: &testpb.TestAllTypes_OneofFloat{3.14152},
		},
		mutator: func(mi proto.Message) bool {
			m := mi.(*testpb.TestAllTypes)
			m.OneofField.(*testpb.TestAllTypes_OneofFloat).OneofFloat++
			return false // scalar mutations are not observable in shallow copy
		},
	}, {
		desc: "merge extension fields",
		dst: func() proto.Message {
			m := new(testpb.TestAllExtensions)
			proto.SetExtension(m, testpb.E_OptionalInt32, int32(32))
			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
				&testpb.TestAllExtensions_NestedMessage{
					A: proto.Int32(50),
				},
			)
			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{1, 2, 3})
			return m
		}(),
		src: func() proto.Message {
			m2 := new(testpb.TestAllExtensions)
			proto.SetExtension(m2, testpb.E_OptionalInt64, int64(1000))
			m := new(testpb.TestAllExtensions)
			proto.SetExtension(m, testpb.E_OptionalInt64, int64(64))
			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
				&testpb.TestAllExtensions_NestedMessage{
					Corecursive: m2,
				},
			)
			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{4, 5, 6})
			return m
		}(),
		want: func() proto.Message {
			m2 := new(testpb.TestAllExtensions)
			proto.SetExtension(m2, testpb.E_OptionalInt64, int64(1000))
			m := new(testpb.TestAllExtensions)
			proto.SetExtension(m, testpb.E_OptionalInt32, int32(32))
			proto.SetExtension(m, testpb.E_OptionalInt64, int64(64))
			proto.SetExtension(m, testpb.E_OptionalNestedMessage,
				&testpb.TestAllExtensions_NestedMessage{
					A:           proto.Int32(50),
					Corecursive: m2,
				},
			)
			proto.SetExtension(m, testpb.E_RepeatedFixed32, []uint32{1, 2, 3, 4, 5, 6})
			return m
		}(),
	}, {
		desc: "merge unknown fields",
		dst: func() proto.Message {
			m := new(testpb.TestAllTypes)
			m.ProtoReflect().SetUnknown(pack.Message{
				pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
			}.Marshal())
			return m
		}(),
		src: func() proto.Message {
			m := new(testpb.TestAllTypes)
			m.ProtoReflect().SetUnknown(pack.Message{
				pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
			}.Marshal())
			return m
		}(),
		want: func() proto.Message {
			m := new(testpb.TestAllTypes)
			m.ProtoReflect().SetUnknown(pack.Message{
				pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
				pack.Tag{Number: 500000, Type: pack.VarintType}, pack.Svarint(-50),
			}.Marshal())
			return m
		}(),
	}}

	for _, tt := range tests {
		t.Run(tt.desc, func(t *testing.T) {
			// Merge should be semantically equivalent to unmarshaling the
			// encoded form of src into the current dst.
			b1, err := proto.MarshalOptions{AllowPartial: true}.Marshal(tt.dst)
			if err != nil {
				t.Fatalf("Marshal(dst) error: %v", err)
			}
			b2, err := proto.MarshalOptions{AllowPartial: true}.Marshal(tt.src)
			if err != nil {
				t.Fatalf("Marshal(src) error: %v", err)
			}
			dst := tt.dst.ProtoReflect().New().Interface()
			err = proto.UnmarshalOptions{AllowPartial: true}.Unmarshal(append(b1, b2...), dst)
			if err != nil {
				t.Fatalf("Unmarshal() error: %v", err)
			}
			if !proto.Equal(dst, tt.want) {
				t.Fatalf("Unmarshal(Marshal(dst)+Marshal(src)) mismatch: got %v, want %v", dst, tt.want)
			}

			proto.Merge(tt.dst, tt.src)
			if !proto.Equal(tt.dst, tt.want) {
				t.Fatalf("Merge() mismatch:\n got %v\nwant %v", tt.dst, tt.want)
			}
			if tt.mutator != nil {
				if !proto.Equal(tt.dst, tt.want) {
					t.Fatalf("mutation observed in dest after modifying merge source:\n got %v\nwant %v", tt.dst, tt.want)
				}
			}
		})
	}
}

// TestMergeAberrant tests inputs that are beyond the protobuf data model.
// Just because there is a test for the current behavior does not mean that
// this will behave the same way in the future.
func TestMergeAberrant(t *testing.T) {
	tests := []struct {
		label string
		dst   proto.Message
		src   proto.Message
		check func(proto.Message) bool
	}{{
		label: "Proto2EmptyBytes",
		dst:   &testpb.TestAllTypes{OptionalBytes: nil},
		src:   &testpb.TestAllTypes{OptionalBytes: []byte{}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).OptionalBytes != nil
		},
	}, {
		label: "Proto3EmptyBytes",
		dst:   &test3pb.TestAllTypes{OptionalBytes: nil},
		src:   &test3pb.TestAllTypes{OptionalBytes: []byte{}},
		check: func(m proto.Message) bool {
			return m.(*test3pb.TestAllTypes).OptionalBytes == nil
		},
	}, {
		label: "EmptyList",
		dst:   &testpb.TestAllTypes{RepeatedInt32: nil},
		src:   &testpb.TestAllTypes{RepeatedInt32: []int32{}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).RepeatedInt32 == nil
		},
	}, {
		label: "ListWithNilBytes",
		dst:   &testpb.TestAllTypes{RepeatedBytes: nil},
		src:   &testpb.TestAllTypes{RepeatedBytes: [][]byte{nil}},
		check: func(m proto.Message) bool {
			return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
		},
	}, {
		label: "ListWithEmptyBytes",
		dst:   &testpb.TestAllTypes{RepeatedBytes: nil},
		src:   &testpb.TestAllTypes{RepeatedBytes: [][]byte{{}}},
		check: func(m proto.Message) bool {
			return reflect.DeepEqual(m.(*testpb.TestAllTypes).RepeatedBytes, [][]byte{{}})
		},
	}, {
		label: "ListWithNilMessage",
		dst:   &testpb.TestAllTypes{RepeatedNestedMessage: nil},
		src:   &testpb.TestAllTypes{RepeatedNestedMessage: []*testpb.TestAllTypes_NestedMessage{nil}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).RepeatedNestedMessage[0] != nil
		},
	}, {
		label: "EmptyMap",
		dst:   &testpb.TestAllTypes{MapStringString: nil},
		src:   &testpb.TestAllTypes{MapStringString: map[string]string{}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).MapStringString == nil
		},
	}, {
		label: "MapWithNilBytes",
		dst:   &testpb.TestAllTypes{MapStringBytes: nil},
		src:   &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": nil}},
		check: func(m proto.Message) bool {
			return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
		},
	}, {
		label: "MapWithEmptyBytes",
		dst:   &testpb.TestAllTypes{MapStringBytes: nil},
		src:   &testpb.TestAllTypes{MapStringBytes: map[string][]byte{"k": {}}},
		check: func(m proto.Message) bool {
			return reflect.DeepEqual(m.(*testpb.TestAllTypes).MapStringBytes, map[string][]byte{"k": {}})
		},
	}, {
		label: "MapWithNilMessage",
		dst:   &testpb.TestAllTypes{MapStringNestedMessage: nil},
		src:   &testpb.TestAllTypes{MapStringNestedMessage: map[string]*testpb.TestAllTypes_NestedMessage{"k": nil}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).MapStringNestedMessage["k"] != nil
		},
	}, {
		label: "OneofWithTypedNilWrapper",
		dst:   &testpb.TestAllTypes{OneofField: nil},
		src:   &testpb.TestAllTypes{OneofField: (*testpb.TestAllTypes_OneofNestedMessage)(nil)},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).OneofField == nil
		},
	}, {
		label: "OneofWithNilMessage",
		dst:   &testpb.TestAllTypes{OneofField: nil},
		src:   &testpb.TestAllTypes{OneofField: &testpb.TestAllTypes_OneofNestedMessage{OneofNestedMessage: nil}},
		check: func(m proto.Message) bool {
			return m.(*testpb.TestAllTypes).OneofField.(*testpb.TestAllTypes_OneofNestedMessage).OneofNestedMessage != nil
		},
		// TODO: extension, nil message
		// TODO: repeated extension, nil
		// TODO: extension bytes
		// TODO: repeated extension, nil message
	}}

	for _, tt := range tests {
		t.Run(tt.label, func(t *testing.T) {
			var pass bool
			func() {
				defer func() { recover() }()
				proto.Merge(tt.dst, tt.src)
				pass = tt.check(tt.dst)
			}()
			if !pass {
				t.Error("check failed")
			}
		})
	}
}

func TestMergeRace(t *testing.T) {
	dst := new(testpb.TestAllTypes)
	srcs := []*testpb.TestAllTypes{
		{OptionalInt32: proto.Int32(1)},
		{OptionalString: proto.String("hello")},
		{RepeatedInt32: []int32{2, 3, 4}},
		{RepeatedString: []string{"goodbye"}},
		{MapStringString: map[string]string{"key": "value"}},
		{OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
			A: proto.Int32(5),
		}},
		func() *testpb.TestAllTypes {
			m := new(testpb.TestAllTypes)
			m.ProtoReflect().SetUnknown(pack.Message{
				pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
			}.Marshal())
			return m
		}(),
	}

	// It should be safe to concurrently merge non-overlapping fields.
	var wg sync.WaitGroup
	defer wg.Wait()
	for _, src := range srcs {
		wg.Add(1)
		go func(src proto.Message) {
			defer wg.Done()
			proto.Merge(dst, src)
		}(src)
	}
}

func TestMergeSelf(t *testing.T) {
	got := &testpb.TestAllTypes{
		OptionalInt32:   proto.Int32(1),
		OptionalString:  proto.String("hello"),
		RepeatedInt32:   []int32{2, 3, 4},
		RepeatedString:  []string{"goodbye"},
		MapStringString: map[string]string{"key": "value"},
		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
			A: proto.Int32(5),
		},
	}
	got.ProtoReflect().SetUnknown(pack.Message{
		pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
	}.Marshal())
	proto.Merge(got, got)

	// The main impact of merging to self is that repeated fields and
	// unknown fields are doubled.
	want := &testpb.TestAllTypes{
		OptionalInt32:   proto.Int32(1),
		OptionalString:  proto.String("hello"),
		RepeatedInt32:   []int32{2, 3, 4, 2, 3, 4},
		RepeatedString:  []string{"goodbye", "goodbye"},
		MapStringString: map[string]string{"key": "value"},
		OptionalNestedMessage: &testpb.TestAllTypes_NestedMessage{
			A: proto.Int32(5),
		},
	}
	want.ProtoReflect().SetUnknown(pack.Message{
		pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
		pack.Tag{Number: 50000, Type: pack.VarintType}, pack.Svarint(-5),
	}.Marshal())

	if !proto.Equal(got, want) {
		t.Errorf("Equal mismatch:\ngot  %v\nwant %v", got, want)
	}
}