package udp

import (
	"net"
	"testing"
	"time"

	"src.dualinventive.com/go/lib/dilog"

	"github.com/stretchr/testify/assert"
)

func TestNewListener_withNilLogger_returnsErr(t *testing.T) {
	rec := newRecorder()

	l, err := NewListener(nil, ":8080", DefaultUDPBufferSize, 2, rec.handle)
	assert.Nil(t, l)
	assert.NotNil(t, err)
	assert.EqualError(t, err, "logger must not be nil")
}

func TestNewListener_withNilHandler_returnsErr(t *testing.T) {
	log := dilog.NewNilLogger()

	l, err := NewListener(log, ":8080", DefaultUDPBufferSize, 2, nil)
	assert.Nil(t, l)
	assert.NotNil(t, err)
	assert.EqualError(t, err, "handler must not be nil")
}

func TestNewListener_withEmptyAddr_startOnRandomPort(t *testing.T) {
	log := dilog.NewTestLogger(t)
	rec := newRecorder()

	l, err := NewListener(log, "", DefaultUDPBufferSize, 2, rec.handle)

	assert.NotNil(t, l)
	assert.Nil(t, err)
	assert.NotNil(t, l.pc)
}

func TestNewListener_withZeroBufferSize_setsDefaultBufferSize(t *testing.T) {
	log := dilog.NewTestLogger(t)
	rec := newRecorder()

	l, err := NewListener(log, ":8080", 0, 2, rec.handle)

	assert.NotNil(t, l)
	assert.Nil(t, err)
	assert.Equal(t, len(l.buffer), DefaultUDPBufferSize)
	assert.NotNil(t, l.pc)
}

func TestListenAndServe_routesPacketsToHandler(t *testing.T) {
	log := dilog.NewTestLogger(t)
	rec := newRecorder()

	l, err := NewListener(log, "", 1064, 2, rec.handle)
	assert.Nil(t, err)

	go func() {
		err = l.ListenAndServe()
	}()

	done := make(chan bool, 1)
	go func() {
		select {
		case <-rec.recvChan:
			assert.NotEmpty(t, rec.recv)
			assert.Len(t, rec.recv, 1)
			assert.Equal(t, []byte("test"), rec.recv[0])
			done <- true
		case <-time.Tick(time.Second * 5):
			assert.Fail(t, "timeout")
			done <- true
		}
	}()

	writeUDP(t, l.LocalAddr(), "test")
	<-done
}

type recorder struct {
	recv     [][]byte
	recvChan chan bool
}

func (r *recorder) handle(b []byte) {
	r.recv = append(r.recv, b)
	r.recvChan <- true
}

func newRecorder() *recorder {
	recvChan := make(chan bool, 1)
	return &recorder{recv: [][]byte{}, recvChan: recvChan}
}

func writeUDP(t *testing.T, addr string, payload string) {
	conn, err := net.Dial("udp", addr)
	assert.Nil(t, err)
	_, err = conn.Write([]byte(payload))
	assert.Nil(t, err)
}