// Copyright 2015 The Vanadium 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 main

import (
	"bytes"
	"fmt"
	"strings"
	"testing"

	"v.io/v23"
	"v.io/v23/context"
	"v.io/v23/rpc"
	"v.io/x/lib/cmdline"
	"v.io/x/lib/vlog"
	"v.io/x/ref/cmd/vrpc/internal"
	"v.io/x/ref/lib/v23cmd"
	_ "v.io/x/ref/runtime/factories/generic"
	"v.io/x/ref/test"
)

type server struct{}

//go:generate v23 test generate

// TypeTester interface implementation

func (*server) EchoBool(_ *context.T, _ rpc.ServerCall, i1 bool) (bool, error) {
	vlog.VI(2).Info("EchoBool(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoFloat32(_ *context.T, _ rpc.ServerCall, i1 float32) (float32, error) {
	vlog.VI(2).Info("EchoFloat32(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoFloat64(_ *context.T, _ rpc.ServerCall, i1 float64) (float64, error) {
	vlog.VI(2).Info("EchoFloat64(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoInt32(_ *context.T, _ rpc.ServerCall, i1 int32) (int32, error) {
	vlog.VI(2).Info("EchoInt32(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoInt64(_ *context.T, _ rpc.ServerCall, i1 int64) (int64, error) {
	vlog.VI(2).Info("EchoInt64(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoString(_ *context.T, _ rpc.ServerCall, i1 string) (string, error) {
	vlog.VI(2).Info("EchoString(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoByte(_ *context.T, _ rpc.ServerCall, i1 byte) (byte, error) {
	vlog.VI(2).Info("EchoByte(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoUint32(_ *context.T, _ rpc.ServerCall, i1 uint32) (uint32, error) {
	vlog.VI(2).Info("EchoUint32(%v) was called.", i1)
	return i1, nil
}

func (*server) EchoUint64(_ *context.T, _ rpc.ServerCall, i1 uint64) (uint64, error) {
	vlog.VI(2).Info("EchoUint64(%v) was called.", i1)
	return i1, nil
}

func (*server) XEchoArray(_ *context.T, _ rpc.ServerCall, i1 internal.Array2Int) (internal.Array2Int, error) {
	vlog.VI(2).Info("XEchoArray(%v) was called.", i1)
	return i1, nil
}

func (*server) XEchoMap(_ *context.T, _ rpc.ServerCall, i1 map[int32]string) (map[int32]string, error) {
	vlog.VI(2).Info("XEchoMap(%v) was called.", i1)
	return i1, nil
}

func (*server) XEchoSet(_ *context.T, _ rpc.ServerCall, i1 map[int32]struct{}) (map[int32]struct{}, error) {
	vlog.VI(2).Info("XEchoSet(%v) was called.", i1)
	return i1, nil
}

func (*server) XEchoSlice(_ *context.T, _ rpc.ServerCall, i1 []int32) ([]int32, error) {
	vlog.VI(2).Info("XEchoSlice(%v) was called.", i1)
	return i1, nil
}

func (*server) XEchoStruct(_ *context.T, _ rpc.ServerCall, i1 internal.Struct) (internal.Struct, error) {
	vlog.VI(2).Info("XEchoStruct(%v) was called.", i1)
	return i1, nil
}

func (*server) YMultiArg(_ *context.T, _ rpc.ServerCall, i1, i2 int32) (int32, int32, error) {
	vlog.VI(2).Info("YMultiArg(%v,%v) was called.", i1, i2)
	return i1, i2, nil
}

func (*server) YNoArgs(_ *context.T, _ rpc.ServerCall) error {
	vlog.VI(2).Info("YNoArgs() was called.")
	return nil
}

func (*server) ZStream(_ *context.T, call internal.TypeTesterZStreamServerCall, nStream int32, item bool) error {
	vlog.VI(2).Info("ZStream(%v,%v) was called.", nStream, item)
	sender := call.SendStream()
	for i := int32(0); i < nStream; i++ {
		sender.Send(item)
	}
	return nil
}

func initTest(t *testing.T) (ctx *context.T, name string, shutdown v23.Shutdown) {
	ctx, shutdown = test.V23Init()

	rpcServer, err := v23.NewServer(ctx)
	if err != nil {
		t.Fatalf("NewServer failed: %v", err)
		return
	}
	endpoints, err := rpcServer.Listen(v23.GetListenSpec(ctx))
	if err != nil {
		t.Fatalf("Listen failed: %v", err)
		return
	}
	name = endpoints[0].Name()
	obj := internal.TypeTesterServer(&server{})
	if err := rpcServer.Serve("", obj, nil); err != nil {
		t.Fatalf("Serve failed: %v", err)
		return
	}
	return
}

func testSignature(t *testing.T, showReserved bool, wantSig string) {
	ctx, name, shutdown := initTest(t)
	defer shutdown()
	var stdout, stderr bytes.Buffer
	env := &cmdline.Env{Stdout: &stdout, Stderr: &stderr}
	args := []string{"signature", fmt.Sprintf("-show-reserved=%v", showReserved), name}
	if err := v23cmd.ParseAndRunForTest(cmdVRPC, ctx, env, args); err != nil {
		t.Fatalf("%s: %v", args, err)
	}

	if got, want := stdout.String(), wantSig; got != want {
		t.Errorf("%s: got stdout %s, want %s", args, got, want)
	}
	if got, want := stderr.String(), ""; got != want {
		t.Errorf("%s: got stderr %s, want %s", args, got, want)
	}
}

func TestSignatureWithReserved(t *testing.T) {
	wantSig := `// TypeTester methods are listed in alphabetical order, to make it easier to
// test Signature output, which sorts methods alphabetically.
type "v.io/x/ref/cmd/vrpc/internal".TypeTester interface {
	// Methods to test support for primitive types.
	EchoBool(I1 bool) (O1 bool | error)
	EchoByte(I1 byte) (O1 byte | error)
	EchoFloat32(I1 float32) (O1 float32 | error)
	EchoFloat64(I1 float64) (O1 float64 | error)
	EchoInt32(I1 int32) (O1 int32 | error)
	EchoInt64(I1 int64) (O1 int64 | error)
	EchoString(I1 string) (O1 string | error)
	EchoUint32(I1 uint32) (O1 uint32 | error)
	EchoUint64(I1 uint64) (O1 uint64 | error)
	// Methods to test support for composite types.
	XEchoArray(I1 "v.io/x/ref/cmd/vrpc/internal".Array2Int) (O1 "v.io/x/ref/cmd/vrpc/internal".Array2Int | error)
	XEchoMap(I1 map[int32]string) (O1 map[int32]string | error)
	XEchoSet(I1 set[int32]) (O1 set[int32] | error)
	XEchoSlice(I1 []int32) (O1 []int32 | error)
	XEchoStruct(I1 "v.io/x/ref/cmd/vrpc/internal".Struct) (O1 "v.io/x/ref/cmd/vrpc/internal".Struct | error)
	// Methods to test support for different number of arguments.
	YMultiArg(I1 int32, I2 int32) (O1 int32, O2 int32 | error)
	YNoArgs() error
	// Methods to test support for streaming.
	ZStream(NumStreamItems int32, StreamItem bool) stream<_, bool> error
}

// Reserved methods implemented by the RPC framework.  Each method name is prefixed with a double underscore "__".
type __Reserved interface {
	// Glob returns all entries matching the pattern.
	__Glob(pattern string) stream<any, any> error
	// MethodSignature returns the signature for the given method.
	__MethodSignature(method string) ("signature".Method | error)
	// Signature returns all interface signatures implemented by the object.
	__Signature() ([]"signature".Interface | error)
}

type "signature".Arg struct {
	Name string
	Doc string
	Type typeobject
}

type "signature".Embed struct {
	Name string
	PkgPath string
	Doc string
}

type "signature".Interface struct {
	Name string
	PkgPath string
	Doc string
	Embeds []"signature".Embed
	Methods []"signature".Method
}

type "signature".Method struct {
	Name string
	Doc string
	InArgs []"signature".Arg
	OutArgs []"signature".Arg
	InStream ?"signature".Arg
	OutStream ?"signature".Arg
	Tags []any
}

type "v.io/x/ref/cmd/vrpc/internal".Array2Int [2]int32

type "v.io/x/ref/cmd/vrpc/internal".Struct struct {
	X int32
	Y int32
}
`
	testSignature(t, true, wantSig)
}

func TestSignatureNoReserved(t *testing.T) {
	wantSig := `// TypeTester methods are listed in alphabetical order, to make it easier to
// test Signature output, which sorts methods alphabetically.
type "v.io/x/ref/cmd/vrpc/internal".TypeTester interface {
	// Methods to test support for primitive types.
	EchoBool(I1 bool) (O1 bool | error)
	EchoByte(I1 byte) (O1 byte | error)
	EchoFloat32(I1 float32) (O1 float32 | error)
	EchoFloat64(I1 float64) (O1 float64 | error)
	EchoInt32(I1 int32) (O1 int32 | error)
	EchoInt64(I1 int64) (O1 int64 | error)
	EchoString(I1 string) (O1 string | error)
	EchoUint32(I1 uint32) (O1 uint32 | error)
	EchoUint64(I1 uint64) (O1 uint64 | error)
	// Methods to test support for composite types.
	XEchoArray(I1 "v.io/x/ref/cmd/vrpc/internal".Array2Int) (O1 "v.io/x/ref/cmd/vrpc/internal".Array2Int | error)
	XEchoMap(I1 map[int32]string) (O1 map[int32]string | error)
	XEchoSet(I1 set[int32]) (O1 set[int32] | error)
	XEchoSlice(I1 []int32) (O1 []int32 | error)
	XEchoStruct(I1 "v.io/x/ref/cmd/vrpc/internal".Struct) (O1 "v.io/x/ref/cmd/vrpc/internal".Struct | error)
	// Methods to test support for different number of arguments.
	YMultiArg(I1 int32, I2 int32) (O1 int32, O2 int32 | error)
	YNoArgs() error
	// Methods to test support for streaming.
	ZStream(NumStreamItems int32, StreamItem bool) stream<_, bool> error
}

type "v.io/x/ref/cmd/vrpc/internal".Array2Int [2]int32

type "v.io/x/ref/cmd/vrpc/internal".Struct struct {
	X int32
	Y int32
}
`
	testSignature(t, false, wantSig)
}

func TestMethodSignature(t *testing.T) {
	ctx, name, shutdown := initTest(t)
	defer shutdown()

	tests := []struct {
		Method, Want string
	}{
		// Spot-check some individual methods.
		{"EchoByte", `EchoByte(I1 byte) (O1 byte | error)`},
		{"EchoFloat32", `EchoFloat32(I1 float32) (O1 float32 | error)`},
		{"XEchoStruct", `
XEchoStruct(I1 "v.io/x/ref/cmd/vrpc/internal".Struct) (O1 "v.io/x/ref/cmd/vrpc/internal".Struct | error)

type "v.io/x/ref/cmd/vrpc/internal".Struct struct {
	X int32
	Y int32
}
`},
	}
	for _, test := range tests {
		var stdout, stderr bytes.Buffer
		env := &cmdline.Env{Stdout: &stdout, Stderr: &stderr}
		if err := v23cmd.ParseAndRunForTest(cmdVRPC, ctx, env, []string{"signature", name, test.Method}); err != nil {
			t.Errorf("%q failed: %v", test.Method, err)
			continue
		}
		if got, want := strings.TrimSpace(stdout.String()), strings.TrimSpace(test.Want); got != want {
			t.Errorf("got stdout %q, want %q", got, want)
		}
		if got, want := stderr.String(), ""; got != want {
			t.Errorf("got stderr %q, want %q", got, want)
		}
	}
}

func TestCall(t *testing.T) {
	ctx, name, shutdown := initTest(t)
	defer shutdown()

	tests := []struct {
		Method, InArgs, Want string
	}{
		{"EchoBool", `true`, `true`},
		{"EchoBool", `false`, `false`},
		{"EchoFloat32", `1.2`, `float32(1.2)`},
		{"EchoFloat64", `-3.4`, `float64(-3.4)`},
		{"EchoInt32", `11`, `int32(11)`},
		{"EchoInt64", `-22`, `int64(-22)`},
		{"EchoString", `"abc"`, `"abc"`},
		{"EchoByte", `33`, `byte(33)`},
		{"EchoUint32", `44`, `uint32(44)`},
		{"EchoUint64", `55`, `uint64(55)`},
		{"XEchoArray", `{1,2}`, `"v.io/x/ref/cmd/vrpc/internal".Array2Int{1, 2}`},
		{"XEchoMap", `{1:"a"}`, `map[int32]string{1: "a"}`},
		{"XEchoSet", `{1}`, `set[int32]{1}`},
		{"XEchoSlice", `{1,2}`, `[]int32{1, 2}`},
		{"XEchoStruct", `{1,2}`, `"v.io/x/ref/cmd/vrpc/internal".Struct{X: 1, Y: 2}`},
		{"YMultiArg", `1,2`, `int32(1) int32(2)`},
		{"YNoArgs", ``, ``},
		{"ZStream", `2,true`, `<< true
<< true`},
	}
	for _, test := range tests {
		var stdout, stderr bytes.Buffer
		env := &cmdline.Env{Stdout: &stdout, Stderr: &stderr}
		if err := v23cmd.ParseAndRunForTest(cmdVRPC, ctx, env, []string{"call", name, test.Method, test.InArgs}); err != nil {
			t.Errorf("%q(%s) failed: %v", test.Method, test.InArgs, err)
			continue
		}
		if got, want := strings.TrimSpace(stdout.String()), strings.TrimSpace(test.Want); got != want {
			t.Errorf("got stdout %q, want %q", got, want)
		}
		if got, want := stderr.String(), ""; got != want {
			t.Errorf("got stderr %q, want %q", got, want)
		}
	}
}