// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

//go:build !build_with_native_toolchain

package component_test

import (
	"context"
	"errors"
	"sync"
	"syscall/zx"
	"syscall/zx/fidl"
	"syscall/zx/zxwait"
	"testing"
	"time"

	"go.fuchsia.dev/fuchsia/src/lib/component"

	"fidl/bindingstest"
)

var _ bindingstest.Test1WithCtx = (*test1Impl)(nil)

type test1Impl struct{}

func (*test1Impl) Echo(_ fidl.Context, s *string) (*string, error) {
	return s, nil
}

func (*test1Impl) NoResponse(fidl.Context) error {
	return nil
}

func (*test1Impl) EmptyResponse(fidl.Context) error {
	return nil
}

func (*test1Impl) TooManyBytesInResponse(fidl.Context) ([]uint8, error) {
	return make([]uint8, zx.ChannelMaxMessageBytes+1), nil
}

func (*test1Impl) TooManyHandlesInResponse(fidl.Context) ([]zx.Handle, error) {
	out := make([]zx.Handle, zx.ChannelMaxMessageHandles+1)
	for i := range out {
		out[i] = 1 // to avoid zx.HandleInvalid(0).
	}
	return out, nil
}

func (*test1Impl) EchoHandleRights(_ fidl.Context, h zx.Port) (uint32, error) {
	infoHandleBasic, err := h.Handle().GetInfoHandleBasic()
	if err != nil {
		return 0, err
	}
	return uint32(infoHandleBasic.Rights), h.Close()
}

func TestEmptyWriteErrors(t *testing.T) {
	var wg sync.WaitGroup

	ch, sh, err := zx.NewChannel(0)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		if err := ch.Close(); err != nil {
			t.Error(err)
		}
		// Wait for the serving goroutine to exit, then confirm that Serve
		// closed the channel.
		wg.Wait()
		err := sh.Close()
		if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
			return
		}
		t.Errorf("got sh.Close() = %v, want %q", err, zx.ErrBadHandle)
	}()

	errChan := make(chan error, 1)

	wg.Add(1)
	go func() {
		defer wg.Done()
		component.Serve(context.Background(), &bindingstest.Test1WithCtxStub{
			Impl: &test1Impl{},
		}, sh, component.ServeOptions{
			OnError: func(err error) {
				errChan <- err
			},
		})
	}()

	if err := ch.Write(nil, nil, 0); err != nil {
		t.Fatal(err)
	}

	if _, err := zxwait.WaitContext(context.Background(), zx.Handle(ch), zx.SignalChannelPeerClosed); err != nil {
		t.Fatal(err)
	}

	close(errChan)
	for err := range errChan {
		if !errors.Is(err, fidl.ErrPayloadTooSmall) {
			t.Errorf("got Serve error = %v, want %q", err, fidl.ErrPayloadTooSmall)
		}
	}
}

func TestEcho(t *testing.T) {
	var wg sync.WaitGroup

	ch, sh, err := zx.NewChannel(0)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		// Expect the final test to have closed the client.
		func() {
			err := ch.Close()
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
				return
			}
			t.Errorf("got ch.Close() = %v, want %q", err, zx.ErrBadHandle)
		}()
		// Wait for the serving goroutine to exit, then confirm that Serve
		// closed the channel.
		wg.Wait()
		func() {
			err := sh.Close()
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
				return
			}
			t.Errorf("got sh.Close() = %v, want %q", err, zx.ErrBadHandle)
		}()
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		component.Serve(context.Background(), &bindingstest.Test1WithCtxStub{
			Impl: &test1Impl{},
		}, sh, component.ServeOptions{
			OnError: func(err error) {
				t.Error(err)
			},
		})
	}()

	client := bindingstest.Test1WithCtxInterface{Channel: ch}

	t.Run("Basic", func(t *testing.T) {
		str := "Hello World!"
		r, err := client.Echo(context.Background(), &str)
		if err != nil {
			t.Fatal(err)
		}
		if r == nil {
			t.Fatalf("got Echo(%q) = nil", str)
		}
		if *r != str {
			t.Fatalf("got Echo(%q) = %q", str, *r)
		}
	})

	t.Run("NoResponse", func(t *testing.T) {
		if err := client.NoResponse(context.Background()); err != nil {
			t.Fatal(err)
		}
	})

	t.Run("EmptyResponse", func(t *testing.T) {
		if err := client.EmptyResponse(context.Background()); err != nil {
			t.Fatal(err)
		}
	})

	t.Run("Event", func(t *testing.T) {
		const str = "Surprise!"
		pxy := bindingstest.Test1EventProxy{Channel: sh}
		if err := pxy.Surprise(str); err != nil {
			t.Fatal(err)
		}
		s, err := client.ExpectSurprise(context.Background())
		if err != nil {
			t.Fatal(err)
		}
		if s != str {
			t.Fatalf("got Event = %q, want %q", str, s)
		}
	})

	t.Run("ReducingHandleRights", func(t *testing.T) {
		const expectedRights = zx.RightTransfer | zx.RightDuplicate | zx.RightRead
		port, err := zx.NewPort(0)
		if err != nil {
			t.Fatal(err)
		}
		defer func() {
			err := port.Close()
			// Ownership should have moved to the server, and it should have closed
			// the handle.
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
				return
			}
			t.Errorf("got port.Close() = %v, want %q", err, zx.ErrBadHandle)
		}()
		handleInfo, err := port.Handle().GetInfoHandleBasic()
		if err != nil {
			t.Fatal(err)
		}
		if !handleInfo.Rights.StrictSupersetOf(expectedRights) {
			t.Fatalf("got !(%b).StrictSupersetOf(%b)", handleInfo.Rights, expectedRights)
		}
		rights, err := client.EchoHandleRights(context.Background(), port)
		if err != nil {
			t.Fatal(err)
		}
		if rights := zx.Rights(rights); rights != expectedRights {
			t.Fatalf("got EchoHandleRights(...) = %b, want %b", rights, expectedRights)
		}
	})

	t.Run("MissingExpectedRightsSendingSide", func(t *testing.T) {
		// This test tests the sending side when there are missing expected rights.
		// The receiving side is harder to test because there needs to be a
		// mismatch of rights on the sending and receiving side.
		port, err := zx.NewPort(0)
		if err != nil {
			t.Fatal(err)
		}
		defer func() {
			err := port.Close()
			// This handle should have been consumed by the replace below.
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
				return
			}
			t.Errorf("got port.Close() = %v, want %q", err, zx.ErrBadHandle)
		}()
		const reducedRights = zx.RightTransfer | zx.RightDuplicate
		h, err := port.Handle().Replace(reducedRights)
		if err != nil {
			t.Fatal(err)
		}
		defer func() {
			err := h.Close()
			// Ownership should have moved to the server, and it should have closed
			// the handle.
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
				return
			}
			t.Errorf("got h.Close() = %v, want %q", err, zx.ErrBadHandle)
		}()
		handleInfo, err := h.GetInfoHandleBasic()
		if err != nil {
			t.Fatal(err)
		}
		if handleInfo.Rights != reducedRights {
			t.Fatalf("got Rights = %b, want %b", handleInfo.Rights, reducedRights)
		}
		{
			_, err := client.EchoHandleRights(context.Background(), zx.Port(h))
			if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrInvalidArgs {
				return
			}
			t.Fatalf("got EchoHandleRights(reducedRights) = %v, want %q", err, zx.ErrInvalidArgs)
		}
	})
}

func TestRespondErrors(t *testing.T) {
	tests := []struct {
		name              string
		call              func(*bindingstest.Test1WithCtxInterface) error
		expectErr         zx.Status
		expectErrOnServer error
	}{
		{
			name: "TooManyBytes",
			call: func(client *bindingstest.Test1WithCtxInterface) error {
				_, err := client.TooManyBytesInResponse(context.Background())
				return err
			},
			expectErr:         zx.ErrPeerClosed,
			expectErrOnServer: component.ErrTooManyBytesInResponse,
		},
		{
			name: "TooManyHandles",
			call: func(client *bindingstest.Test1WithCtxInterface) error {
				_, err := client.TooManyHandlesInResponse(context.Background())
				return err
			},
			expectErr:         zx.ErrPeerClosed,
			expectErrOnServer: component.ErrTooManyHandlesInResponse,
		},
	}

	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {
			var wg sync.WaitGroup
			defer wg.Wait()

			ch, sh, err := zx.NewChannel(0)
			if err != nil {
				t.Fatal(err)
			}

			errChan := make(chan error, 1)
			wg.Add(1)
			go func() {
				defer wg.Done()
				component.Serve(context.Background(), &bindingstest.Test1WithCtxStub{
					Impl: &test1Impl{},
				}, sh, component.ServeOptions{
					OnError: func(err error) {
						errChan <- err
					},
				})
			}()

			err = test.call(&bindingstest.Test1WithCtxInterface{Channel: ch})
			if err, ok := err.(*zx.Error); !ok || err.Status != test.expectErr {
				t.Errorf("got err = %q", err)
			}

			select {
			case err := <-errChan:
				if !errors.Is(err, test.expectErrOnServer) {
					t.Errorf("got err = %s, want %q", err, test.expectErrOnServer)
				}
			default:
				t.Error("got no error on server")
			}
		})
	}
}

func TestServe_MagicNumberCheck(t *testing.T) {
	var wg sync.WaitGroup

	ch, sh, err := zx.NewChannel(0)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		if err := ch.Close(); err != nil {
			t.Error(err)
		}
		// Wait for the serving goroutine to exit, then confirm that Serve
		// closed the channel.
		wg.Wait()
		err := sh.Close()
		if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
			return
		}
		t.Errorf("got sh.Close() = %v, want %q", err, zx.ErrBadHandle)
	}()

	errChan := make(chan error, 1)

	wg.Add(1)
	go func() {
		defer wg.Done()
		component.Serve(context.Background(), &bindingstest.Test1WithCtxStub{
			Impl: &test1Impl{},
		}, sh, component.ServeOptions{
			OnError: func(err error) {
				errChan <- err
			},
		})
	}()

	// Send an event with an unknown magic number. The method ordinal and message
	// body can also be invalid but magic numbers are checked first.
	request := []byte{
		0, 0, 0, 0, // txid
		0, 0, 0, // flags
		0,                      // magic number
		0, 0, 0, 0, 0, 0, 0, 1, // method ordinal
		0, 0, 0, 0, 0, 0, 0, 0, // empty struct data
	}

	if err := ch.Write(request, nil, 0); err != nil {
		t.Fatal(err)
	}

	if _, err := zxwait.WaitContext(context.Background(), zx.Handle(ch), zx.SignalChannelPeerClosed); err != nil {
		t.Fatal(err)
	}

	close(errChan)
	for err := range errChan {
		if !errors.Is(err, fidl.ErrUnknownMagic) {
			t.Errorf("got Serve error = %v, want %q", err, fidl.ErrUnknownMagic)
		}
	}
}

var _ bindingstest.Test1WithCtx = (*hangingImpl)(nil)

type hangingImpl struct {
	test1Impl

	// Used to coordinate blocking.
	sem chan struct{}
}

func (impl *hangingImpl) NoResponse(ctx fidl.Context) error {
	defer func() {
		<-impl.sem
	}()

	for {
		select {
		case <-impl.sem:
		case <-ctx.Done():
			return ctx.Err()
		}
	}
}

func TestServeConcurrent(t *testing.T) {
	ch, sh, err := zx.NewChannel(0)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		if err := ch.Close(); err != nil {
			t.Error(err)
		}
	}()

	impl := hangingImpl{
		sem: make(chan struct{}),
	}
	defer close(impl.sem)

	errChan := make(chan error, 1)

	done := make(chan struct{})
	go func() {
		defer close(done)
		component.Serve(context.Background(), &bindingstest.Test1WithCtxStub{
			Impl: &impl,
		}, sh, component.ServeOptions{
			Concurrent: true,
			OnError: func(err error) {
				errChan <- err
			},
		})
	}()

	client := bindingstest.Test1WithCtxInterface{Channel: ch}
	if err := client.NoResponse(context.Background()); err != nil {
		t.Fatal(err)
	}

	// Ensure the handler is blocked.
	impl.sem <- struct{}{}

	// Closing the channel cancels the handler's context.
	if err := ch.Close(); err != nil {
		t.Fatal(err)
	}

	// Handler should now be blocked on deferred channel read.
	select {
	case <-done:
		t.Error("serving returned while handler running")
	case <-time.After(100 * time.Millisecond):
	}

	impl.sem <- struct{}{}
	<-done

	// Serving should have closed the channel.
	func() {
		err := sh.Close()
		if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
			return
		}
		t.Errorf("got sh.Close() = %v, want %q", err, zx.ErrBadHandle)
	}()

	close(errChan)
	for err := range errChan {
		if err != nil {
			t.Errorf("Serve(...) = %s", err)
		}
	}
}

func TestKeepChannelAlive(t *testing.T) {
	tests := []struct {
		name      string
		keepAlive bool
	}{
		{
			name:      "keep alive",
			keepAlive: true,
		},
		{
			name:      "close",
			keepAlive: false,
		},
	}
	for _, testCase := range tests {
		t.Run(testCase.name, func(t *testing.T) {
			client, server, err := zx.NewChannel(0)
			if err != nil {
				t.Fatal(err)
			}
			defer func() {
				if err := client.Close(); err != nil {
					t.Errorf("client.Close() = %s", err)
				}
			}()

			ctx, cancel := context.WithCancel(context.Background())
			cancel()
			component.Serve(ctx, &bindingstest.Test1WithCtxStub{
				Impl: &test1Impl{},
			}, server, component.ServeOptions{
				KeepChannelAlive: testCase.keepAlive,
				OnError: func(err error) {
					t.Error(err)
				},
			})

			err = server.Close()
			if testCase.keepAlive {
				if err != nil {
					t.Fatalf("server.Close() = %s", err)
				}
			} else {
				var zxErr *zx.Error
				if !errors.As(err, &zxErr) {
					t.Fatalf("expected %s to be %T", err, zxErr)
				}
				if got, want := zxErr.Status, zx.ErrBadHandle; got != want {
					t.Fatalf("zxErr.status = %s, want %s", got, want)
				}
			}
		})
	}
}

func TestCloseWithEpitaph(t *testing.T) {
	client, server, err := zx.NewChannel(0)
	if err != nil {
		t.Fatal(err)
	}
	defer func() {
		err := client.Close()
		if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrBadHandle {
			return
		}
		t.Errorf("got client.Close() = %v, want %s", err, zx.ErrBadHandle)
	}()

	status := zx.ErrInvalidArgs
	if err := component.CloseWithEpitaph(server, status); err != nil {
		t.Fatal(err)
	}

	proxy := bindingstest.Test1WithCtxInterface{Channel: client}

	switch err := proxy.NoResponse(context.Background()).(type) {
	case *zx.Error:
		if err.Status != status {
			t.Fatalf("got proxy.NoResponse() = %s, want %s", err.Status, status)
		}
	default:
		t.Fatalf("got proxy.NoResponse() = %v, want %s", err, status)
	}
}