package transport_test

import (
	"bufio"
	"bytes"
	"io"
	"strings"
	"testing"

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

func TestWriteAndReadMessage(t *testing.T) {
	original := transport.NewHello()

	var buffer bytes.Buffer

	if err := transport.WriteMessage(&buffer, original); err != nil {
		t.Fatalf("WriteMessage() failed: %v", err)
	}

	reader := bufio.NewReader(&buffer)

	var decoded transport.HelloMessage

	if err := transport.ReadMessage(reader, &decoded); err != nil {
		t.Fatalf("ReadMessage() failed: %v", err)
	}

	if decoded.Version != original.Version {
		t.Errorf("Version = %d, want %d",
			decoded.Version, original.Version)
	}

	if decoded.Type != original.Type {
		t.Errorf("Type = %q, want %q",
			decoded.Type, original.Type)
	}
}

func TestMultipleMessages(t *testing.T) {
	var buffer bytes.Buffer

	if err := transport.WriteMessage(&buffer, transport.NewHello()); err != nil {
		t.Fatalf("WriteMessage(hello) failed: %v", err)
	}

	if err := transport.WriteMessage(&buffer, transport.NewGetDevices()); err != nil {
		t.Fatalf("WriteMessage(get_devices) failed: %v", err)
	}

	reader := bufio.NewReader(&buffer)

	var hello transport.HelloMessage

	if err := transport.ReadMessage(reader, &hello); err != nil {
		t.Fatalf("ReadMessage(hello) failed: %v", err)
	}

	if hello.Type != transport.MessageHello {
		t.Errorf("first Type = %q, want %q",
			hello.Type, transport.MessageHello)
	}

	var getDevices transport.GetDevicesMessage

	if err := transport.ReadMessage(reader, &getDevices); err != nil {
		t.Fatalf("ReadMessage(get_devices) failed: %v", err)
	}

	if getDevices.Type != transport.MessageGetDevices {
		t.Errorf("second Type = %q, want %q",
			getDevices.Type, transport.MessageGetDevices)
	}
}

func TestMessageFraming(t *testing.T) {
	var buffer bytes.Buffer

	if err := transport.WriteMessage(&buffer, transport.NewHello()); err != nil {
		t.Fatalf("WriteMessage() failed: %v", err)
	}

	text := buffer.String()

	if !strings.HasSuffix(text, "\n") {
		t.Fatalf("message does not end with newline: %q", text)
	}

	if strings.Count(text, "\n") != 1 {
		t.Fatalf("newline count = %d, want 1",
			strings.Count(text, "\n"))
	}
}

func TestReadMessageEOF(t *testing.T) {
	reader := bufio.NewReader(strings.NewReader(""))

	var message transport.HelloMessage

	err := transport.ReadMessage(reader, &message)

	if err != io.EOF {
		t.Fatalf("ReadMessage() error = %v, want io.EOF", err)
	}
}

func TestReadMessageInvalidJSON(t *testing.T) {
	reader := bufio.NewReader(
		strings.NewReader(`{"version":1,"type":invalid}` + "\n"),
	)

	var message transport.HelloMessage

	if err := transport.ReadMessage(reader, &message); err == nil {
		t.Fatal("ReadMessage() succeeded, want JSON error")
	}
}

func TestReadMessageIncomplete(t *testing.T) {
	reader := bufio.NewReader(
		strings.NewReader(`{"version":1,"type":"hello"}`),
	)

	var message transport.HelloMessage

	err := transport.ReadMessage(reader, &message)

	if err == nil {
		t.Fatal("ReadMessage() succeeded, want incomplete message error")
	}
}

func TestNilWriter(t *testing.T) {
	if err := transport.WriteMessage(nil, transport.NewHello()); err == nil {
		t.Fatal("WriteMessage() succeeded, want error")
	}
}

func TestNilMessage(t *testing.T) {
	var buffer bytes.Buffer

	if err := transport.WriteMessage(&buffer, nil); err == nil {
		t.Fatal("WriteMessage() succeeded, want error")
	}
}

func TestNilReader(t *testing.T) {
	var message transport.HelloMessage

	if err := transport.ReadMessage(nil, &message); err == nil {
		t.Fatal("ReadMessage() succeeded, want error")
	}
}

func TestNilTarget(t *testing.T) {
	reader := bufio.NewReader(strings.NewReader(
		`{"version":1,"type":"hello"}` + "\n",
	))

	if err := transport.ReadMessage(reader, nil); err == nil {
		t.Fatal("ReadMessage() succeeded, want error")
	}
}