// 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 (
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"

	"mojo/public/go/bindings"
	"mojo/public/go/system"
	test "mojo/public/interfaces/bindings/tests/validation_test_interfaces"
)

func getTestPath(name string) string {
	// TODO(rogulenko): try to get a better solution.
	// This should be .../out/name{Debug|Release}/obj/mojo/go.
	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
	if err != nil {
		panic(err)
	}
	// Go 5 folders up.
	for i := 0; i < 5; i++ {
		dir = filepath.Dir(dir)
	}
	testsFolder := filepath.Join("mojo", "public", "interfaces", "bindings", "tests", "data", "validation")
	if name != "" {
		return filepath.Join(dir, testsFolder, name)
	} else {
		return filepath.Join(dir, testsFolder)
	}
}

func listTestFiles() []string {
	files, err := ioutil.ReadDir(getTestPath(""))
	if err != nil {
		panic(err)
	}
	var fileNames []string
	for _, file := range files {
		if file.Mode().IsRegular() {
			fileNames = append(fileNames, file.Name())
		}
	}
	return fileNames
}

func getMatchingTests(fileNames []string, prefix string) []string {
	var result []string
	extension := ".data"
	for _, fileName := range fileNames {
		if strings.HasPrefix(fileName, prefix) && strings.HasSuffix(fileName, extension) {
			result = append(result, strings.TrimSuffix(fileName, extension))
		}
	}
	if len(result) == 0 {
		panic("empty test list")
	}
	return result
}

func readTest(testName string) ([]byte, []system.UntypedHandle) {
	content, err := ioutil.ReadFile(getTestPath(testName + ".data"))
	if err != nil {
		panic(err)
	}
	lines := strings.Split(strings.Replace(string(content), "\r", "\n", -1), "\n")
	for i, _ := range lines {
		lines[i] = strings.Split(lines[i], "//")[0]
	}
	parser := &inputParser{}
	bytes, handles := parser.Parse(strings.Join(lines, " "))
	return bytes, handles
}

func readAnswer(testName string) string {
	content, err := ioutil.ReadFile(getTestPath(testName + ".expected"))
	if err != nil {
		panic(err)
	}
	return strings.TrimSpace(string(content))
}

func pipeOwner(h system.MessagePipeHandle) bindings.MessagePipeHandleOwner {
	return bindings.NewMessagePipeHandleOwner(h)
}

type rawMessage struct {
	Bytes   []byte
	Handles []system.UntypedHandle
}

type mockMessagePipeHandle struct {
	bindings.InvalidHandle
	messages chan rawMessage
}

func NewMockMessagePipeHandle() *mockMessagePipeHandle {
	h := &mockMessagePipeHandle{}
	h.messages = make(chan rawMessage, 10)
	return h
}

func (h *mockMessagePipeHandle) reset() {
	h.messages = make(chan rawMessage, 10)
}

func (h *mockMessagePipeHandle) IsValid() bool {
	return true
}

func (h *mockMessagePipeHandle) ToUntypedHandle() system.UntypedHandle {
	return h
}

func (h *mockMessagePipeHandle) ToMessagePipeHandle() system.MessagePipeHandle {
	return h
}

func (h *mockMessagePipeHandle) ReadMessage(flags system.MojoReadMessageFlags) (system.MojoResult, []byte, []system.UntypedHandle) {
	message := <-h.messages
	return system.MOJO_RESULT_OK, message.Bytes, message.Handles
}

func (h *mockMessagePipeHandle) WriteMessage(bytes []byte, handles []system.UntypedHandle, flags system.MojoWriteMessageFlags) system.MojoResult {
	h.messages <- rawMessage{bytes, handles}
	return system.MOJO_RESULT_OK
}

type conformanceValidator struct {
	CheckArgs bool
	Proxy     test.ConformanceTestInterface
}

func (v *conformanceValidator) Method0(inParam0 float32) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := float32(-1)
	if inParam0 != param0 {
		return fmt.Errorf("unexpected value (Method0, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method0(inParam0)
}

func (v *conformanceValidator) Method1(inParam0 test.StructA) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := test.StructA{1234}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method1, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method1(inParam0)
}

func (v *conformanceValidator) Method2(inParam0 test.StructB, inParam1 test.StructA) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := test.StructB{test.StructA{12345}}
	param1 := test.StructA{67890}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method2, inParam0): expected %v, got %v", param0, inParam0)
	}
	if !reflect.DeepEqual(inParam1, param1) {
		return fmt.Errorf("unexpected value (Method2, inParam1): expected %v, got %v", param1, inParam1)
	}
	return v.Proxy.Method2(inParam0, inParam1)
}

func (v *conformanceValidator) Method3(inParam0 []bool) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := []bool{true, false, true, false, true, false, true, false, true, true, true, true}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method3, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method3(inParam0)
}

func (v *conformanceValidator) Method4(inParam0 test.StructC, inParam1 []uint8) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := test.StructC{[]uint8{0, 1, 2}}
	param1 := []uint8{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method4, inParam0): expected %v, got %v", param0, inParam0)
	}
	if !reflect.DeepEqual(inParam1, param1) {
		return fmt.Errorf("unexpected value (Method4, inParam1): expected %v, got %v", param1, inParam1)
	}
	return v.Proxy.Method4(inParam0, inParam1)
}

func (v *conformanceValidator) Method5(inParam0 test.StructE, inParam1 system.ProducerHandle) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := test.StructE{
		test.StructD{[]system.MessagePipeHandle{
			&mockHandle{handle: 1},
			&mockHandle{handle: 2},
		}},
		&mockHandle{handle: 4},
	}
	param1 := &mockHandle{handle: 5}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method5, inParam0): expected %v, got %v", param0, inParam0)
	}
	if !reflect.DeepEqual(inParam1, param1) {
		return fmt.Errorf("unexpected value (Method5, inParam1): expected %v, got %v", param1, inParam1)
	}
	return v.Proxy.Method5(inParam0, inParam1)
}

func (v *conformanceValidator) Method6(inParam0 [][]uint8) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := [][]uint8{[]uint8{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method6, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method6(inParam0)
}

func (v *conformanceValidator) Method7(inParam0 test.StructF, inParam1 [2]*[3]uint8) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := test.StructF{[3]uint8{0, 1, 2}}
	param1 := [2]*[3]uint8{
		nil,
		&[3]uint8{0, 1, 2},
	}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method7, inParam0): expected %v, got %v", param0, inParam0)
	}
	if !reflect.DeepEqual(inParam1, param1) {
		return fmt.Errorf("unexpected value (Method7, inParam1): expected %v, got %v", param1, inParam1)
	}
	return v.Proxy.Method7(inParam0, inParam1)
}

func (v *conformanceValidator) Method8(inParam0 []*[]string) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := []*[]string{
		nil,
		&[]string{string([]byte{0, 1, 2, 3, 4})},
		nil,
	}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method8, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method8(inParam0)
}

func (v *conformanceValidator) Method9(inParam0 *[][]*system.Handle) error {
	if !v.CheckArgs {
		return nil
	}
	handles := []system.Handle{
		&mockHandle{handle: 1},
		&mockHandle{handle: 3},
		&mockHandle{handle: 4},
	}
	param0 := &[][]*system.Handle{
		[]*system.Handle{&handles[0], nil},
		[]*system.Handle{&handles[1], nil, &handles[2]},
	}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method9, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method9(inParam0)
}

func (v *conformanceValidator) Method10(inParam0 map[string]uint8) error {
	if !v.CheckArgs {
		return nil
	}
	param0 := map[string]uint8{
		string([]byte{0, 1, 2, 3, 4}): 1,
		string([]byte{5, 6, 7, 8, 9}): 2,
	}
	if !reflect.DeepEqual(inParam0, param0) {
		return fmt.Errorf("unexpected value (Method10, inParam0): expected %v, got %v", param0, inParam0)
	}
	return v.Proxy.Method10(inParam0)
}

func (v *conformanceValidator) Method11(test.StructG) error {
	return nil
}

func (v *conformanceValidator) Method12(float32) (float32, error) {
	return 0, nil
}

func (v *conformanceValidator) Method13(*test.InterfaceA_Pointer, uint32, *test.InterfaceA_Pointer) error {
	return nil
}

func verifyValidationError(t *testing.T, test string, err error, answer string) {
	if (err == nil) != (answer == "PASS") {
		t.Fatalf("unexpected result for test %v: %v", test, err)
	}
	if answer != "PASS" {
		validationError, ok := err.(*bindings.ValidationError)
		if !ok {
			t.Fatalf("can't convert err '%v' to ValidationError in test %v", err, test)
		}
		code := validationError.ErrorCode
		if code != answer {
			t.Fatalf("unexpected error code in test %v: got %v(%v), want %v", test, code, err, answer)
		}
	}
}

func TestConformanceValidation(t *testing.T) {
	tests := getMatchingTests(listTestFiles(), "conformance_")

	h := NewMockMessagePipeHandle()
	proxyIn, proxyOut := h, h
	interfacePointer := test.ConformanceTestInterface_Pointer{pipeOwner(proxyIn)}
	impl := &conformanceValidator{false, test.NewConformanceTestInterfaceProxy(interfacePointer, waiter)}

	h = NewMockMessagePipeHandle()
	stubIn, stubOut := h, h
	interfaceRequest := test.ConformanceTestInterface_Request{pipeOwner(stubOut)}
	stub := test.NewConformanceTestInterfaceStub(interfaceRequest, impl, waiter)
	for _, test := range tests {
		bytes, handles := readTest(test)
		answer := readAnswer(test)
		impl.CheckArgs = strings.HasSuffix(test, "_good")
		stubIn.WriteMessage(bytes, handles, system.MOJO_WRITE_MESSAGE_FLAG_NONE)
		err := stub.ServeRequest()
		verifyValidationError(t, test, err, answer)

		if !impl.CheckArgs {
			continue
		}
		// Decode again to verify correctness of encoding.
		_, bytes, handles = proxyOut.ReadMessage(system.MOJO_READ_MESSAGE_FLAG_NONE)
		stubIn.WriteMessage(bytes, handles, system.MOJO_WRITE_MESSAGE_FLAG_NONE)
		if err := stub.ServeRequest(); err != nil {
			t.Fatalf("error processing encoded data for test %v: %v", test, err)
		}
		proxyOut.ReadMessage(system.MOJO_READ_MESSAGE_FLAG_NONE)
		// Do not compare encoded bytes, as some tests contain maps, that
		// can be encoded randomly.
	}
}

func runTests(t *testing.T, prefix string, in *mockMessagePipeHandle, check func() error) {
	tests := getMatchingTests(listTestFiles(), prefix)
	for _, test := range tests {
		bytes, handles := readTest(test)
		answer := readAnswer(test)
		// Replace request ID to match proxy numbers.
		if bytes[0] == 24 {
			bytes[16] = 1
		}
		in.WriteMessage(bytes, handles, system.MOJO_WRITE_MESSAGE_FLAG_NONE)
		verifyValidationError(t, test, check(), answer)
	}
}

type integrationStubImpl struct{}

func (s *integrationStubImpl) Method0(test.BasicStruct) ([]uint8, error) {
	return nil, nil
}

func TestIntegrationTests(t *testing.T) {
	h := NewMockMessagePipeHandle()
	checkStub := func() error {
		interfaceRequest := test.IntegrationTestInterface_Request{pipeOwner(h)}
		stub := test.NewIntegrationTestInterfaceStub(interfaceRequest, &integrationStubImpl{}, waiter)
		err := stub.ServeRequest()
		stub.Close()
		h.reset()
		return err
	}
	runTests(t, "integration_intf_rqst_", h, checkStub)
	runTests(t, "integration_msghdr_", h, checkStub)

	checkProxy := func() error {
		interfacePointer := test.IntegrationTestInterface_Pointer{pipeOwner(h)}
		proxy := test.NewIntegrationTestInterfaceProxy(interfacePointer, waiter)
		_, err := proxy.Method0(test.BasicStruct{})
		proxy.Close_Proxy()
		h.reset()
		return err
	}
	runTests(t, "integration_intf_resp_", h, checkProxy)
	runTests(t, "integration_msghdr_", h, checkProxy)
}

type boundsCheckStubImpl struct{}

func (s *boundsCheckStubImpl) Method0(uint8) (uint8, error) {
	return 0, nil
}

func (s *boundsCheckStubImpl) Method1(uint8) error {
	return nil
}

func TestBoundsCheck(t *testing.T) {
	h := NewMockMessagePipeHandle()
	checkStub := func() error {
		interfaceRequest := test.BoundsCheckTestInterface_Request{pipeOwner(h)}
		stub := test.NewBoundsCheckTestInterfaceStub(interfaceRequest, &boundsCheckStubImpl{}, waiter)
		err := stub.ServeRequest()
		stub.Close()
		return err
	}
	runTests(t, "boundscheck_", h, checkStub)

	checkProxy := func() error {
		interfacePointer := test.BoundsCheckTestInterface_Pointer{pipeOwner(h)}
		proxy := test.NewBoundsCheckTestInterfaceProxy(interfacePointer, waiter)
		_, err := proxy.Method0(0)
		proxy.Close_Proxy()
		h.reset()
		return err
	}
	runTests(t, "resp_boundscheck_", h, checkProxy)
}

func TestConformanceResponse(t *testing.T) {
	h := NewMockMessagePipeHandle()
	checkProxy := func() error {
		interfacePointer := test.ConformanceTestInterface_Pointer{pipeOwner(h)}
		proxy := test.NewConformanceTestInterfaceProxy(interfacePointer, waiter)
		_, err := proxy.Method12(0)
		proxy.Close_Proxy()
		h.reset()
		return err
	}
	runTests(t, "resp_conformance_", h, checkProxy)
}