package client_test

import (
	"bufio"
	"net"
	"testing"

	"git.lang-dieter.de/rs2322tcp/internal/client"
	"git.lang-dieter.de/rs2322tcp/internal/transport"
)

func TestClientOpenDataConnection(t *testing.T) {
	dataListener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("data listener failed: %v", err)
	}
	defer dataListener.Close()

	dataPort := dataListener.Addr().(*net.TCPAddr).Port

	controlListener, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatalf("control listener failed: %v", err)
	}
	defer controlListener.Close()

	serverDone := make(chan error, 1)

	go func() {
		conn, err := controlListener.Accept()
		if err != nil {
			serverDone <- err
			return
		}
		defer conn.Close()

		reader := bufio.NewReader(conn)

		var hello transport.HelloMessage

		if err := transport.ReadMessage(reader, &hello); err != nil {
			serverDone <- err
			return
		}

		if hello.Type != transport.MessageHello {
			serverDone <- &testError{
				message: "unexpected hello message type",
			}
			return
		}

		if err := transport.WriteMessage(
			conn,
			transport.NewHelloResponse(),
		); err != nil {
			serverDone <- err
			return
		}

		serverDone <- nil
	}()

	clientConn, err := client.New(controlListener.Addr().String())
	if err != nil {
		t.Fatalf("client.New() failed: %v", err)
	}
	defer clientConn.Close()

	device := transport.RemoteDeviceInfo{
		ID:       "radio",
		Name:     "Funkgerät",
		DataPort: dataPort,
	}

	dataConn, err := clientConn.OpenDataConnection(device)
	if err != nil {
		t.Fatalf("OpenDataConnection() failed: %v", err)
	}
	defer dataConn.Close()

	serverDataConn, err := dataListener.Accept()
	if err != nil {
		t.Fatalf("data listener Accept() failed: %v", err)
	}
	defer serverDataConn.Close()

	if err := <-serverDone; err != nil {
		t.Fatalf("control server failed: %v", err)
	}

	// Verify that the data connection is actually usable.
	message := []byte("test")

	if _, err := dataConn.Write(message); err != nil {
		t.Fatalf("data connection Write() failed: %v", err)
	}

	buffer := make([]byte, len(message))

	if _, err := serverDataConn.Read(buffer); err != nil {
		t.Fatalf("data connection Read() failed: %v", err)
	}

	if string(buffer) != string(message) {
		t.Fatalf(
			"received %q, want %q",
			string(buffer),
			string(message),
		)
	}
}

type testError struct {
	message string
}

func (e *testError) Error() string {
	return e.message
}