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

package sshutil

import (
	"bytes"
	"context"
	"errors"
	"io"
	"net"
	"strconv"
	"sync/atomic"
	"testing"

	"golang.org/x/crypto/ssh"

	"go.fuchsia.dev/fuchsia/tools/lib/retry"
)

func setUpClient(
	ctx context.Context,
	t *testing.T,
	onNewChannel func(ssh.NewChannel),
	onRequest func(ssh.Channel, *ssh.Request),
) (*Client, *sshServer) {
	server, err := startSSHServer(ctx, onNewChannel, onRequest)
	if err != nil {
		t.Fatalf("failed to start ssh server: %s", err)
	}
	t.Cleanup(func() {
		if err := server.stop(); err != nil {
			t.Error(err)
		}
	})

	client, err := NewClient(
		ctx,
		ConstantAddrResolver{
			Addr: server.listener.Addr(),
		},
		server.clientConfig,
		retry.NoRetries())
	if err != nil {
		t.Fatalf("failed to create client: %s", err)
	}
	t.Cleanup(client.Close)

	return client, server
}

func TestReconnect(t *testing.T) {
	ctx := context.Background()

	t.Run("can run a command before and after reconnection", func(t *testing.T) {
		var execCount int64
		client, _ := setUpClient(
			ctx,
			t,
			nil,
			onExecRequest(func(cmd string, stdout io.Writer, stderr io.Writer) int {
				expected := strconv.Itoa(int(atomic.AddInt64(&execCount, 1)))
				if expected != cmd {
					t.Fatalf("expected exec cmd to be %q, not %q", expected, cmd)
				}
				stdout.Write([]byte(expected))
				stderr.Write([]byte(expected))
				return 0
			}),
		)

		// Check we can run a command before reconnecting.
		var stdout bytes.Buffer
		var stderr bytes.Buffer
		if err := client.Run(ctx, []string{"1"}, &stdout, &stderr); err != nil {
			t.Errorf("failed to run a command: %s", err)
		}
		if execCount != 1 {
			t.Errorf("expected exec count to be 1, not %d", execCount)
		}
		if stdout.String() != "1" {
			t.Errorf("expected stdout to be \"1\", not %q", stdout.String())
		}
		if stderr.String() != "1" {
			t.Errorf("expected stderr to be \"1\", not %q", stdout.String())
		}

		client.Close()

		<-client.DisconnectionListener()

		if err := client.Reconnect(ctx); err != nil {
			t.Errorf("failed to reconnect: %s", err)
		}

		// Check we can still run a command after reconnecting.
		stdout.Reset()
		stderr.Reset()
		if err := client.Run(ctx, []string{"2"}, &stdout, &stderr); err != nil {
			t.Errorf("failed to run a command: %s", err)
		}
		if execCount != 2 {
			t.Errorf("expected exec count to be 2, not %d", execCount)
		}
		if stdout.String() != "2" {
			t.Errorf("expected stdout to be \"2\", not %q", stdout.String())
		}
		if stderr.String() != "2" {
			t.Errorf("expected stderr to be \"2\", not %q", stdout.String())
		}
	})
}

func TestCloseDuringConnection(t *testing.T) {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	serverConfig, clientConfig, err := genSSHConfig()
	if err != nil {
		t.Fatalf("failed to create ssh config: %s", err)
	}

	connected := make(chan struct{})
	reconnected := make(chan struct{})
	done := make(chan struct{})
	defer close(done)

	// Spawn a server goroutine that will accept a connection, but never read
	// or write to the socket.
	listener, err := net.Listen("tcp", ":0")
	if err != nil {
		t.Fatalf("failed to listen on port: %s", err)
	}
	defer func() {
		if err := listener.Close(); err != nil {
			t.Error(err)
		}
	}()

	serverErrs := make(chan error)
	go func() {
		// `NewClient` blocks until the first connection is made, so
		// we'll accept then close the connection.
		tcpConn, err := listener.Accept()
		if err != nil {
			serverErrs <- err
			return
		}

		sshConn, incomingChannels, _, err := ssh.NewServerConn(tcpConn, serverConfig)
		if err != nil {
			serverErrs <- err
			return
		}

		// Accept the keepalive channel.
		newChannel := <-incomingChannels
		if _, _, err := newChannel.Accept(); err != nil {
			serverErrs <- err
			return
		}

		<-connected

		if err := sshConn.Close(); err != nil && !errors.Is(err, net.ErrClosed) {
			t.Error(err)
		}

		// Accept the reconnection attempt, but never respond to it.
		tcpConn, err = listener.Accept()
		if err != nil {
			serverErrs <- err
			return
		}

		close(reconnected)

		// Wait for the test to complete before closing the
		// connection. Otherwise we'll race with the OS
		// observing the closed connection with the context to
		// be canceled.
		<-done

		if err := tcpConn.Close(); err != nil {
			t.Error(err)
		}
	}()

	// Spawn a goroutine to establish the initial client.
	type clientResult struct {
		client *Client
		err    error
	}
	clientChan := make(chan clientResult)

	go func() {
		client, err := NewClient(
			ctx,
			ConstantAddrResolver{
				Addr: listener.Addr(),
			},
			clientConfig,
			retry.NoRetries(),
		)
		clientChan <- clientResult{
			client: client,
			err:    err,
		}
	}()

	// Wait for the connection to succeed.
	var client *Client
	select {
	case err := <-serverErrs:
		t.Fatalf("server failed to accept connection: %s", err)
	case res := <-clientChan:
		if res.err != nil {
			t.Fatalf("client failed to connect: %s", err)
		}

		client = res.client
	}

	// Signal to the server that we connected so it can switch to waiting
	// for the reconnection attempt.
	close(connected)

	reconnectCtx, reconnectCancel := context.WithCancel(ctx)
	reconnectErrs := make(chan error)

	// Spawn a reconnection attempt. This should never succeed
	go func() {
		reconnectErrs <- client.Reconnect(reconnectCtx)
	}()

	select {
	case err := <-serverErrs:
		t.Fatalf("server failed to accept reconnection: %s", err)
	case err := <-reconnectErrs:
		t.Fatalf("client failed to reconnect: %s", err)
	case <-reconnected:
	}

	// Close the connection, which should not block.
	clientClosed := make(chan struct{})
	go func() {
		client.Close()
		close(clientClosed)
	}()

	// The close goroutine should succeed.
	<-clientClosed

	// The reconnection goroutine won't error out until the context is canceled.
	reconnectCancel()

	select {
	case err := <-reconnectErrs:
		if !errors.Is(err, context.Canceled) {
			t.Fatalf("client reconnection should have been canceled, not %v", err)
		}
	}
}