package player

import (
	"testing"
	"time"

	"eq2emu/internal/database"
)

// MockLogger for testing
type MockLogger struct{}

func (ml *MockLogger) Debug(format string, args ...interface{})  {}
func (ml *MockLogger) Info(format string, args ...interface{})   {}
func (ml *MockLogger) Warn(format string, args ...interface{})   {}
func (ml *MockLogger) Error(format string, args ...interface{})  {}

// MockConfig for testing
type MockConfig struct{}

func (mc *MockConfig) GetString(key string) string { return "" }
func (mc *MockConfig) GetInt(key string) int       { return 0 }
func (mc *MockConfig) GetBool(key string) bool     { return false }

func TestPlayerManagerCreation(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database // Use nil for testing

	manager := NewPlayerManager(db, logger, config)
	if manager == nil {
		t.Fatal("Failed to create PlayerManager")
	}

	// Test that manager starts empty
	players := manager.GetAllPlayers()
	if len(players) != 0 {
		t.Errorf("Expected 0 players, got %d", len(players))
	}
}

func TestPlayerManagerAddRemove(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create a test player
	player := NewPlayer()
	player.charID = 12345
	player.SetLevel(10)

	// Test adding player
	manager.AddPlayer(player)
	
	// Verify player was added
	retrievedPlayer := manager.GetPlayer(12345)
	if retrievedPlayer == nil {
		t.Error("Failed to retrieve added player")
	}
	
	if retrievedPlayer.GetCharacterID() != 12345 {
		t.Errorf("Expected character ID 12345, got %d", retrievedPlayer.GetCharacterID())
	}

	// Test getting all players
	allPlayers := manager.GetAllPlayers()
	if len(allPlayers) != 1 {
		t.Errorf("Expected 1 player, got %d", len(allPlayers))
	}

	// Test removing player
	manager.RemovePlayer(12345)
	
	removedPlayer := manager.GetPlayer(12345)
	if removedPlayer != nil {
		t.Error("Player should have been removed")
	}
}

func TestPlayerManagerMultiplePlayers(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)

	// Add multiple players
	for i := 1; i <= 5; i++ {
		player := NewPlayer()
		player.charID = int32(i)
		player.SetLevel(int16(10 * i))
		manager.AddPlayer(player)
	}

	// Verify all players were added
	allPlayers := manager.GetAllPlayers()
	if len(allPlayers) != 5 {
		t.Errorf("Expected 5 players, got %d", len(allPlayers))
	}

	// Test retrieving specific players
	for i := 1; i <= 5; i++ {
		player := manager.GetPlayer(int32(i))
		if player == nil {
			t.Errorf("Failed to retrieve player %d", i)
		}
		if player.GetLevel() != int8(10*i) {
			t.Errorf("Expected level %d, got %d", 10*i, player.GetLevel())
		}
	}
}

func TestPlayerManagerExperience(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create and add a test player
	player := NewPlayer()
	player.charID = 999
	player.SetLevel(5)
	manager.AddPlayer(player)

	// Test adding experience (should not error even though it's simplified)
	err := manager.AddExperience(999, 1000, "adventure")
	if err != nil {
		t.Errorf("AddExperience failed: %v", err)
	}

	// Test adding tradeskill experience
	err = manager.AddExperience(999, 500, "tradeskill")
	if err != nil {
		t.Errorf("AddExperience tradeskill failed: %v", err)
	}

	// Test invalid XP type
	err = manager.AddExperience(999, 100, "invalid")
	if err == nil {
		t.Error("Expected error for invalid XP type")
	}

	// Test non-existent player
	err = manager.AddExperience(888, 100, "adventure")
	if err == nil {
		t.Error("Expected error for non-existent player")
	}
}

func TestPlayerManagerCombat(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create test players
	attacker := NewPlayer()
	attacker.charID = 100
	manager.AddPlayer(attacker)

	defender := NewPlayer()
	defender.charID = 200
	manager.AddPlayer(defender)

	// Test combat processing
	err := manager.ProcessCombat(100, 200, 50)
	if err != nil {
		t.Errorf("ProcessCombat failed: %v", err)
	}

	// Test combat with non-existent attacker
	err = manager.ProcessCombat(999, 200, 30)
	if err == nil {
		t.Error("Expected error for non-existent attacker")
	}
}

func TestPlayerManagerCurrency(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create test player
	player := NewPlayer()
	player.charID = 300
	manager.AddPlayer(player)

	// Test currency updates
	err := manager.UpdateCurrency(300, "coin", 1000)
	if err != nil {
		t.Errorf("UpdateCurrency coin failed: %v", err)
	}

	err = manager.UpdateCurrency(300, "tokens", 50)
	if err != nil {
		t.Errorf("UpdateCurrency tokens failed: %v", err)
	}

	err = manager.UpdateCurrency(300, "status", 25)
	if err != nil {
		t.Errorf("UpdateCurrency status failed: %v", err)
	}

	// Test invalid currency type
	err = manager.UpdateCurrency(300, "invalid", 100)
	if err == nil {
		t.Error("Expected error for invalid currency type")
	}
}

func TestPlayerManagerLevelUp(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create test player
	player := NewPlayer()
	player.charID = 400
	player.SetLevel(10)
	manager.AddPlayer(player)

	// Test level up
	err := manager.UpdatePlayerLevel(400, 11)
	if err != nil {
		t.Errorf("UpdatePlayerLevel failed: %v", err)
	}

	// Verify level was updated
	updatedPlayer := manager.GetPlayer(400)
	if updatedPlayer.GetLevel() != 11 {
		t.Errorf("Expected level 11, got %d", updatedPlayer.GetLevel())
	}

	// Test level up for non-existent player
	err = manager.UpdatePlayerLevel(999, 20)
	if err == nil {
		t.Error("Expected error for non-existent player")
	}
}

func TestPlayerManagerSave(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Create test player
	player := NewPlayer()
	player.charID = 500
	manager.AddPlayer(player)

	// Test save player (should not panic even with nil database)
	err := manager.SavePlayer(500)
	if err != nil {
		// Expected since we're using nil database
		t.Logf("Save failed as expected with nil database: %v", err)
	}

	// Test save all players
	err = manager.SaveAllPlayers()
	if err != nil {
		t.Errorf("SaveAllPlayers failed: %v", err)
	}
}

func TestPlayerManagerShutdown(t *testing.T) {
	logger := &MockLogger{}
	config := &MockConfig{}
	var db *database.Database

	manager := NewPlayerManager(db, logger, config)
	
	// Add some test players
	for i := 1; i <= 3; i++ {
		player := NewPlayer()
		player.charID = int32(600 + i)
		manager.AddPlayer(player)
	}

	// Test graceful shutdown (should not panic)
	manager.Shutdown()
	
	// Give a moment for background processes to stop
	time.Sleep(100 * time.Millisecond)
}