package groups

import (
	"fmt"
	"math/rand"
	"sync/atomic"
	"testing"
	"time"
)

// Mock implementations for benchmarking use the existing mock entities from groups_test.go

// Helper functions for creating test data

// createTestEntity creates a mock entity for benchmarking
func createTestEntity(id int32, name string, isPlayer bool) *mockEntity {
	entity := createMockEntity(id, name, isPlayer)
	// Randomize some properties for more realistic benchmarking
	entity.level = int8(rand.Intn(80) + 1)
	entity.class = int8(rand.Intn(25) + 1)
	entity.race = int8(rand.Intn(18) + 1)
	entity.hp = int32(rand.Intn(5000) + 1000)
	entity.maxHP = int32(rand.Intn(5000) + 1000)
	entity.power = int32(rand.Intn(3000) + 500)
	entity.maxPower = int32(rand.Intn(3000) + 500)
	entity.isBot = !isPlayer && rand.Intn(2) == 1
	entity.isNPC = !isPlayer && rand.Intn(2) == 0
	entity.zone = &mockZone{
		zoneID:     int32(rand.Intn(100) + 1),
		instanceID: int32(rand.Intn(10)),
		zoneName:   fmt.Sprintf("Zone %d", rand.Intn(100)+1),
	}
	return entity
}

// createTestGroup creates a group with test data for benchmarking
func createTestGroup(b *testing.B, groupID int32, memberCount int) *Group {
	b.Helper()
	
	group := NewGroup(groupID, nil, nil)
	
	// Add test members
	for i := 0; i < memberCount; i++ {
		entity := createTestEntity(
			int32(i+1),
			fmt.Sprintf("Player%d", i+1),
			true,
		)
		
		isLeader := (i == 0)
		err := group.AddMember(entity, isLeader)
		if err != nil {
			b.Fatalf("Failed to add member to group: %v", err)
		}
	}
	
	return group
}

// BenchmarkGroupCreation measures group creation performance
func BenchmarkGroupCreation(b *testing.B) {
	b.Run("NewGroup", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group := NewGroup(int32(i+1), nil, nil)
			group.Disband() // Clean up background goroutine
		}
	})
	
	b.Run("NewGroupWithOptions", func(b *testing.B) {
		options := DefaultGroupOptions()
		for i := 0; i < b.N; i++ {
			group := NewGroup(int32(i+1), &options, nil)
			group.Disband() // Clean up background goroutine
		}
	})
	
	b.Run("NewGroupParallel", func(b *testing.B) {
		var idCounter int64
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				id := atomic.AddInt64(&idCounter, 1)
				group := NewGroup(int32(id), nil, nil)
				group.Disband() // Clean up background goroutine
			}
		})
	})
}

// BenchmarkGroupMemberOperations measures member management performance
func BenchmarkGroupMemberOperations(b *testing.B) {
	group := createTestGroup(b, 1001, 3)
	defer group.Disband() // Clean up background goroutine
	
	b.Run("AddMember", func(b *testing.B) {
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			// Create a new group for each iteration to avoid full group
			testGroup := NewGroup(int32(i+1000), nil, nil)
			entity := createTestEntity(int32(i+1), fmt.Sprintf("BenchPlayer%d", i), true)
			testGroup.AddMember(entity, false)
			testGroup.Disband() // Clean up background goroutine
		}
	})
	
	b.Run("GetSize", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetSize()
			}
		})
	})
	
	b.Run("GetMembers", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = group.GetMembers()
		}
	})
	
	b.Run("GetLeaderName", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetLeaderName()
			}
		})
	})
	
	b.Run("UpdateGroupMemberInfo", func(b *testing.B) {
		members := group.GetMembers()
		if len(members) == 0 {
			b.Skip("No members to update")
		}
		
		for i := 0; i < b.N; i++ {
			member := members[i%len(members)]
			if member.Member != nil {
				group.UpdateGroupMemberInfo(member.Member, false)
			}
		}
	})
}

// BenchmarkGroupOptions measures group options performance
func BenchmarkGroupOptions(b *testing.B) {
	group := createTestGroup(b, 1001, 3)
	defer group.Disband() // Clean up background goroutine
	
	b.Run("GetGroupOptions", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetGroupOptions()
			}
		})
	})
	
	b.Run("SetGroupOptions", func(b *testing.B) {
		options := DefaultGroupOptions()
		for i := 0; i < b.N; i++ {
			options.LootMethod = int8(i % 4)
			group.SetGroupOptions(&options)
		}
	})
	
	b.Run("GetLastLooterIndex", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetLastLooterIndex()
			}
		})
	})
	
	b.Run("SetNextLooterIndex", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group.SetNextLooterIndex(int8(i % 6))
		}
	})
}

// BenchmarkGroupRaidOperations measures raid functionality performance
func BenchmarkGroupRaidOperations(b *testing.B) {
	group := createTestGroup(b, 1001, 6)
	defer group.Disband() // Clean up background goroutine
	
	// Setup some raid groups
	raidGroups := []int32{1001, 1002, 1003, 1004}
	group.ReplaceRaidGroups(raidGroups)
	
	b.Run("GetRaidGroups", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetRaidGroups()
			}
		})
	})
	
	b.Run("IsGroupRaid", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.IsGroupRaid()
			}
		})
	})
	
	b.Run("IsInRaidGroup", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			targetID := int32((i % 4) + 1001)
			_ = group.IsInRaidGroup(targetID, false)
		}
	})
	
	b.Run("AddGroupToRaid", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			// Cycle through a limited set of group IDs to avoid infinite growth
			groupID := int32(2000 + (i % 10))
			group.AddGroupToRaid(groupID)
		}
	})
	
	b.Run("ReplaceRaidGroups", func(b *testing.B) {
		newGroups := []int32{2001, 2002, 2003}
		for i := 0; i < b.N; i++ {
			group.ReplaceRaidGroups(newGroups)
		}
	})
	
	b.Run("ClearGroupRaid", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group.ClearGroupRaid()
			// Re-add groups for next iteration
			group.ReplaceRaidGroups(raidGroups)
		}
	})
}

// BenchmarkGroupMessaging measures messaging performance
func BenchmarkGroupMessaging(b *testing.B) {
	group := createTestGroup(b, 1001, 6)
	defer group.Disband() // Clean up background goroutine
	
	b.Run("SimpleGroupMessage", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group.SimpleGroupMessage(fmt.Sprintf("Benchmark message %d", i))
		}
	})
	
	b.Run("SendGroupMessage", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group.SendGroupMessage(GROUP_MESSAGE_TYPE_SYSTEM, fmt.Sprintf("System message %d", i))
		}
	})
	
	b.Run("GroupChatMessageFromName", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			group.GroupChatMessageFromName(
				fmt.Sprintf("Player%d", i%6+1), 
				0, 
				fmt.Sprintf("Chat message %d", i), 
				CHANNEL_GROUP_CHAT,
			)
		}
	})
}

// BenchmarkGroupState measures group state operations
func BenchmarkGroupState(b *testing.B) {
	group := createTestGroup(b, 1001, 6)
	defer group.Disband() // Clean up background goroutine
	
	b.Run("GetID", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetID()
			}
		})
	})
	
	b.Run("IsDisbanded", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.IsDisbanded()
			}
		})
	})
	
	b.Run("GetCreatedTime", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetCreatedTime()
			}
		})
	})
	
	b.Run("GetLastActivity", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = group.GetLastActivity()
			}
		})
	})
}

// BenchmarkMasterListOperations measures master list performance
func BenchmarkMasterListOperations(b *testing.B) {
	ml := NewMasterList()
	
	// Pre-populate with groups
	const numGroups = 1000
	groups := make([]*Group, numGroups)
	
	b.StopTimer()
	for i := 0; i < numGroups; i++ {
		groups[i] = createTestGroup(b, int32(i+1), rand.Intn(6)+1)
		ml.AddGroup(groups[i])
	}
	// Cleanup all groups when benchmark is done
	defer func() {
		for _, group := range groups {
			if group != nil {
				group.Disband()
			}
		}
	}()
	b.StartTimer()
	
	b.Run("GetGroup", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				id := int32(rand.Intn(numGroups) + 1)
				_ = ml.GetGroup(id)
			}
		})
	})
	
	b.Run("AddGroup", func(b *testing.B) {
		startID := int32(numGroups + 1)
		var addedGroups []*Group
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			group := createTestGroup(b, startID+int32(i), 3)
			ml.AddGroup(group)
			addedGroups = append(addedGroups, group)
		}
		// Cleanup added groups
		for _, group := range addedGroups {
			group.Disband()
		}
	})
	
	b.Run("GetAllGroups", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = ml.GetAllGroups()
		}
	})
	
	b.Run("GetActiveGroups", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = ml.GetActiveGroups()
		}
	})
	
	b.Run("GetGroupsByZone", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			zoneID := int32(rand.Intn(100) + 1)
			_ = ml.GetGroupsByZone(zoneID)
		}
	})
	
	b.Run("GetGroupsBySize", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			size := int32(rand.Intn(6) + 1)
			_ = ml.GetGroupsBySize(size)
		}
	})
	
	b.Run("GetRaidGroups", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = ml.GetRaidGroups()
		}
	})
	
	b.Run("GetGroupStatistics", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = ml.GetGroupStatistics()
		}
	})
}

// BenchmarkManagerOperations measures manager performance
func BenchmarkManagerOperations(b *testing.B) {
	config := GroupManagerConfig{
		MaxGroups:          1000,
		InviteTimeout:      30 * time.Second,
		UpdateInterval:     1 * time.Second,
		BuffUpdateInterval: 5 * time.Second,
		EnableStatistics:   true,
	}
	
	manager := NewManager(config, nil)
	
	// Pre-populate with groups
	b.StopTimer()
	for i := 0; i < 100; i++ {
		leader := createTestEntity(int32(i+1), fmt.Sprintf("Leader%d", i+1), true)
		manager.NewGroup(leader, nil, 0)
	}
	b.StartTimer()
	
	b.Run("NewGroup", func(b *testing.B) {
		startID := int32(1000)
		for i := 0; i < b.N; i++ {
			leader := createTestEntity(startID+int32(i), fmt.Sprintf("BenchLeader%d", i), true)
			_, err := manager.NewGroup(leader, nil, 0)
			if err != nil {
				b.Fatalf("Failed to create group: %v", err)
			}
		}
	})
	
	b.Run("GetGroup", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				groupID := int32(rand.Intn(100) + 1)
				_ = manager.GetGroup(groupID)
			}
		})
	})
	
	b.Run("IsGroupIDValid", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				groupID := int32(rand.Intn(100) + 1)
				_ = manager.IsGroupIDValid(groupID)
			}
		})
	})
	
	b.Run("GetGroupCount", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = manager.GetGroupCount()
			}
		})
	})
	
	b.Run("GetAllGroups", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			_ = manager.GetAllGroups()
		}
	})
	
	b.Run("GetStats", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				_ = manager.GetStats()
			}
		})
	})
}

// BenchmarkInviteSystem measures invitation system performance
func BenchmarkInviteSystem(b *testing.B) {
	config := GroupManagerConfig{
		InviteTimeout:    30 * time.Second,
		EnableStatistics: true,
	}
	
	manager := NewManager(config, nil)
	
	b.Run("AddInvite", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			leader := createTestEntity(int32(i+1), fmt.Sprintf("Leader%d", i+1), true)
			member := createTestEntity(int32(i+1001), fmt.Sprintf("Member%d", i+1), true)
			manager.AddInvite(leader, member)
		}
	})
	
	b.Run("HasPendingInvite", func(b *testing.B) {
		// Add some invites first
		for i := 0; i < 100; i++ {
			leader := createTestEntity(int32(i+1), fmt.Sprintf("TestLeader%d", i+1), true)
			member := createTestEntity(int32(i+2001), fmt.Sprintf("TestMember%d", i+1), true)
			manager.AddInvite(leader, member)
		}
		
		b.ResetTimer()
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				member := createTestEntity(int32(rand.Intn(100)+2001), fmt.Sprintf("TestMember%d", rand.Intn(100)+1), true)
				_ = manager.HasPendingInvite(member)
			}
		})
	})
	
	b.Run("Invite", func(b *testing.B) {
		for i := 0; i < b.N; i++ {
			leader := createTestEntity(int32(i+3001), fmt.Sprintf("InviteLeader%d", i+1), true)
			member := createTestEntity(int32(i+4001), fmt.Sprintf("InviteMember%d", i+1), true)
			_ = manager.Invite(leader, member)
		}
	})
	
	b.Run("DeclineInvite", func(b *testing.B) {
		// Add invites to decline
		for i := 0; i < b.N; i++ {
			leader := createTestEntity(int32(i+5001), fmt.Sprintf("DeclineLeader%d", i+1), true)
			member := createTestEntity(int32(i+6001), fmt.Sprintf("DeclineMember%d", i+1), true)
			manager.AddInvite(leader, member)
			manager.DeclineInvite(member)
		}
	})
}

// BenchmarkConcurrentOperations measures concurrent access performance
func BenchmarkConcurrentOperations(b *testing.B) {
	config := GroupManagerConfig{
		MaxGroups:        1000,
		EnableStatistics: true,
	}
	
	manager := NewManager(config, nil)
	
	// Pre-populate
	for i := 0; i < 50; i++ {
		leader := createTestEntity(int32(i+1), fmt.Sprintf("ConcurrentLeader%d", i+1), true)
		manager.NewGroup(leader, nil, 0)
	}
	
	b.Run("ConcurrentGroupAccess", func(b *testing.B) {
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				groupID := int32(rand.Intn(50) + 1)
				
				switch rand.Intn(4) {
				case 0:
					_ = manager.GetGroup(groupID)
				case 1:
					_ = manager.GetGroupSize(groupID)
				case 2:
					_ = manager.IsGroupIDValid(groupID)
				case 3:
					member := createTestEntity(int32(rand.Intn(1000)+10000), "ConcurrentMember", true)
					manager.AddGroupMember(groupID, member, false)
				}
			}
		})
	})
	
	b.Run("ConcurrentInviteOperations", func(b *testing.B) {
		var counter int64
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				i := atomic.AddInt64(&counter, 1)
				leader := createTestEntity(int32(i+20000), fmt.Sprintf("ConcurrentInviteLeader%d", i), true)
				member := createTestEntity(int32(i+30000), fmt.Sprintf("ConcurrentInviteMember%d", i), true)
				
				switch rand.Intn(3) {
				case 0:
					manager.AddInvite(leader, member)
				case 1:
					_ = manager.HasPendingInvite(member)
				case 2:
					manager.DeclineInvite(member)
				}
			}
		})
	})
}

// BenchmarkMemoryAllocation measures memory allocation patterns
func BenchmarkMemoryAllocation(b *testing.B) {
	b.Run("GroupAllocation", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			group := NewGroup(int32(i+1), nil, nil)
			group.Disband() // Clean up background goroutine
		}
	})
	
	b.Run("MasterListAllocation", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			ml := NewMasterList()
			_ = ml
		}
	})
	
	b.Run("ManagerAllocation", func(b *testing.B) {
		config := GroupManagerConfig{}
		b.ReportAllocs()
		b.ResetTimer()
		for i := 0; i < b.N; i++ {
			manager := NewManager(config, nil)
			_ = manager
		}
	})
	
	b.Run("GroupMemberInfoAllocation", func(b *testing.B) {
		b.ReportAllocs()
		for i := 0; i < b.N; i++ {
			gmi := &GroupMemberInfo{
				GroupID:      int32(i + 1),
				Name:         fmt.Sprintf("Member%d", i+1),
				Zone:         "TestZone",
				HPCurrent:    1000,
				HPMax:        1000,
				PowerCurrent: 500,
				PowerMax:     500,
				LevelCurrent: 50,
				LevelMax:     80,
				RaceID:       1,
				ClassID:      1,
				Leader:       false,
				IsClient:     true,
				JoinTime:     time.Now(),
				LastUpdate:   time.Now(),
			}
			_ = gmi
		}
	})
}

// BenchmarkComparisonWithOldSystem provides comparison benchmarks
func BenchmarkComparisonWithOldSystem(b *testing.B) {
	ml := NewMasterList()
	const numGroups = 1000
	
	// Setup
	b.StopTimer()
	groups := make([]*Group, numGroups)
	for i := 0; i < numGroups; i++ {
		groups[i] = createTestGroup(b, int32(i+1), rand.Intn(6)+1)
		ml.AddGroup(groups[i])
	}
	// Cleanup all groups when benchmark is done
	defer func() {
		for _, group := range groups {
			if group != nil {
				group.Disband()
			}
		}
	}()
	b.StartTimer()
	
	b.Run("ModernizedGroupLookup", func(b *testing.B) {
		// Modern generic-based lookup
		b.RunParallel(func(pb *testing.PB) {
			for pb.Next() {
				id := int32(rand.Intn(numGroups) + 1)
				_ = ml.GetGroup(id)
			}
		})
	})
	
	b.Run("ModernizedGroupFiltering", func(b *testing.B) {
		// Modern filter-based operations
		for i := 0; i < b.N; i++ {
			_ = ml.GetActiveGroups()
		}
	})
	
	b.Run("ModernizedGroupStatistics", func(b *testing.B) {
		// Modern statistics computation
		for i := 0; i < b.N; i++ {
			_ = ml.GetGroupStatistics()
		}
	})
}