eq2go/internal/ground_spawn/ground_spawn_test.go

package ground_spawn

import (
	"testing"

	"eq2emu/internal/database"
)

func TestNew(t *testing.T) {
	// Test creating a new ground spawn
	db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	if err != nil {
		t.Fatalf("Failed to create test database: %v", err)
	}
	defer db.Close()

	gs := New(db)
	if gs == nil {
		t.Fatal("Expected non-nil ground spawn")
	}

	if gs.db != db {
		t.Error("Database connection not set correctly")
	}

	if !gs.isNew {
		t.Error("New ground spawn should be marked as new")
	}

	if !gs.IsAlive {
		t.Error("New ground spawn should be alive")
	}

	if gs.RandomizeHeading != true {
		t.Error("Default RandomizeHeading should be true")
	}
}

func TestGroundSpawnGetID(t *testing.T) {
	db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	if err != nil {
		t.Fatalf("Failed to create test database: %v", err)
	}
	defer db.Close()

	gs := New(db)
	gs.GroundSpawnID = 12345

	if gs.GetID() != 12345 {
		t.Errorf("Expected GetID() to return 12345, got %d", gs.GetID())
	}
}

func TestGroundSpawnState(t *testing.T) {
	db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	if err != nil {
		t.Fatalf("Failed to create test database: %v", err)
	}
	defer db.Close()

	gs := New(db)
	gs.NumberHarvests = 5
	gs.CurrentHarvests = 3

	if gs.IsDepleted() {
		t.Error("Ground spawn with harvests should not be depleted")
	}

	if !gs.IsAvailable() {
		t.Error("Ground spawn with harvests should be available")
	}

	gs.CurrentHarvests = 0
	if !gs.IsDepleted() {
		t.Error("Ground spawn with no harvests should be depleted")
	}

	if gs.IsAvailable() {
		t.Error("Depleted ground spawn should not be available")
	}
}

func TestHarvestMessageName(t *testing.T) {
	db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	if err != nil {
		t.Fatalf("Failed to create test database: %v", err)
	}
	defer db.Close()

	testCases := []struct {
		skill         string
		presentTense  bool
		failure       bool
		expectedVerb  string
	}{
		{"Mining", true, false, "mine"},
		{"Mining", false, false, "mined"},
		{"Gathering", true, false, "gather"},
		{"Gathering", false, false, "gathered"},
		{"Fishing", true, false, "fish"},
		{"Fishing", false, false, "fished"},
		{"Unknown", true, false, "collect"},
		{"Unknown", false, false, "collected"},
	}

	for _, tc := range testCases {
		gs := New(db)
		gs.CollectionSkill = tc.skill
		
		result := gs.GetHarvestMessageName(tc.presentTense, tc.failure)
		if result != tc.expectedVerb {
			t.Errorf("For skill %s (present=%v, failure=%v), expected %s, got %s",
				tc.skill, tc.presentTense, tc.failure, tc.expectedVerb, result)
		}
	}
}

func TestNewMasterList(t *testing.T) {
	ml := NewMasterList()
	if ml == nil {
		t.Fatal("Expected non-nil master list")
	}

	if ml.MasterList.Size() != 0 {
		t.Error("New master list should be empty")
	}
}

func TestMasterListOperations(t *testing.T) {
	db, err := database.NewSQLite("file::memory:?mode=memory&cache=shared")
	if err != nil {
		t.Fatalf("Failed to create test database: %v", err)
	}
	defer db.Close()

	ml := NewMasterList()
	
	// Create test ground spawn
	gs := New(db)
	gs.GroundSpawnID = 1001
	gs.Name = "Test Node"
	gs.CollectionSkill = "Mining"
	gs.ZoneID = 1
	gs.CurrentHarvests = 5

	// Test add
	if !ml.AddGroundSpawn(gs) {
		t.Error("Should be able to add new ground spawn")
	}

	// Test get
	retrieved := ml.GetGroundSpawn(1001)
	if retrieved == nil {
		t.Fatal("Should be able to retrieve added ground spawn")
	}

	if retrieved.Name != "Test Node" {
		t.Errorf("Expected name 'Test Node', got '%s'", retrieved.Name)
	}

	// Test zone filter
	zoneSpawns := ml.GetByZone(1)
	if len(zoneSpawns) != 1 {
		t.Errorf("Expected 1 spawn in zone 1, got %d", len(zoneSpawns))
	}

	// Test skill filter
	miningSpawns := ml.GetBySkill("Mining")
	if len(miningSpawns) != 1 {
		t.Errorf("Expected 1 mining spawn, got %d", len(miningSpawns))
	}

	// Test available spawns
	available := ml.GetAvailableSpawns()
	if len(available) != 1 {
		t.Errorf("Expected 1 available spawn, got %d", len(available))
	}

	// Test depleted spawns (should be none)
	depleted := ml.GetDepletedSpawns()
	if len(depleted) != 0 {
		t.Errorf("Expected 0 depleted spawns, got %d", len(depleted))
	}
}