package clients

import (
	"errors"
	"io"
	"io/ioutil"
	"net"
	"sync/atomic"
	"testing"
	"time"

	"github.com/mochi-co/mqtt/server/events"
	"github.com/mochi-co/mqtt/server/internal/circ"
	"github.com/mochi-co/mqtt/server/internal/packets"
	"github.com/mochi-co/mqtt/server/listeners/auth"
	"github.com/mochi-co/mqtt/server/system"
	"github.com/stretchr/testify/require"
)

var testClientStop = errors.New("test stop")

func genClient() *Client {
	c, _ := net.Pipe()
	return NewClient(c, circ.NewReader(128, 8), circ.NewWriter(128, 8), new(system.Info))
}

func TestNewClients(t *testing.T) {
	cl := New()
	require.NotNil(t, cl.internal)
}

func BenchmarkNewClients(b *testing.B) {
	for n := 0; n < b.N; n++ {
		New()
	}
}

func TestClientsAdd(t *testing.T) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	require.Contains(t, cl.internal, "t1")
}

func BenchmarkClientsAdd(b *testing.B) {
	cl := New()
	client := &Client{ID: "t1"}
	for n := 0; n < b.N; n++ {
		cl.Add(client)
	}
}

func TestClientsGet(t *testing.T) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	cl.Add(&Client{ID: "t2"})
	require.Contains(t, cl.internal, "t1")
	require.Contains(t, cl.internal, "t2")

	client, ok := cl.Get("t1")
	require.Equal(t, true, ok)
	require.Equal(t, "t1", client.ID)
}

func BenchmarkClientsGet(b *testing.B) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	for n := 0; n < b.N; n++ {
		cl.Get("t1")
	}
}

func TestClientsLen(t *testing.T) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	cl.Add(&Client{ID: "t2"})
	require.Contains(t, cl.internal, "t1")
	require.Contains(t, cl.internal, "t2")
	require.Equal(t, 2, cl.Len())
}

func BenchmarkClientsLen(b *testing.B) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	for n := 0; n < b.N; n++ {
		cl.Len()
	}
}

func TestClientsDelete(t *testing.T) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	require.Contains(t, cl.internal, "t1")

	cl.Delete("t1")
	_, ok := cl.Get("t1")
	require.Equal(t, false, ok)
	require.Nil(t, cl.internal["t1"])
}

func BenchmarkClientsDelete(b *testing.B) {
	cl := New()
	cl.Add(&Client{ID: "t1"})
	for n := 0; n < b.N; n++ {
		cl.Delete("t1")
	}
}

func TestClientsGetByListener(t *testing.T) {
	cl := New()
	cl.Add(&Client{ID: "t1", Listener: "tcp1"})
	cl.Add(&Client{ID: "t2", Listener: "ws1"})
	require.Contains(t, cl.internal, "t1")
	require.Contains(t, cl.internal, "t2")

	clients := cl.GetByListener("tcp1")
	require.NotEmpty(t, clients)
	require.Equal(t, 1, len(clients))
	require.Equal(t, "tcp1", clients[0].Listener)
}

func BenchmarkClientsGetByListener(b *testing.B) {
	cl := New()
	cl.Add(&Client{ID: "t1", Listener: "tcp1"})
	cl.Add(&Client{ID: "t2", Listener: "ws1"})
	for n := 0; n < b.N; n++ {
		cl.GetByListener("tcp1")
	}
}

func TestNewClient(t *testing.T) {
	cl := genClient()

	require.NotNil(t, cl)
	require.NotNil(t, cl.Inflight.internal)
	require.NotNil(t, cl.Subscriptions)
	require.NotNil(t, cl.R)
	require.NotNil(t, cl.W)
	require.Nil(t, cl.StopCause())
}

func TestClientInfoUnknown(t *testing.T) {
	cl := genClient()
	cl.ID = "testid"
	cl.Listener = "testlistener"
	cl.conn = nil

	require.Equal(t, events.Client{
		ID:       "testid",
		Remote:   "unknown",
		Listener: "testlistener",
	}, cl.Info())
}

func TestClientInfoKnown(t *testing.T) {
	c1, c2 := net.Pipe()
	defer c1.Close()
	defer c2.Close()

	cl := genClient()
	cl.ID = "ID"
	cl.Listener = "L"
	cl.conn = c1

	require.Equal(t, events.Client{
		ID:       "ID",
		Remote:   c1.RemoteAddr().String(),
		Listener: "L",
	}, cl.Info())
}

func BenchmarkNewClient(b *testing.B) {
	c, _ := net.Pipe()
	for n := 0; n < b.N; n++ {
		NewClient(c, circ.NewReader(16, 4), circ.NewWriter(16, 4), nil)
	}
}

func TestNewClientStub(t *testing.T) {
	cl := NewClientStub(nil)

	require.NotNil(t, cl)
	require.NotNil(t, cl.Inflight.internal)
	require.NotNil(t, cl.Subscriptions)
}

func BenchmarkNewClientStub(b *testing.B) {
	for n := 0; n < b.N; n++ {
		NewClientStub(nil)
	}
}

func TestClientIdentify(t *testing.T) {
	cl := genClient()

	pk := packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:      packets.Connect,
			Remaining: 16,
		},
		ProtocolName:     []byte{'M', 'Q', 'T', 'T'},
		ProtocolVersion:  4,
		CleanSession:     true,
		Keepalive:        60,
		ClientIdentifier: "mochi",
	}

	cl.Identify("tcp1", pk, new(auth.Allow))
	require.Equal(t, pk.Keepalive, cl.keepalive)
	require.Equal(t, pk.CleanSession, cl.CleanSession)
	require.Equal(t, pk.ClientIdentifier, cl.ID)
}

func BenchmarkClientIdentify(b *testing.B) {
	cl := genClient()

	pk := packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:      packets.Connect,
			Remaining: 16,
		},
		ProtocolName:     []byte{'M', 'Q', 'T', 'T'},
		ProtocolVersion:  4,
		CleanSession:     true,
		Keepalive:        60,
		ClientIdentifier: "mochi",
	}

	for n := 0; n < b.N; n++ {
		cl.Identify("tcp1", pk, new(auth.Allow))
	}
}

func TestClientIdentifyNoID(t *testing.T) {
	cl := genClient()

	pk := packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:      packets.Connect,
			Remaining: 16,
		},
		ProtocolName:    []byte{'M', 'Q', 'T', 'T'},
		ProtocolVersion: 4,
		CleanSession:    true,
		Keepalive:       60,
	}

	cl.Identify("tcp1", pk, new(auth.Allow))
	require.NotEmpty(t, cl.ID)
}

func TestClientIdentifyLWT(t *testing.T) {
	cl := genClient()

	pk := packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:      packets.Connect,
			Remaining: 16,
		},
		ProtocolName:     []byte{'M', 'Q', 'T', 'T'},
		ProtocolVersion:  4,
		CleanSession:     true,
		Keepalive:        60,
		ClientIdentifier: "mochi",
		WillFlag:         true,
		WillTopic:        "lwt",
		WillMessage:      []byte("lol gg"),
		WillQos:          1,
		WillRetain:       false,
	}

	cl.Identify("tcp1", pk, new(auth.Allow))
	require.Equal(t, pk.WillTopic, cl.LWT.Topic)
	require.Equal(t, pk.WillMessage, cl.LWT.Message)
	require.Equal(t, pk.WillQos, cl.LWT.Qos)
	require.Equal(t, pk.WillRetain, cl.LWT.Retain)
}

func TestClientNextPacketID(t *testing.T) {
	cl := genClient()

	require.Equal(t, uint32(1), cl.NextPacketID())
	require.Equal(t, uint32(2), cl.NextPacketID())

	cl.packetID = uint32(65534)
	require.Equal(t, uint32(65535), cl.NextPacketID())
	require.Equal(t, uint32(1), cl.NextPacketID())
}

func BenchmarkClientNextPacketID(b *testing.B) {
	cl := genClient()

	for n := 0; n < b.N; n++ {
		cl.NextPacketID()
	}
}

func TestClientNoteSubscription(t *testing.T) {
	cl := genClient()

	cl.NoteSubscription("a/b/c", 0)
	require.Contains(t, cl.Subscriptions, "a/b/c")
	require.Equal(t, byte(0), cl.Subscriptions["a/b/c"])
}

func BenchmarkClientNoteSubscription(b *testing.B) {
	cl := genClient()
	for n := 0; n < b.N; n++ {
		cl.NoteSubscription("a/b/c", 0)
	}
}

func TestClientForgetSubscription(t *testing.T) {
	cl := genClient()
	require.NotNil(t, cl)
	cl.Subscriptions = map[string]byte{
		"a/b/c/": 1,
	}
	cl.ForgetSubscription("a/b/c/")
	require.Empty(t, cl.Subscriptions["a/b/c"])
}

func BenchmarkClientForgetSubscription(b *testing.B) {
	cl := genClient()
	for n := 0; n < b.N; n++ {
		cl.NoteSubscription("a/b/c", 0)
		cl.ForgetSubscription("a/b/c/")
	}
}

func TestClientRefreshDeadline(t *testing.T) {
	cl := genClient()
	cl.refreshDeadline(10)

	// How do we check net.Conn deadline?
	require.NotNil(t, cl.conn)
}

func BenchmarkClientRefreshDeadline(b *testing.B) {
	cl := genClient()
	for n := 0; n < b.N; n++ {
		cl.refreshDeadline(10)
	}
}

func TestClientStart(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)
	time.Sleep(time.Millisecond)
	require.Equal(t, uint32(1), atomic.LoadUint32(&cl.R.State))
	require.Equal(t, uint32(2), atomic.LoadUint32(&cl.W.State))
}

func BenchmarkClientStart(b *testing.B) {
	cl := genClient()
	defer cl.Stop(testClientStop)

	for n := 0; n < b.N; n++ {
		cl.Start()
	}
}

func TestClientReadFixedHeader(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	cl.R.Set([]byte{packets.Connect << 4, 0x00}, 0, 2)
	cl.R.SetPos(0, 2)

	fh := new(packets.FixedHeader)
	err := cl.ReadFixedHeader(fh)
	require.NoError(t, err)
	require.Equal(t, int64(2), atomic.LoadInt64(&cl.systemInfo.BytesRecv))

	tail, head := cl.R.GetPos()
	require.Equal(t, int64(2), tail)
	require.Equal(t, int64(2), head)

}

func TestClientReadFixedHeaderDecodeError(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	o := make(chan error)
	go func() {
		fh := new(packets.FixedHeader)
		cl.R.Set([]byte{packets.Connect<<4 | 1<<1, 0x00, 0x00}, 0, 2)
		cl.R.SetPos(0, 2)
		o <- cl.ReadFixedHeader(fh)
	}()
	time.Sleep(time.Millisecond)
	require.Error(t, <-o)
}

func TestClientReadFixedHeaderReadEOF(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	o := make(chan error)
	go func() {
		fh := new(packets.FixedHeader)
		cl.R.Set([]byte{packets.Connect << 4, 0x00}, 0, 2)
		cl.R.SetPos(0, 1)
		o <- cl.ReadFixedHeader(fh)
	}()
	time.Sleep(time.Millisecond)
	cl.R.Stop()
	err := <-o
	require.Error(t, err)
	require.Equal(t, io.EOF, err)
}

func TestClientReadFixedHeaderNoLengthTerminator(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	o := make(chan error)
	go func() {
		fh := new(packets.FixedHeader)
		err := cl.R.Set([]byte{packets.Connect << 4, 0xd5, 0x86, 0xf9, 0x9e, 0x01}, 0, 5)
		require.NoError(t, err)
		cl.R.SetPos(0, 5)
		o <- cl.ReadFixedHeader(fh)
	}()
	time.Sleep(time.Millisecond)
	require.Error(t, <-o)
}

func TestClientReadOK(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	// Two packets in a row...
	b := []byte{
		byte(packets.Publish << 4), 18, // Fixed header
		0, 5, // Topic Name - LSB+MSB
		'a', '/', 'b', '/', 'c', // Topic Name
		'h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 'c', 'h', 'i', // Payload,
		byte(packets.Publish << 4), 11, // Fixed header
		0, 5, // Topic Name - LSB+MSB
		'd', '/', 'e', '/', 'f', // Topic Name
		'y', 'e', 'a', 'h', // Payload
	}

	err := cl.R.Set(b, 0, len(b))
	require.NoError(t, err)
	cl.R.SetPos(0, int64(len(b)))

	o := make(chan error)
	var pks []packets.Packet
	go func() {
		o <- cl.Read(func(cl *Client, pk packets.Packet) error {
			pks = append(pks, pk)
			return nil
		})
	}()

	time.Sleep(time.Millisecond)
	cl.R.Stop()

	err = <-o
	require.Error(t, err)
	require.Equal(t, io.EOF, err)
	require.Equal(t, 2, len(pks))
	require.Equal(t, pks, []packets.Packet{
		{
			FixedHeader: packets.FixedHeader{
				Type:      packets.Publish,
				Remaining: 18,
			},
			TopicName: "a/b/c",
			Payload:   []byte("hello mochi"),
		},
		{
			FixedHeader: packets.FixedHeader{
				Type:      packets.Publish,
				Remaining: 11,
			},
			TopicName: "d/e/f",
			Payload:   []byte("yeah"),
		},
	})

	require.Equal(t, int64(len(b)), atomic.LoadInt64(&cl.systemInfo.BytesRecv))
	require.Equal(t, int64(2), atomic.LoadInt64(&cl.systemInfo.MessagesRecv))

}

func TestClientClearBuffers(t *testing.T) {
	cl := genClient()
	cl.Start()
	cl.Stop(testClientStop)
	cl.ClearBuffers()

	require.Nil(t, cl.W)
	require.Nil(t, cl.R)
}

func TestClientReadDone(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)
	cl.State.Done = 1

	err := cl.Read(func(cl *Client, pk packets.Packet) error {
		return nil
	})

	require.NoError(t, err)
}

func TestClientReadPacketError(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	b := []byte{
		0, 18,
		0, 5,
		'a', '/', 'b', '/', 'c',
		'h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 'c', 'h', 'i',
	}
	err := cl.R.Set(b, 0, len(b))
	require.NoError(t, err)
	cl.R.SetPos(0, int64(len(b)))

	o := make(chan error)
	go func() {
		o <- cl.Read(func(cl *Client, pk packets.Packet) error {
			return nil
		})
	}()

	require.Error(t, <-o)
}

func TestClientReadPacketEOF(t *testing.T) {
	cl := genClient()
	cl.Start()

	b := []byte{
		0, 18,
		0, 5,
		'a', '/', 'b', '/', 'c',
		'h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 'c', 'h', // missing 1 byte
	}
	err := cl.R.Set(b, 0, len(b))
	require.NoError(t, err)
	cl.R.SetPos(0, int64(len(b)))

	o := make(chan error)
	go func() {
		o <- cl.Read(func(cl *Client, pk packets.Packet) error {
			return nil
		})
	}()

	cl.R.Stop()
	cl.Stop(testClientStop)
	require.Error(t, <-o)
	require.True(t, errors.Is(cl.StopCause(), testClientStop))
}

func TestClientReadHandlerErr(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	b := []byte{
		byte(packets.Publish << 4), 11, // Fixed header
		0, 5, // Topic Name - LSB+MSB
		'd', '/', 'e', '/', 'f', // Topic Name
		'y', 'e', 'a', 'h', // Payload
	}

	err := cl.R.Set(b, 0, len(b))
	require.NoError(t, err)
	cl.R.SetPos(0, int64(len(b)))

	err = cl.Read(func(cl *Client, pk packets.Packet) error {
		return errors.New("test")
	})

	require.Error(t, err)
}

func TestClientReadPacketOK(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	err := cl.R.Set([]byte{
		byte(packets.Publish << 4), 11, // Fixed header
		0, 5,
		'd', '/', 'e', '/', 'f',
		'y', 'e', 'a', 'h',
	}, 0, 13)
	require.NoError(t, err)
	cl.R.SetPos(0, 13)

	fh := new(packets.FixedHeader)
	err = cl.ReadFixedHeader(fh)
	require.NoError(t, err)

	pk, err := cl.ReadPacket(fh)
	require.NoError(t, err)
	require.NotNil(t, pk)

	require.Equal(t, packets.Packet{
		FixedHeader: packets.FixedHeader{
			Type:      packets.Publish,
			Remaining: 11,
		},
		TopicName: "d/e/f",
		Payload:   []byte("yeah"),
	}, pk)
}

func TestClientReadPacket(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	for i, tt := range pkTable {
		err := cl.R.Set(tt.bytes, 0, len(tt.bytes))
		require.NoError(t, err)
		cl.R.SetPos(0, int64(len(tt.bytes)))

		fh := new(packets.FixedHeader)
		err = cl.ReadFixedHeader(fh)
		require.NoError(t, err)

		pk, err := cl.ReadPacket(fh)
		require.NoError(t, err)
		require.NotNil(t, pk)

		require.Equal(t, tt.packet, pk, "Mismatched packet: [i:%d] %d", i, tt.bytes[0])
		if tt.packet.FixedHeader.Type == packets.Publish {
			require.Equal(t, int64(1), atomic.LoadInt64(&cl.systemInfo.PublishRecv))
		}
	}
}

func TestClientReadPacketReadingError(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)

	err := cl.R.Set([]byte{
		0, 11, // Fixed header
		0, 5,
		'd', '/', 'e', '/', 'f',
		'y', 'e', 'a', 'h',
	}, 0, 13)
	require.NoError(t, err)
	cl.R.SetPos(2, 13)

	_, err = cl.ReadPacket(&packets.FixedHeader{
		Type:      0,
		Remaining: 11,
	})
	require.Error(t, err)
}

func TestClientReadPacketReadError(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)
	cl.R.Stop()

	_, err := cl.ReadPacket(&packets.FixedHeader{
		Remaining: 1,
	})
	require.Error(t, err)
	require.Equal(t, io.EOF, err)
}

func TestClientReadPacketReadUnknown(t *testing.T) {
	cl := genClient()
	cl.Start()
	defer cl.Stop(testClientStop)
	cl.R.Stop()

	_, err := cl.ReadPacket(&packets.FixedHeader{
		Remaining: 1,
	})
	require.Error(t, err)
}

func TestClientWritePacket(t *testing.T) {
	for i, tt := range pkTable {
		r, w := net.Pipe()
		cl := NewClient(r, circ.NewReader(128, 8), circ.NewWriter(128, 8), new(system.Info))
		cl.Start()

		o := make(chan []byte)
		go func() {
			buf, err := ioutil.ReadAll(w)
			require.NoError(t, err)
			o <- buf
		}()

		n, err := cl.WritePacket(tt.packet)
		require.NoError(t, err, "Error [i:%d] %d", i, tt.packet)
		require.Equal(t, len(tt.bytes), n, "Mismatched written [i:%d] %d", i, tt.packet)

		time.Sleep(2 * time.Millisecond)
		r.Close()

		require.Equal(t, tt.bytes, <-o, "Mismatched packet: [i:%d] %d", i, tt.bytes[0])
		cl.Stop(testClientStop)

		// The stop cause is either the test error, EOF, or a
		// closed pipe, depending on which goroutine runs first.
		err = cl.StopCause()
		time.Sleep(time.Millisecond * 5)
		require.True(t,
			errors.Is(err, testClientStop) ||
				errors.Is(err, io.EOF) ||
				errors.Is(err, io.ErrClosedPipe))

		require.Equal(t, int64(n), atomic.LoadInt64(&cl.systemInfo.BytesSent))
		require.Equal(t, int64(1), atomic.LoadInt64(&cl.systemInfo.MessagesSent))
		if tt.packet.FixedHeader.Type == packets.Publish {
			require.Equal(t, int64(1), atomic.LoadInt64(&cl.systemInfo.PublishSent))
		}
	}
}

func TestClientWritePacketWriteNoConn(t *testing.T) {
	c, _ := net.Pipe()
	cl := NewClient(c, circ.NewReader(16, 4), circ.NewWriter(16, 4), new(system.Info))
	cl.W.SetPos(0, 16)
	cl.Stop(testClientStop)

	_, err := cl.WritePacket(pkTable[1].packet)
	require.Error(t, err)
	require.Equal(t, ErrConnectionClosed, err)
}

func TestClientWritePacketWriteError(t *testing.T) {
	c, _ := net.Pipe()
	cl := NewClient(c, circ.NewReader(16, 4), circ.NewWriter(16, 4), new(system.Info))
	cl.W.SetPos(0, 16)
	cl.W.Stop()

	_, err := cl.WritePacket(pkTable[1].packet)
	require.Error(t, err)
}

func TestClientWritePacketInvalidPacket(t *testing.T) {
	c, _ := net.Pipe()
	cl := NewClient(c, circ.NewReader(16, 4), circ.NewWriter(16, 4), new(system.Info))
	cl.Start()

	_, err := cl.WritePacket(packets.Packet{})
	require.Error(t, err)
}

/////

func TestInflightSet(t *testing.T) {
	cl := genClient()
	q := cl.Inflight.Set(1, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	require.Equal(t, true, q)
	require.NotNil(t, cl.Inflight.internal[1])
	require.NotEqual(t, 0, cl.Inflight.internal[1].Sent)

	q = cl.Inflight.Set(1, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	require.Equal(t, false, q)
}

func BenchmarkInflightSet(b *testing.B) {
	cl := genClient()
	in := InflightMessage{Packet: packets.Packet{}, Sent: 0}
	for n := 0; n < b.N; n++ {
		cl.Inflight.Set(1, in)
	}
}

func TestInflightGet(t *testing.T) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{Packet: packets.Packet{}, Sent: 0})

	msg, ok := cl.Inflight.Get(2)
	require.Equal(t, true, ok)
	require.NotEqual(t, 0, msg.Sent)
}

func BenchmarkInflightGet(b *testing.B) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	for n := 0; n < b.N; n++ {
		cl.Inflight.Get(2)
	}
}

func TestInflightGetAll(t *testing.T) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{})

	m := cl.Inflight.GetAll()
	o := map[uint16]InflightMessage{
		2: {},
	}
	require.Equal(t, o, m)
}

func BenchmarkInflightGetAll(b *testing.B) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	for n := 0; n < b.N; n++ {
		cl.Inflight.Get(2)
	}
}

func TestInflightLen(t *testing.T) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	require.Equal(t, 1, cl.Inflight.Len())
}

func BenchmarkInflightLen(b *testing.B) {
	cl := genClient()
	cl.Inflight.Set(2, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	for n := 0; n < b.N; n++ {
		cl.Inflight.Len()
	}
}

func TestInflightDelete(t *testing.T) {
	cl := genClient()
	cl.Inflight.Set(3, InflightMessage{Packet: packets.Packet{}, Sent: 0})
	require.NotNil(t, cl.Inflight.internal[3])

	q := cl.Inflight.Delete(3)
	require.Equal(t, true, q)
	require.Equal(t, int64(0), cl.Inflight.internal[3].Sent)

	_, ok := cl.Inflight.Get(3)
	require.Equal(t, false, ok)

	q = cl.Inflight.Delete(3)
	require.Equal(t, false, q)
}

func BenchmarkInflightDelete(b *testing.B) {
	cl := genClient()
	for n := 0; n < b.N; n++ {
		cl.Inflight.Set(4, InflightMessage{Packet: packets.Packet{}, Sent: 0})
		cl.Inflight.Delete(4)
	}
}

var (
	pkTable = []struct {
		bytes  []byte
		packet packets.Packet
	}{
		{
			bytes: []byte{
				byte(packets.Connect << 4), 16, // Fixed header
				0, 4, // Protocol Name - MSB+LSB
				'M', 'Q', 'T', 'T', // Protocol Name
				4,     // Protocol Version
				0,     // Packet Flags
				0, 60, // Keepalive
				0, 4, // Client ID - MSB+LSB
				'z', 'e', 'n', '3',
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Connect,
					Remaining: 16,
				},
				ProtocolName:     []byte("MQTT"),
				ProtocolVersion:  4,
				CleanSession:     false,
				Keepalive:        60,
				ClientIdentifier: "zen3",
			},
		},
		{
			bytes: []byte{
				byte(packets.Connack << 4), 2,
				0,
				packets.Accepted,
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Connack,
					Remaining: 2,
				},
				SessionPresent: false,
				ReturnCode:     packets.Accepted,
			},
		},
		{
			bytes: []byte{
				byte(packets.Publish << 4), 18,
				0, 5,
				'a', '/', 'b', '/', 'c',
				'h', 'e', 'l', 'l', 'o', ' ', 'm', 'o', 'c', 'h', 'i',
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Publish,
					Remaining: 18,
				},
				TopicName: "a/b/c",
				Payload:   []byte("hello mochi"),
			},
		},
		{
			bytes: []byte{
				byte(packets.Puback << 4), 2, // Fixed header
				0, 11, // Packet ID - LSB+MSB
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Puback,
					Remaining: 2,
				},
				PacketID: 11,
			},
		},
		{
			bytes: []byte{
				byte(packets.Pubrec << 4), 2, // Fixed header
				0, 12, // Packet ID - LSB+MSB
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Pubrec,
					Remaining: 2,
				},
				PacketID: 12,
			},
		},
		{
			bytes: []byte{
				byte(packets.Pubrel<<4) | 2, 2, // Fixed header
				0, 12, // Packet ID - LSB+MSB
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Pubrel,
					Remaining: 2,
					Qos:       1,
				},
				PacketID: 12,
			},
		},
		{
			bytes: []byte{
				byte(packets.Pubcomp << 4), 2, // Fixed header
				0, 14, // Packet ID - LSB+MSB
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Pubcomp,
					Remaining: 2,
				},
				PacketID: 14,
			},
		},
		{
			bytes: []byte{
				byte(packets.Subscribe << 4), 30, // Fixed header
				0, 15, // Packet ID - LSB+MSB

				0, 3, // Topic Name - LSB+MSB
				'a', '/', 'b', // Topic Name
				0, // QoS

				0, 11, // Topic Name - LSB+MSB
				'd', '/', 'e', '/', 'f', '/', 'g', '/', 'h', '/', 'i', // Topic Name
				1, // QoS

				0, 5, // Topic Name - LSB+MSB
				'x', '/', 'y', '/', 'z', // Topic Name
				2, // QoS
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Subscribe,
					Remaining: 30,
				},
				PacketID: 15,
				Topics: []string{
					"a/b",
					"d/e/f/g/h/i",
					"x/y/z",
				},
				Qoss: []byte{0, 1, 2},
			},
		},
		{
			bytes: []byte{
				byte(packets.Suback << 4), 6, // Fixed header
				0, 17, // Packet ID - LSB+MSB
				0,    // Return Code QoS 0
				1,    // Return Code QoS 1
				2,    // Return Code QoS 2
				0x80, // Return Code fail
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Suback,
					Remaining: 6,
				},
				PacketID:    17,
				ReturnCodes: []byte{0, 1, 2, 0x80},
			},
		},
		{
			bytes: []byte{
				byte(packets.Unsubscribe << 4), 27, // Fixed header
				0, 35, // Packet ID - LSB+MSB

				0, 3, // Topic Name - LSB+MSB
				'a', '/', 'b', // Topic Name

				0, 11, // Topic Name - LSB+MSB
				'd', '/', 'e', '/', 'f', '/', 'g', '/', 'h', '/', 'i', // Topic Name

				0, 5, // Topic Name - LSB+MSB
				'x', '/', 'y', '/', 'z', // Topic Name
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Unsubscribe,
					Remaining: 27,
				},
				PacketID: 35,
				Topics: []string{
					"a/b",
					"d/e/f/g/h/i",
					"x/y/z",
				},
			},
		},
		{
			bytes: []byte{
				byte(packets.Unsuback << 4), 2, // Fixed header
				0, 37, // Packet ID - LSB+MSB

			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Unsuback,
					Remaining: 2,
				},
				PacketID: 37,
			},
		},
		{
			bytes: []byte{
				byte(packets.Pingreq << 4), 0, // fixed header
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Pingreq,
					Remaining: 0,
				},
			},
		},
		{
			bytes: []byte{
				byte(packets.Pingresp << 4), 0, // fixed header
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Pingresp,
					Remaining: 0,
				},
			},
		},
		{
			bytes: []byte{
				byte(packets.Disconnect << 4), 0, // fixed header
			},
			packet: packets.Packet{
				FixedHeader: packets.FixedHeader{
					Type:      packets.Disconnect,
					Remaining: 0,
				},
			},
		},
	}
)