package client

import (
	"testing"

	"forge.redroom.link/yves/meowlib"
	"github.com/stretchr/testify/assert"
)

// Helper function to create a test server list with sample servers
func createTestServerList(t *testing.T) *ServerList {
	sl := &ServerList{
		Name:    "TestServerList",
		Servers: []*Server{},
	}

	// Create servers with different public keys
	for i := 0; i < 5; i++ {
		srv, err := CreateServerFromUrl("https://server" + string(rune('0'+i)) + ".example.com/meow")
		if err != nil {
			t.Fatalf("Failed to create server: %v", err)
		}

		// Generate unique public keys for testing
		kp, err := meowlib.NewKeyPair()
		if err != nil {
			t.Fatalf("Failed to create keypair: %v", err)
		}
		srv.PublicKey = kp.Public
		srv.Name = "Server" + string(rune('0'+i))

		sl.Servers = append(sl.Servers, srv)
	}

	return sl
}

func TestServerList_FilterByIdxs(t *testing.T) {
	sl := createTestServerList(t)

	t.Run("Filter with valid indices", func(t *testing.T) {
		indices := []int{0, 2, 4}
		filtered, err := sl.FilterByIdxs(indices)

		assert.NoError(t, err, "FilterByIdxs should not return error for valid indices")
		assert.NotNil(t, filtered, "Filtered list should not be nil")
		assert.Equal(t, 3, len(filtered.Servers), "Should have 3 servers after filtering")

		// Verify the filtered servers are correct
		assert.Equal(t, sl.Servers[0], filtered.Servers[0])
		assert.Equal(t, sl.Servers[2], filtered.Servers[1])
		assert.Equal(t, sl.Servers[4], filtered.Servers[2])
	})

	t.Run("Filter with single index", func(t *testing.T) {
		indices := []int{1}
		filtered, err := sl.FilterByIdxs(indices)

		assert.NoError(t, err, "FilterByIdxs should not return error for valid single index")
		assert.NotNil(t, filtered, "Filtered list should not be nil")
		assert.Equal(t, 1, len(filtered.Servers), "Should have 1 server after filtering")
		assert.Equal(t, sl.Servers[1], filtered.Servers[0])
	})

	t.Run("Filter with empty indices", func(t *testing.T) {
		indices := []int{}
		filtered, err := sl.FilterByIdxs(indices)

		assert.NoError(t, err, "FilterByIdxs should not return error for empty indices")
		assert.NotNil(t, filtered, "Filtered list should not be nil")
		assert.Equal(t, 0, len(filtered.Servers), "Should have 0 servers after filtering with empty indices")
	})

	t.Run("Filter with out of range index", func(t *testing.T) {
		indices := []int{0, 10}
		filtered, err := sl.FilterByIdxs(indices)

		assert.Error(t, err, "FilterByIdxs should return error for out of range index")
		assert.Nil(t, filtered, "Filtered list should be nil on error")
		assert.Contains(t, err.Error(), "out of range", "Error message should mention out of range")
	})

	t.Run("Filter with negative index", func(t *testing.T) {
		indices := []int{-1}
		filtered, err := sl.FilterByIdxs(indices)

		assert.Error(t, err, "FilterByIdxs should return error for negative index")
		assert.Nil(t, filtered, "Filtered list should be nil on error")
	})

	t.Run("Filter with duplicate indices", func(t *testing.T) {
		indices := []int{1, 1, 2}
		filtered, err := sl.FilterByIdxs(indices)

		assert.NoError(t, err, "FilterByIdxs should not return error for duplicate indices")
		assert.NotNil(t, filtered, "Filtered list should not be nil")
		// Note: duplicates will result in duplicate servers in the list
		assert.Equal(t, 3, len(filtered.Servers), "Should have 3 servers (including duplicate)")
	})
}

func TestServerList_FilterByIdxs_EmptyList(t *testing.T) {
	sl := &ServerList{
		Name:    "EmptyList",
		Servers: []*Server{},
	}

	t.Run("Filter empty list with indices", func(t *testing.T) {
		indices := []int{0}
		filtered, err := sl.FilterByIdxs(indices)

		assert.Error(t, err, "FilterByIdxs should return error when trying to filter empty list")
		assert.Nil(t, filtered, "Filtered list should be nil on error")
	})

	t.Run("Filter empty list with empty indices", func(t *testing.T) {
		indices := []int{}
		filtered, err := sl.FilterByIdxs(indices)

		assert.NoError(t, err, "FilterByIdxs should not return error for empty indices on empty list")
		assert.NotNil(t, filtered, "Filtered list should not be nil")
		assert.Equal(t, 0, len(filtered.Servers), "Should have 0 servers")
	})
}

func TestServerList_GetServerByIdx(t *testing.T) {
	sl := createTestServerList(t)

	t.Run("Get server with valid index", func(t *testing.T) {
		server, err := sl.GetServerByIdx(2)

		assert.NoError(t, err, "GetServerByIdx should not return error for valid index")
		assert.NotNil(t, server, "Server should not be nil")
		assert.Equal(t, sl.Servers[2], server, "Should return the correct server")
	})

	t.Run("Get first server", func(t *testing.T) {
		server, err := sl.GetServerByIdx(0)

		assert.NoError(t, err, "GetServerByIdx should not return error for index 0")
		assert.NotNil(t, server, "Server should not be nil")
		assert.Equal(t, sl.Servers[0], server, "Should return the first server")
	})

	t.Run("Get last server", func(t *testing.T) {
		lastIdx := len(sl.Servers) - 1
		server, err := sl.GetServerByIdx(lastIdx)

		assert.NoError(t, err, "GetServerByIdx should not return error for last index")
		assert.NotNil(t, server, "Server should not be nil")
		assert.Equal(t, sl.Servers[lastIdx], server, "Should return the last server")
	})

	t.Run("Get server with out of range index", func(t *testing.T) {
		server, err := sl.GetServerByIdx(100)

		assert.Error(t, err, "GetServerByIdx should return error for out of range index")
		assert.Nil(t, server, "Server should be nil on error")
		assert.Contains(t, err.Error(), "out of range", "Error message should mention out of range")
	})

	t.Run("Get server with negative index", func(t *testing.T) {
		server, err := sl.GetServerByIdx(-1)

		assert.Error(t, err, "GetServerByIdx should return error for negative index")
		assert.Nil(t, server, "Server should be nil on error")
	})
}

func TestServerList_GetServerByIdx_EmptyList(t *testing.T) {
	sl := &ServerList{
		Name:    "EmptyList",
		Servers: []*Server{},
	}

	t.Run("Get server from empty list", func(t *testing.T) {
		server, err := sl.GetServerByIdx(0)

		assert.Error(t, err, "GetServerByIdx should return error on empty list")
		assert.Nil(t, server, "Server should be nil on error")
	})
}

func TestServerList_GetServerByPubkey(t *testing.T) {
	sl := createTestServerList(t)

	t.Run("Get server with existing public key", func(t *testing.T) {
		// Use the public key from the second server
		targetPubkey := sl.Servers[1].PublicKey

		server := sl.GetServerByPubkey(targetPubkey)

		assert.NotNil(t, server, "Server should not be nil when public key exists")
		assert.Equal(t, targetPubkey, server.PublicKey, "Should return server with matching public key")
		assert.Equal(t, sl.Servers[1], server, "Should return the correct server")
	})

	t.Run("Get server with non-existent public key", func(t *testing.T) {
		server := sl.GetServerByPubkey("nonexistent-pubkey-12345")

		assert.Nil(t, server, "Server should be nil when public key doesn't exist")
	})

	t.Run("Get server with empty public key", func(t *testing.T) {
		server := sl.GetServerByPubkey("")

		assert.Nil(t, server, "Server should be nil when searching for empty public key")
	})

	t.Run("Get first matching server", func(t *testing.T) {
		// Add a duplicate public key
		duplicatePubkey := sl.Servers[0].PublicKey
		newServer, err := CreateServerFromUrl("https://duplicate.example.com/meow")
		if err != nil {
			t.Fatalf("Failed to create server: %v", err)
		}
		newServer.PublicKey = duplicatePubkey
		sl.Servers = append(sl.Servers, newServer)

		server := sl.GetServerByPubkey(duplicatePubkey)

		assert.NotNil(t, server, "Server should not be nil")
		assert.Equal(t, duplicatePubkey, server.PublicKey)
		// Should return the first match
		assert.Equal(t, sl.Servers[0], server, "Should return the first matching server")
	})
}

func TestServerList_GetServerByPubkey_EmptyList(t *testing.T) {
	sl := &ServerList{
		Name:    "EmptyList",
		Servers: []*Server{},
	}

	t.Run("Get server from empty list", func(t *testing.T) {
		server := sl.GetServerByPubkey("any-pubkey")

		assert.Nil(t, server, "Server should be nil when searching in empty list")
	})
}

func TestServerList_AddUrls(t *testing.T) {
	t.Run("Add valid URLs", func(t *testing.T) {
		sl := &ServerList{
			Name:    "TestList",
			Servers: []*Server{},
		}

		urls := []string{
			"https://server1.example.com/meow",
			"https://server2.example.com/meow",
			"https://server3.example.com/meow",
		}

		err := sl.AddUrls(urls)

		assert.NoError(t, err, "AddUrls should not return error for valid URLs")
		assert.Equal(t, 3, len(sl.Servers), "Should have 3 servers after adding URLs")

		// Verify each server was created correctly
		for i, url := range urls {
			assert.Equal(t, url, sl.Servers[i].Url, "Server URL should match")
			assert.NotNil(t, sl.Servers[i].UserKp, "Server should have UserKp")
		}
	})

	t.Run("Add empty URLs list", func(t *testing.T) {
		sl := &ServerList{
			Name:    "TestList",
			Servers: []*Server{},
		}

		urls := []string{}
		err := sl.AddUrls(urls)

		assert.NoError(t, err, "AddUrls should not return error for empty list")
		assert.Equal(t, 0, len(sl.Servers), "Should have 0 servers after adding empty list")
	})

	t.Run("Add URLs to existing list", func(t *testing.T) {
		sl := createTestServerList(t)
		initialCount := len(sl.Servers)

		urls := []string{
			"https://newserver1.example.com/meow",
			"https://newserver2.example.com/meow",
		}

		err := sl.AddUrls(urls)

		assert.NoError(t, err, "AddUrls should not return error")
		assert.Equal(t, initialCount+2, len(sl.Servers), "Should have added 2 servers to existing list")
	})

	t.Run("Add single URL", func(t *testing.T) {
		sl := &ServerList{
			Name:    "TestList",
			Servers: []*Server{},
		}

		urls := []string{"https://single.example.com/meow"}
		err := sl.AddUrls(urls)

		assert.NoError(t, err, "AddUrls should not return error for single URL")
		assert.Equal(t, 1, len(sl.Servers), "Should have 1 server after adding single URL")
	})
}

func TestServerList_AddUrls_NilList(t *testing.T) {
	t.Run("Add URLs to nil server list", func(t *testing.T) {
		sl := &ServerList{
			Name:    "TestList",
			Servers: nil, // Explicitly nil
		}

		urls := []string{"https://server.example.com/meow"}
		err := sl.AddUrls(urls)

		assert.NoError(t, err, "AddUrls should not return error even with nil Servers slice")
		assert.NotNil(t, sl.Servers, "Servers slice should be initialized")
		assert.Equal(t, 1, len(sl.Servers), "Should have 1 server after adding URL")
	})
}

// Test the ServerList struct itself
func TestServerList_Structure(t *testing.T) {
	t.Run("Create empty server list", func(t *testing.T) {
		sl := &ServerList{
			Name:    "TestList",
			Servers: []*Server{},
		}

		assert.NotNil(t, sl, "ServerList should not be nil")
		assert.Equal(t, "TestList", sl.Name, "Name should be set correctly")
		assert.NotNil(t, sl.Servers, "Servers slice should not be nil")
		assert.Equal(t, 0, len(sl.Servers), "Servers slice should be empty")
	})

	t.Run("Create server list with name", func(t *testing.T) {
		sl := &ServerList{
			Name: "MyMessageServers",
		}

		assert.Equal(t, "MyMessageServers", sl.Name)
	})
}