package chat

import (
	"testing"

	"eq2emu/internal/database"
)

func TestNewMasterList(t *testing.T) {
	masterList := NewMasterList()

	if masterList == nil {
		t.Fatal("NewMasterList returned nil")
	}

	if masterList.GetChannelCount() != 0 {
		t.Errorf("Expected count 0, got %d", masterList.GetChannelCount())
	}
}

func TestMasterListBasicOperations(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Create test channels
	channel1 := NewWithData(1001, "Auction", ChannelTypeWorld, db)
	channel2 := NewWithData(1002, "Custom Channel", ChannelTypeCustom, db)

	// Test adding
	if !masterList.AddChannel(channel1) {
		t.Error("Should successfully add channel1")
	}

	if !masterList.AddChannel(channel2) {
		t.Error("Should successfully add channel2")
	}

	// Test duplicate add (should fail)
	if masterList.AddChannel(channel1) {
		t.Error("Should not add duplicate channel")
	}

	if masterList.GetChannelCount() != 2 {
		t.Errorf("Expected count 2, got %d", masterList.GetChannelCount())
	}

	// Test retrieving
	retrieved := masterList.GetChannel(1001)
	if retrieved == nil {
		t.Error("Should retrieve added channel")
	}

	if retrieved.GetName() != "Auction" {
		t.Errorf("Expected name 'Auction', got '%s'", retrieved.GetName())
	}

	// Test safe retrieval
	retrieved, exists := masterList.GetChannelSafe(1001)
	if !exists || retrieved == nil {
		t.Error("GetChannelSafe should return channel and true")
	}

	_, exists = masterList.GetChannelSafe(9999)
	if exists {
		t.Error("GetChannelSafe should return false for non-existent ID")
	}

	// Test HasChannel
	if !masterList.HasChannel(1001) {
		t.Error("HasChannel should return true for existing ID")
	}

	if masterList.HasChannel(9999) {
		t.Error("HasChannel should return false for non-existent ID")
	}

	// Test removing
	if !masterList.RemoveChannel(1001) {
		t.Error("Should successfully remove channel")
	}

	if masterList.GetChannelCount() != 1 {
		t.Errorf("Expected count 1, got %d", masterList.GetChannelCount())
	}

	if masterList.HasChannel(1001) {
		t.Error("Channel should be removed")
	}

	// Test clear
	masterList.ClearChannels()
	if masterList.GetChannelCount() != 0 {
		t.Errorf("Expected count 0 after clear, got %d", masterList.GetChannelCount())
	}
}

func TestMasterListFiltering(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Add test data
	channels := []*Channel{
		NewWithData(1, "Auction", ChannelTypeWorld, db),
		NewWithData(2, "Trade", ChannelTypeWorld, db),
		NewWithData(3, "Custom Chat", ChannelTypeCustom, db),
		NewWithData(4, "Player Channel", ChannelTypeCustom, db),
	}

	for _, ch := range channels {
		masterList.AddChannel(ch)
	}

	// Test FindChannelsByName
	auctionChannels := masterList.FindChannelsByName("Auction")
	if len(auctionChannels) != 1 {
		t.Errorf("FindChannelsByName('Auction') returned %v results, want 1", len(auctionChannels))
	}

	chatChannels := masterList.FindChannelsByName("Channel")
	if len(chatChannels) != 1 {
		t.Errorf("FindChannelsByName('Channel') returned %v results, want 1", len(chatChannels))
	}

	// Test FindChannelsByType
	worldChannels := masterList.FindChannelsByType(ChannelTypeWorld)
	if len(worldChannels) != 2 {
		t.Errorf("FindChannelsByType(World) returned %v results, want 2", len(worldChannels))
	}

	customChannels := masterList.FindChannelsByType(ChannelTypeCustom)
	if len(customChannels) != 2 {
		t.Errorf("FindChannelsByType(Custom) returned %v results, want 2", len(customChannels))
	}

	// Test GetWorldChannels
	worldList := masterList.GetWorldChannels()
	if len(worldList) != 2 {
		t.Errorf("GetWorldChannels() returned %v results, want 2", len(worldList))
	}

	// Test GetCustomChannels
	customList := masterList.GetCustomChannels()
	if len(customList) != 2 {
		t.Errorf("GetCustomChannels() returned %v results, want 2", len(customList))
	}

	// Test GetActiveChannels (all channels are empty initially)
	activeChannels := masterList.GetActiveChannels()
	if len(activeChannels) != 0 {
		t.Errorf("GetActiveChannels() returned %v results, want 0", len(activeChannels))
	}

	// Add members to make channels active
	channels[0].JoinChannel(1001)
	channels[1].JoinChannel(1002)

	activeChannels = masterList.GetActiveChannels()
	if len(activeChannels) != 2 {
		t.Errorf("GetActiveChannels() returned %v results, want 2", len(activeChannels))
	}

	// Test GetEmptyChannels
	emptyChannels := masterList.GetEmptyChannels()
	if len(emptyChannels) != 2 {
		t.Errorf("GetEmptyChannels() returned %v results, want 2", len(emptyChannels))
	}
}

func TestMasterListGetByName(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Add test channels
	channel1 := NewWithData(100, "Auction", ChannelTypeWorld, db)
	channel2 := NewWithData(200, "AUCTION", ChannelTypeWorld, db) // Different case
	masterList.AddChannel(channel1)
	masterList.AddChannel(channel2)

	// Test case-insensitive lookup
	found := masterList.GetChannelByName("auction")
	if found == nil {
		t.Error("GetChannelByName should find channel (case insensitive)")
	}

	found = masterList.GetChannelByName("AUCTION")
	if found == nil {
		t.Error("GetChannelByName should find channel (uppercase)")
	}

	found = masterList.GetChannelByName("NonExistent")
	if found != nil {
		t.Error("GetChannelByName should return nil for non-existent channel")
	}

	// Test HasChannelByName
	if !masterList.HasChannelByName("auction") {
		t.Error("HasChannelByName should return true for existing channel")
	}

	if masterList.HasChannelByName("NonExistent") {
		t.Error("HasChannelByName should return false for non-existent channel")
	}
}

func TestMasterListCompatibility(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Create channels with restrictions
	channel1 := NewWithData(1, "LowLevel", ChannelTypeWorld, db)
	channel1.SetLevelRestriction(5)

	channel2 := NewWithData(2, "HighLevel", ChannelTypeWorld, db)
	channel2.SetLevelRestriction(50)

	channel3 := NewWithData(3, "RaceRestricted", ChannelTypeWorld, db)
	channel3.SetRacesAllowed(1 << 1) // Only race 1 allowed

	masterList.AddChannel(channel1)
	masterList.AddChannel(channel2)
	masterList.AddChannel(channel3)

	// Test compatibility for level 10, race 1, class 1 player
	compatible := masterList.GetCompatibleChannels(10, 1, 1)
	if len(compatible) != 2 { // Should match channel1 and channel3
		t.Errorf("GetCompatibleChannels(10,1,1) returned %v results, want 2", len(compatible))
	}

	// Test compatibility for level 60, race 2, class 1 player  
	compatible = masterList.GetCompatibleChannels(60, 2, 1)
	if len(compatible) != 2 { // Should match channel1 and channel2 (not channel3)
		t.Errorf("GetCompatibleChannels(60,2,1) returned %v results, want 2", len(compatible))
	}

	// Test compatibility for level 1, race 1, class 1 player
	compatible = masterList.GetCompatibleChannels(1, 1, 1)
	if len(compatible) != 1 { // Should only match channel3 (no level restriction)
		t.Errorf("GetCompatibleChannels(1,1,1) returned %v results, want 1", len(compatible))
	}
}

func TestMasterListGetAll(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Add test channels
	for i := int32(1); i <= 3; i++ {
		ch := NewWithData(i*100, "Test", ChannelTypeWorld, db)
		masterList.AddChannel(ch)
	}

	// Test GetAllChannels (map)
	allMap := masterList.GetAllChannels()
	if len(allMap) != 3 {
		t.Errorf("GetAllChannels() returned %v items, want 3", len(allMap))
	}

	// Verify it's a copy by modifying returned map
	delete(allMap, 100)
	if masterList.GetChannelCount() != 3 {
		t.Error("Modifying returned map affected internal state")
	}

	// Test GetAllChannelsList (slice)
	allList := masterList.GetAllChannelsList()
	if len(allList) != 3 {
		t.Errorf("GetAllChannelsList() returned %v items, want 3", len(allList))
	}
}

func TestMasterListValidation(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Add valid channels
	ch1 := NewWithData(100, "Valid Channel", ChannelTypeWorld, db)
	masterList.AddChannel(ch1)

	issues := masterList.ValidateChannels()
	if len(issues) != 0 {
		t.Errorf("ValidateChannels() returned issues for valid data: %v", issues)
	}

	if !masterList.IsValid() {
		t.Error("IsValid() should return true for valid data")
	}

	// Add invalid channel (empty name)
	ch2 := NewWithData(200, "", ChannelTypeWorld, db)
	masterList.AddChannel(ch2)

	issues = masterList.ValidateChannels()
	if len(issues) == 0 {
		t.Error("ValidateChannels() should return issues for invalid data")
	}

	if masterList.IsValid() {
		t.Error("IsValid() should return false for invalid data")
	}
}

func TestMasterListStatistics(t *testing.T) {
	db, _ := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	defer db.Close()

	masterList := NewMasterList()

	// Add channels with different types
	masterList.AddChannel(NewWithData(10, "World1", ChannelTypeWorld, db))
	masterList.AddChannel(NewWithData(20, "World2", ChannelTypeWorld, db))
	masterList.AddChannel(NewWithData(30, "Custom1", ChannelTypeCustom, db))
	masterList.AddChannel(NewWithData(40, "Custom2", ChannelTypeCustom, db))
	masterList.AddChannel(NewWithData(50, "Custom3", ChannelTypeCustom, db))

	// Add some members
	masterList.GetChannel(10).JoinChannel(1001)
	masterList.GetChannel(20).JoinChannel(1002)

	stats := masterList.GetStatistics()

	if total, ok := stats["total_channels"].(int); !ok || total != 5 {
		t.Errorf("total_channels = %v, want 5", stats["total_channels"])
	}

	if worldChannels, ok := stats["world_channels"].(int); !ok || worldChannels != 2 {
		t.Errorf("world_channels = %v, want 2", stats["world_channels"])
	}

	if customChannels, ok := stats["custom_channels"].(int); !ok || customChannels != 3 {
		t.Errorf("custom_channels = %v, want 3", stats["custom_channels"])
	}

	if activeChannels, ok := stats["active_channels"].(int); !ok || activeChannels != 2 {
		t.Errorf("active_channels = %v, want 2", stats["active_channels"])
	}

	if totalMembers, ok := stats["total_members"].(int); !ok || totalMembers != 2 {
		t.Errorf("total_members = %v, want 2", stats["total_members"])
	}

	if minID, ok := stats["min_id"].(int32); !ok || minID != 10 {
		t.Errorf("min_id = %v, want 10", stats["min_id"])
	}

	if maxID, ok := stats["max_id"].(int32); !ok || maxID != 50 {
		t.Errorf("max_id = %v, want 50", stats["max_id"])
	}

	if idRange, ok := stats["id_range"].(int32); !ok || idRange != 40 {
		t.Errorf("id_range = %v, want 40", stats["id_range"])
	}
}

func TestContainsFunction(t *testing.T) {
	tests := []struct {
		str    string
		substr string
		want   bool
	}{
		{"hello world", "world", true},
		{"hello world", "World", false}, // Case sensitive
		{"hello", "hello world", false},
		{"hello", "", true},
		{"", "hello", false},
		{"", "", true},
		{"abcdef", "cde", true},
		{"abcdef", "xyz", false},
	}

	for _, tt := range tests {
		t.Run("", func(t *testing.T) {
			if got := contains(tt.str, tt.substr); got != tt.want {
				t.Errorf("contains(%q, %q) = %v, want %v", tt.str, tt.substr, got, tt.want)
			}
		})
	}
}