package fin_test

import (
	"bytes"
	"reflect"
	"strings"
	"testing"

	fin "git.sharkk.net/Sharkk/Fin"
)

func TestBasicWrite(t *testing.T) {
	// Create test data
	data := fin.NewData()
	data.GetData()["boolTrue"] = true
	data.GetData()["boolFalse"] = false
	data.GetData()["integer"] = 42
	data.GetData()["negativeInt"] = -10
	data.GetData()["floatValue"] = 3.14
	data.GetData()["negativeFloat"] = -2.5
	data.GetData()["stringValue"] = "hello world"

	// Write to buffer
	buf := new(bytes.Buffer)
	err := data.Write(buf)
	if err != nil {
		t.Fatalf("unexpected error writing data: %v", err)
	}

	// Read back
	readData, err := fin.Load(bytes.NewReader(buf.Bytes()))
	if err != nil {
		t.Fatalf("unexpected error loading written data: %v", err)
	}

	// Verify values
	testCases := []struct {
		key      string
		expected any
		getter   func(string) (any, error)
	}{
		{"boolTrue", true, func(k string) (any, error) { return readData.GetBool(k) }},
		{"boolFalse", false, func(k string) (any, error) { return readData.GetBool(k) }},
		{"integer", 42, func(k string) (any, error) { return readData.GetInt(k) }},
		{"negativeInt", -10, func(k string) (any, error) { return readData.GetInt(k) }},
		{"floatValue", 3.14, func(k string) (any, error) { return readData.GetFloat(k) }},
		{"negativeFloat", -2.5, func(k string) (any, error) { return readData.GetFloat(k) }},
		{"stringValue", "hello world", func(k string) (any, error) { return readData.GetString(k) }},
	}

	for _, tc := range testCases {
		got, err := tc.getter(tc.key)
		if err != nil {
			t.Errorf("error getting %s: %v", tc.key, err)
		} else if got != tc.expected {
			t.Errorf("expected %s=%v, got %v", tc.key, tc.expected, got)
		}
	}
}

func TestArrayWrite(t *testing.T) {
	// Create test data with arrays
	data := fin.NewData()
	data.GetData()["fruits"] = []any{"apple", "banana", "cherry"}
	data.GetData()["mixed"] = []any{"string", 42, true, 3.14}

	// Write to buffer
	buf := new(bytes.Buffer)
	err := data.Write(buf)
	if err != nil {
		t.Fatalf("unexpected error writing data: %v", err)
	}

	// Read back
	readData, err := fin.Load(bytes.NewReader(buf.Bytes()))
	if err != nil {
		t.Fatalf("unexpected error loading written data: %v", err)
	}

	// Verify arrays
	fruits, err := readData.GetArray("fruits")
	if err != nil {
		t.Fatalf("failed to get fruits array: %v", err)
	}
	expectedFruits := []any{"apple", "banana", "cherry"}
	if !reflect.DeepEqual(fruits, expectedFruits) {
		t.Errorf("expected fruits=%v, got %v", expectedFruits, fruits)
	}

	// Verify mixed array
	mixed, err := readData.GetArray("mixed")
	if err != nil {
		t.Fatalf("failed to get mixed array: %v", err)
	}
	if len(mixed) != 4 {
		t.Errorf("expected 4 items in mixed array, got %d", len(mixed))
	}

	// Check types in mixed array
	stringVal, err := readData.GetString("mixed.0")
	if err != nil || stringVal != "string" {
		t.Errorf("expected mixed.0=\"string\", got %v, err: %v", stringVal, err)
	}
	intVal, err := readData.GetInt("mixed.1")
	if err != nil || intVal != 42 {
		t.Errorf("expected mixed.1=42, got %v, err: %v", intVal, err)
	}
	boolVal, err := readData.GetBool("mixed.2")
	if err != nil || boolVal != true {
		t.Errorf("expected mixed.2=true, got %v, err: %v", boolVal, err)
	}
	floatVal, err := readData.GetFloat("mixed.3")
	if err != nil || floatVal != 3.14 {
		t.Errorf("expected mixed.3=3.14, got %v, err: %v", floatVal, err)
	}
}

func TestMapWrite(t *testing.T) {
	// Create nested map structure
	data := fin.NewData()

	serverMap := map[string]any{
		"host": "localhost",
		"port": 8080,
	}
	data.GetData()["server"] = serverMap

	loggingMap := map[string]any{
		"level": "info",
		"file":  "app.log",
	}
	settingsMap := map[string]any{
		"theme":         "dark",
		"notifications": true,
		"logging":       loggingMap,
	}
	appMap := map[string]any{
		"name":     "MyApp",
		"version":  "1.0.0",
		"settings": settingsMap,
	}
	data.GetData()["application"] = appMap

	// Write to buffer
	buf := new(bytes.Buffer)
	err := data.Write(buf)
	if err != nil {
		t.Fatalf("unexpected error writing data: %v", err)
	}

	// Read back
	readData, err := fin.Load(bytes.NewReader(buf.Bytes()))
	if err != nil {
		t.Fatalf("unexpected error loading written data: %v", err)
	}

	// Verify simple map
	host, err := readData.GetString("server.host")
	if err != nil || host != "localhost" {
		t.Errorf("expected server.host=\"localhost\", got %v, err: %v", host, err)
	}
	port, err := readData.GetInt("server.port")
	if err != nil || port != 8080 {
		t.Errorf("expected server.port=8080, got %v, err: %v", port, err)
	}

	// Verify deeply nested maps
	appName, err := readData.GetString("application.name")
	if err != nil || appName != "MyApp" {
		t.Errorf("expected application.name=\"MyApp\", got %v, err: %v", appName, err)
	}
	theme, err := readData.GetString("application.settings.theme")
	if err != nil || theme != "dark" {
		t.Errorf("expected application.settings.theme=\"dark\", got %v, err: %v", theme, err)
	}
	logLevel, err := readData.GetString("application.settings.logging.level")
	if err != nil || logLevel != "info" {
		t.Errorf("expected application.settings.logging.level=\"info\", got %v, err: %v", logLevel, err)
	}
}

func TestSpecialCasesWrite(t *testing.T) {
	// Test combined value+object case
	data := fin.NewData()

	combinedMap := map[string]any{
		"value":    8080,
		"protocol": "http",
		"secure":   false,
	}
	data.GetData()["port"] = combinedMap

	// Write to buffer
	buf := new(bytes.Buffer)
	err := data.Write(buf)
	if err != nil {
		t.Fatalf("unexpected error writing data: %v", err)
	}

	// Read back
	readData, err := fin.Load(bytes.NewReader(buf.Bytes()))
	if err != nil {
		t.Fatalf("unexpected error loading written data: %v", err)
	}

	// Verify combined value+object
	portVal, err := readData.GetInt("port.value")
	if err != nil || portVal != 8080 {
		t.Errorf("expected port.value=8080, got %v, err: %v", portVal, err)
	}
	protocol, err := readData.GetString("port.protocol")
	if err != nil || protocol != "http" {
		t.Errorf("expected port.protocol=\"http\", got %v, err: %v", protocol, err)
	}
}

func TestStringEscapingWrite(t *testing.T) {
	data := fin.NewData()

	// Add strings with special characters
	data.GetData()["quoted"] = "Text with \"quotes\""
	data.GetData()["backslash"] = "Path with \\backslash"
	data.GetData()["newlines"] = "Text with\nnew lines"
	data.GetData()["tabs"] = "Text with\ttabs"

	// Write to buffer
	buf := new(bytes.Buffer)
	err := data.Write(buf)
	if err != nil {
		t.Fatalf("unexpected error writing data: %v", err)
	}

	// Read back
	readData, err := fin.Load(bytes.NewReader(buf.Bytes()))
	if err != nil {
		t.Fatalf("unexpected error loading written data: %v", err)
	}

	// Verify escaped strings
	quoted, err := readData.GetString("quoted")
	if err != nil || quoted != "Text with \"quotes\"" {
		t.Errorf("expected correct handling of quotes, got %v, err: %v", quoted, err)
	}
	backslash, err := readData.GetString("backslash")
	if err != nil || backslash != "Path with \\backslash" {
		t.Errorf("expected correct handling of backslashes, got %v, err: %v", backslash, err)
	}
	newlines, err := readData.GetString("newlines")
	if err != nil || newlines != "Text with\nnew lines" {
		t.Errorf("expected correct handling of newlines, got %v, err: %v", newlines, err)
	}
	tabs, err := readData.GetString("tabs")
	if err != nil || tabs != "Text with\ttabs" {
		t.Errorf("expected correct handling of tabs, got %v, err: %v", tabs, err)
	}
}

func TestSaveFunction(t *testing.T) {
	// Test the standalone Save function
	data := fin.NewData()
	data.GetData()["key"] = "value"

	buf := new(bytes.Buffer)
	err := fin.Save(buf, data)
	if err != nil {
		t.Fatalf("unexpected error using Save function: %v", err)
	}

	// Verify content was written
	if !strings.Contains(buf.String(), "key \"value\"") {
		t.Errorf("expected Save function to write data, got: %s", buf.String())
	}
}