package game

import (
	"testing"

	"gitea.boner.be/bdnugget/goonscape/game/testutils"
	"gitea.boner.be/bdnugget/goonscape/types"
	rl "github.com/gen2brain/raylib-go/raylib"
	"github.com/stretchr/testify/assert"
)

func TestMouseInput_EdgeCases(t *testing.T) {
	game, cleanup := setupTestEnvironment(t)
	defer cleanup()

	game.Player = &types.Player{ID: 1}

	tests := []struct {
		name     string
		ray      rl.Ray
		expected bool
	}{
		{
			name: "Click outside map bounds",
			ray: rl.Ray{
				Position:  rl.Vector3{X: 1000, Y: 10, Z: 1000},
				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
			},
			expected: false,
		},
		{
			name: "Click at map edge",
			ray: rl.Ray{
				Position:  rl.Vector3{X: float32(types.MapWidth * types.TileSize), Y: 10, Z: 0},
				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
			},
			expected: false,
		},
		{
			name: "Click on valid tile",
			ray: rl.Ray{
				Position:  rl.Vector3{X: 32, Y: 10, Z: 32},
				Direction: rl.Vector3{X: 0, Y: -1, Z: 0},
			},
			expected: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			testutils.ResetMockInput()
			testutils.SimulateMouseRay(tt.ray)
			testutils.SimulateMouseButton(testutils.ToInt32(rl.MouseLeftButton), true)
			tile, clicked := game.GetTileAtMouse()
			assert.Equal(t, tt.expected, clicked)
			if tt.expected {
				assert.NotEmpty(t, tile)
			}
		})
	}
}

func TestChat_InputValidation(t *testing.T) {
	game, cleanup := setupTestEnvironment(t)
	defer cleanup()

	game.Player = &types.Player{ID: 1}

	tests := []struct {
		name     string
		input    []rune
		expected string
	}{
		{
			name:     "Empty message",
			input:    []rune{},
			expected: "",
		},
		{
			name:     "Message with only spaces",
			input:    []rune("   "),
			expected: "",
		},
		{
			name:     "Very long message",
			input:    []rune(string(make([]rune, runeLimit))),
			expected: string(make([]rune, runeLimit)),
		},
		{
			name:     "Unicode characters",
			input:    []rune("Hello 世界"),
			expected: "Hello 世界",
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			testutils.ResetMockInput()
			testutils.SimulateKeyPress(rl.KeyT)
			game.Update(0.1)

			for _, r := range tt.input {
				testutils.SimulateCharInput(r)
				game.Update(0.1)
			}

			testutils.SimulateKeyPress(rl.KeyEnter)
			game.Update(0.1)

			if tt.expected != "" {
				assert.Equal(t, 1, len(game.Player.ActionQueue))
				assert.Equal(t, tt.expected, game.Player.ActionQueue[0].ChatMessage)
			} else {
				assert.Empty(t, game.Player.ActionQueue)
			}
		})
	}
}

func TestLogin_InputValidation(t *testing.T) {
	_, cleanup := setupTestEnvironment(t)
	defer cleanup()

	tests := []struct {
		name          string
		username      string
		password      string
		expectSuccess bool
	}{
		{
			name:          "Valid credentials",
			username:      "validuser",
			password:      "validpass",
			expectSuccess: true,
		},
		{
			name:          "Empty username",
			username:      "",
			password:      "password",
			expectSuccess: false,
		},
		{
			name:          "Empty password",
			username:      "username",
			password:      "",
			expectSuccess: false,
		},
		{
			name:          "Username too long",
			username:      "verylongusername123",
			password:      "password",
			expectSuccess: false,
		},
		{
			name:          "Special characters in username",
			username:      "user@name",
			password:      "password",
			expectSuccess: false,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			login := NewLoginScreen()
			testutils.ResetMockInput()

			// Simulate typing username
			login.focusedField = 0
			for _, r := range tt.username {
				testutils.SimulateCharInput(r)
				login.Update()
			}

			// Simulate typing password
			login.focusedField = 1
			for _, r := range tt.password {
				testutils.SimulateCharInput(r)
				login.Update()
			}

			// Simulate clicking login button
			testutils.SimulateMouseClick(400, 365)
			_, _, _, submitted := login.Update()
			assert.Equal(t, tt.expectSuccess, submitted)
		})
	}
}