// Copyright 2015 The Chromium 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 tests

import (
	"reflect"
	"testing"

	"mojo/public/go/bindings"
	"mojo/public/go/system"
	"mojo/public/interfaces/bindings/tests/rect"
	test "mojo/public/interfaces/bindings/tests/serialization_test_structs"
	"mojo/public/interfaces/bindings/tests/test_structs"
)

func check(t *testing.T, value, zeroValue bindings.Payload) {
	message, err := bindings.EncodeMessage(bindings.MessageHeader{}, value)
	if err != nil {
		t.Fatalf("error encoding value %v: %v", value, err)
	}
	decodedMessage, err := bindings.ParseMessage(message.Bytes, message.Handles)
	if err != nil {
		t.Fatalf("error decoding message header from bytes %v for tested value %v: %v", message.Bytes, value, err)
	}
	if err = decodedMessage.DecodePayload(zeroValue); err != nil {
		t.Fatalf("error decoding message payload from bytes %v for tested value %v: %v", message.Payload, value, err)
	}
	if !reflect.DeepEqual(value, zeroValue) {
		t.Fatalf("unexpected value after decoding: expected %v, got %v", value, zeroValue)
	}
}

func TestSerializationTestStructs(t *testing.T) {
	check(t, &test.Struct1{1}, &test.Struct1{})
	check(t, &test.Struct2{&mockHandle{handle: 1}}, &test.Struct2{})
	check(t, &test.Struct3{test.Struct1{2}}, &test.Struct3{})
	check(t, &test.Struct4{[]test.Struct1{test.Struct1{1}, test.Struct1{2}}}, &test.Struct4{})
	check(t, &test.Struct5{[2]test.Struct1{test.Struct1{1}, test.Struct1{2}}}, &test.Struct5{})
	check(t, &test.Struct6{"hello, world!"}, &test.Struct6{})

	check(t, &test.StructOfNullables{nil, nil, nil}, &test.StructOfNullables{})
	handle := system.Handle(&mockHandle{handle: 1})
	s := "hello, world"
	check(t, &test.StructOfNullables{&handle, nil, nil}, &test.StructOfNullables{})
	check(t, &test.StructOfNullables{&handle, &test.Struct1{3}, nil}, &test.StructOfNullables{})
	check(t, &test.StructOfNullables{&handle, &test.Struct1{3}, &s}, &test.StructOfNullables{})
	check(t, &test.StructOfNullables{&handle, nil, &s}, &test.StructOfNullables{})
}

func TestStructs(t *testing.T) {
	s1 := "hello, world!"
	s2 := "world, hello!"
	handle := system.Handle(&mockHandle{handle: 1})
	messagePipeHandle := system.MessagePipeHandle(&mockHandle{handle: 2})
	consumerHandle := system.ConsumerHandle(&mockHandle{handle: 3})
	producerHandle := system.ProducerHandle(&mockHandle{handle: 4})
	sharedBufferHandle := system.SharedBufferHandle(&mockHandle{handle: 5})
	value := bindings.Payload(&test_structs.NoDefaultFieldValues{
		F0:  true,                        // bool
		F1:  -2,                          // int8
		F2:  3,                           // uint8
		F3:  -4000,                       // int16
		F4:  5000,                        // uint16
		F5:  -6000000,                    // int32
		F6:  7000000,                     // uint32
		F7:  -8000000000000,              // int64
		F8:  9000000000000,               // uint64
		F9:  1e-45,                       // float
		F10: -1e45,                       // double
		F11: s1,                          // string
		F12: &s2,                         // string?
		F13: messagePipeHandle,           // handle<message_pipe>
		F14: consumerHandle,              // handle<data_pipe_consumer>
		F15: producerHandle,              // handle<data_pipe_producer>
		F16: &messagePipeHandle,          // handle<message_pipe>?
		F17: &consumerHandle,             // handle<data_pipe_consumer>?
		F18: &producerHandle,             // handle<data_pipe_producer>?
		F19: handle,                      // handle
		F20: &handle,                     // handle?
		F21: sharedBufferHandle,          // handle<shared_buffer>
		F22: &sharedBufferHandle,         // handle<shared_buffer>?
		F23: []string{s1, s2},            // array<string>
		F24: []*string{&s1, &s2},         // array<string?>
		F25: &[]string{s1, s2},           // array<string>?
		F26: &[]*string{&s1, &s2},        // array<string?>?
		F27: test_structs.EmptyStruct{},  // EmptyStruct
		F28: &test_structs.EmptyStruct{}, // EmptyStruct?
	})
	check(t, value, &test_structs.NoDefaultFieldValues{})

	value = &test_structs.ScopedConstants{
		test_structs.ScopedConstants_EType_E0,
		test_structs.ScopedConstants_EType_E1,
		test_structs.ScopedConstants_EType_E2,
		test_structs.ScopedConstants_EType_E3,
		test_structs.ScopedConstants_EType_E4,
		10,
		25,
	}
	check(t, value, &test_structs.ScopedConstants{})

	value = &test_structs.MapKeyTypes{
		F0:  map[bool]bool{false: true, true: false},
		F1:  map[int8]int8{15: -45, -42: 50},
		F2:  map[uint8]uint8{15: 45, 42: 50},
		F3:  map[int16]int16{-15: 45, -42: 50},
		F4:  map[uint16]uint16{15: 45, 42: 50},
		F5:  map[int32]int32{15: -45, 42: 50},
		F6:  map[uint32]uint32{15: 45, 42: 50},
		F7:  map[int64]int64{15: 45, 42: -50},
		F8:  map[uint64]uint64{15: 45, 42: 50},
		F9:  map[float32]float32{1.5: 2.5, 3.5: 1e-9},
		F10: map[float64]float64{1.5: 2.5, 3.5: 1e-9},
		F11: map[string]string{s1: s2, s2: s1},
	}
	check(t, value, &test_structs.MapKeyTypes{})

	value = &test_structs.MapValueTypes{
		F0: map[string][]string{
			s1: []string{s1, s2},
			s2: []string{s2, s1},
		},
		F1: map[string]*[]string{
			s1: &[]string{s1, s2},
			s2: &[]string{s2, s1},
		},
		F2: map[string][]*string{
			s1: []*string{&s1, &s2},
			s2: []*string{&s2, &s1},
		},
		F3: map[string][2]string{
			s1: [2]string{s1, s2},
			s2: [2]string{s2, s1},
		},
		F4: map[string][]*[2]string{
			s1: []*[2]string{&[2]string{s1, s2}},
			s2: []*[2]string{&[2]string{s1, s2}},
		},
		F5: map[string][1][2]string{
			s1: [1][2]string{[2]string{s1, s2}},
			s2: [1][2]string{[2]string{s1, s2}},
		},
		F6: map[string]*rect.Rect{
			s1: &rect.Rect{},
			s2: &rect.Rect{3, 4, 5, 6},
		},
		F7: map[string]map[string]string{
			s1: map[string]string{s1: s1, s2: s2},
			s2: map[string]string{s1: s2, s2: s1},
		},
		F8: map[string][]map[string]string{
			s1: []map[string]string{
				map[string]string{s1: s1, s2: s2},
				map[string]string{s1: s2, s2: s1},
			},
			s2: []map[string]string{
				map[string]string{s1: s1, s2: s2},
				map[string]string{s1: s2, s2: s1},
			},
		},
		F9: map[string]system.Handle{
			s1: handle,
			s2: handle,
		},
		F10: map[string][]system.Handle{
			s1: []system.Handle{handle},
			s2: []system.Handle{},
		},
		F11: map[string]map[string]system.Handle{
			s1: map[string]system.Handle{s1: handle},
			s2: map[string]system.Handle{s2: handle},
		},
  }
	check(t, value, &test_structs.MapValueTypes{})

	value = &test_structs.BitArrayValues{
		F0: [1]bool{true},
		F1: [7]bool{true, false, true, false, true, false, true},
		F2: [9]bool{true, true, true, false, false, false, true, true, true},
		F3: []bool{true, false, true, false},
		F4: [][]bool{[]bool{true}},
		F5: []*[]bool{
			&[]bool{true, false, true},
			&[]bool{false, true},
		},
		F6: []*[2]bool{
			&[2]bool{false, false},
			&[2]bool{false, true},
			&[2]bool{true, false},
			&[2]bool{true, true},
		},
	}
	check(t, value, &test_structs.BitArrayValues{})
}