package papo_test

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"log/slog"
	"reflect"
	"strings"
	"testing"

	"euandre.org/papo/src"
)


func errorIf(t *testing.T, err error) {
	if err != nil {
		t.Errorf("Unexpected error: %#v\n", err)
	}
}

func assertEqual(t *testing.T, given any, expected any) {
	if !reflect.DeepEqual(given, expected) {
		t.Errorf("given != expected")
		t.Errorf("given:    %#v\n", given)
		t.Errorf("expected: %#v\n", expected)
	}
}

func TestSplitOnCRLF(t *testing.T) {
	inputs := []string {
		"",
		"\r\n",
		"abc\r\n",
		"abc\r\n ",
		"abc\r\n \r\n",
		" \r\n \r\n",
		"aaa\r\nbbb\r\nccc\r\n",
		"\r\nsplit \r \n CRLF\r\n\r\n",
	}
	expected := [][]string {
		nil,
		{ "" },
		{ "abc" },
		{ "abc" },
		{ "abc", " " },
		{ " ", " " },
		{ "aaa", "bbb", "ccc" },
		{ "", "split \r \n CRLF", "" },
	}
	given := make([][]string, len(inputs))

	for i, input := range inputs {
		scanner := bufio.NewScanner(strings.NewReader(input))
		scanner.Split(papo.SplitOnCRLF)
		for scanner.Scan() {
			given[i] = append(given[i], scanner.Text())
		}

		err := scanner.Err()
		errorIf(t, err)
	}

	assertEqual(t, given, expected)
}

func TestSplitOnRawMessage(t *testing.T) {
	inputs := []string {
		"first message\r\nsecond message\r\n",
		"message 1\r\n\r\nmessage 2\r\n\r\nignored",
	}
	expected := [][]string {
		{ "first message", "second message" },
		{ "message 1", "message 2" },
	}
	given := make([][]string, len(inputs))

	for i, input := range inputs {
		scanner := bufio.NewScanner(strings.NewReader(input))
		scanner.Split(papo.SplitOnRawMessage)
		for scanner.Scan() {
			given[i] = append(given[i], scanner.Text())
		}

		err := scanner.Err()
		errorIf(t, err)
	}

	assertEqual(t, given, expected)
}

func TestParseMessageParams(t *testing.T) {
	inputs := []string {
		"",
		" ",
		" :",
		" : ",
		": ",
		":   ",
		" :  ",
		"  :",
		"   :",
		"a",
		"ab",
		"a b",
		"a b c",
		"a b:c",
		"a b:c:",
		"a b :c",
		"a b :c:",
		"a b :c ",
		"a b : c",
		"a b : c ",
		"a b : c :",
		"a b : c : ",
		"a b : c :d",
		"a b : c :d ",
		"a b : c : d ",
	}
	expected := []papo.MessageParams {
		papo.MessageParams {
			Middle: []string { },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: " ",
		},
		papo.MessageParams {
			Middle: []string { ":" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { ":" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: "  ",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "ab" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a", "b", "c" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a", "b:c" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a", "b:c:" },
			Trailing: "",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: "c",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: "c:",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: "c ",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c ",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c :",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c : ",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c :d",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c :d ",
		},
		papo.MessageParams {
			Middle: []string { "a", "b" },
			Trailing: " c : d ",
		},
	}
	given := make([]papo.MessageParams, len(inputs))

	for i, input := range inputs {
		given[i] = papo.ParseMessageParams(input)
	}

	assertEqual(t, given, expected)
}

func TestParseMessage(t *testing.T) {
	inputs := []string {
		"NICK joebloe ",
		"USER joebloe 0.0.0.0 joe :Joe Bloe",
		":pre USER joebloe 0.0.0.0 joe :Joe Bloe",
		":pre  USER   joebloe    0.0.0.0      joe      : Joe Bloe ",
		":pre  USER   joebloe:   0:0:0:0      joe::a:  : Joe Bloe ",
		":pre  USER   :Joe Bloe",
		":pre  USER   : Joe Bloe",
		":pre  USER   :     Joe Bloe",
		":pre  USER   :         ",
		":pre  USER   :",
	}
	expected := []papo.Message {
		papo.Message {
			Prefix:  "",
			Command: "NICK",
			Params:  papo.MessageParams {
				Middle: []string { "joebloe" },
				Trailing: "",
			},
			Raw:     "NICK joebloe ",
		},
		papo.Message {
			Prefix:  "",
			Command: "USER",
			Params:  papo.MessageParams {
				Middle: []string {
					"joebloe", "0.0.0.0", "joe",
				},
				Trailing: "Joe Bloe",
			},
			Raw:     "USER joebloe 0.0.0.0 joe :Joe Bloe",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params:  papo.MessageParams {
				Middle: []string {
					"joebloe", "0.0.0.0", "joe",
				},
				Trailing: "Joe Bloe",
			},
			Raw:     ":pre USER joebloe 0.0.0.0 joe :Joe Bloe",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params:  papo.MessageParams {
				Middle: []string {
					"joebloe", "0.0.0.0", "joe",
				},
				Trailing: " Joe Bloe ",
			},
			Raw:     ":pre  USER   joebloe    0.0.0.0      joe      : Joe Bloe ",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params:  papo.MessageParams {
				Middle: []string {
					"joebloe:", "0:0:0:0", "joe::a:",
				},
				Trailing: " Joe Bloe ",
			},
			Raw:     ":pre  USER   joebloe:   0:0:0:0      joe::a:  : Joe Bloe ",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params: papo.MessageParams {
				Middle: []string { },
				Trailing: "Joe Bloe",
			},
			Raw:     ":pre  USER   :Joe Bloe",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params: papo.MessageParams {
				Middle: []string { },
				Trailing: " Joe Bloe",
			},
			Raw:     ":pre  USER   : Joe Bloe",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params: papo.MessageParams {
				Middle: []string { },
				Trailing: "     Joe Bloe",
			},
			Raw:     ":pre  USER   :     Joe Bloe",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params: papo.MessageParams {
				Middle: []string { },
				Trailing: "         ",
			},
			Raw:     ":pre  USER   :         ",
		},
		papo.Message {
			Prefix:  "pre",
			Command: "USER",
			Params: papo.MessageParams {
				Middle: []string { },
				Trailing: "",
			},
			Raw:     ":pre  USER   :",
		},
	}
	given := make([]papo.Message, len(inputs))

	for i, input := range inputs {
		parsed, err := papo.ParseMessage(input)
		errorIf(t, err)
		given[i] = parsed
	}

	assertEqual(t, given, expected)
}

func TestSetLoggerOutput(t *testing.T) {
	return
	type entry struct {
		msg  string `json:"msg"`
		aKey string `json:"a-key"`
	}
	var e entry
	var buf bytes.Buffer
	papo.SetLoggerOutput(&buf)
	slog.Error("the message", "a-key", "a-value")

	s := buf.String()
	// fmt.Println(s)
	// fmt.Println(e)
	err := json.Unmarshal([]byte(s), &e)
	if err != nil {
		t.Fail()
	}
	if e.msg != "the message" {
		t.Fail()
	}
	fmt.Println(1)
	// fmt.Println(e)
}