package client

import (
	"fmt"
	"reflect"
	"testing"
)

func TestNew(t *testing.T) {
	tests := []struct {
		host       string
		port       int
		shouldWork bool
	}{
		{"localhost", 27960, true},
		{"something.invalid", 27960, false},
		{"locahost", 0, false},
		{"locahost", 99999, false},
	}

	for _, tt := range tests {
		testname := fmt.Sprintf("%s:%d->%t", tt.host, tt.port, tt.shouldWork)
		t.Run(testname, func(t *testing.T) {
			_, err := New(tt.host, tt.port)
			success := err == nil
			if tt.shouldWork && !success || !tt.shouldWork && success {
				t.Errorf(
					"Expected success=%t / was %t (err=%v)",
					tt.shouldWork, success,
					err,
				)
			}
		})
	}
}

func TestClose(t *testing.T) {
	c := mustNew(t)
	if err := c.Close(); err != nil {
		t.Errorf("Error while closing client: %v", err)
	}
}

func TestParseAsMap(t *testing.T) {
	res := parseAsMap(
		[]byte(
			"\xff\xff\xff\xff" + `infoResponse
\modversion\4.3.4\game\q3ut4\auth\1\pure\1\gametype\0\sv_maxclients\10\bots\0\clients\0\mapname\ut4_casa\hostname\test\protocol\68`,
		),
	)
	exp := map[string]string{
		"modversion":    "4.3.4",
		"game":          "q3ut4",
		"auth":          "1",
		"pure":          "1",
		"gametype":      "0",
		"sv_maxclients": "10",
		"bots":          "0",
		"clients":       "0",
		"mapname":       "ut4_casa",
		"hostname":      "test",
		"protocol":      "68",
	}
	if !reflect.DeepEqual(exp, res) {
		t.Errorf(
			"Result mismatch: expected %v, was %v",
			exp, res,
		)
	}
}

func TestParsePlayers(t *testing.T) {
	res, err := parsePlayers(
		[]byte(
			"\xff\xff\xff\xff" + `statusResponse
\g_gametype\0\timelimit\20`,
		),
	)
	if err != nil {
		t.Errorf("Failed to parse players: %v", err)
	}

	exp := []Player{}

	if !reflect.DeepEqual(exp, res) {
		t.Errorf(
			"Result mismatch: expected %v, was %v",
			exp, res,
		)
	}

	tests := []struct {
		name     string
		dataStr  string
		expected []Player
	}{
		{
			name: "nobody",
			dataStr: "\xff\xff\xff\xff" + `statusResponse
\g_gametype\0\timelimit\20`,
			expected: []Player{},
		},
		{
			name: "oneplayer",
			dataStr: "\xff\xff\xff\xff" + `statusResponse
\g_gametype\0\timelimit\20
-1 5 "The!_oneandonly"`,
			expected: []Player{
				{
					Name:  "The!_oneandonly",
					Score: -1,
					Ping:  5,
				},
			},
		},
		{
			name: "twoplayers",
			dataStr: "\xff\xff\xff\xff" + `statusResponse
\g_gametype\0\timelimit\20
0 0 "fooplayer"
3 0 "barplayer"`,
			expected: []Player{
				{
					Name:  "fooplayer",
					Score: 0,
					Ping:  0,
				},
				{
					Name:  "barplayer",
					Score: 3,
					Ping:  0,
				},
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			res, err := parsePlayers([]byte(tt.dataStr))
			if err != nil {
				t.Errorf("Failed to parse players: %v", err)
			}
			if !reflect.DeepEqual(tt.expected, res) {
				t.Errorf(
					"Result mismatch: expected %v, was %v",
					tt.expected, res,
				)
			}
		})
	}
}

func mustNew(t *testing.T) *Q3Client {
	c, err := New("localhost", 27960)
	if err != nil {
		t.Errorf("Failed to create client: %v", err)
	}
	return c
}