package engine

import (
	"testing"
)

func TestBuildWorkingSet(t *testing.T) {
	// Create some tasks
	task1, _ := CreateTask("Task 1")
	task2, _ := CreateTask("Task 2")
	task3, _ := CreateTask("Task 3")

	// Build working set with default filter
	ws, err := BuildWorkingSet(DefaultFilter())
	if err != nil {
		t.Fatalf("Failed to build working set: %v", err)
	}

	if ws.Size() < 3 {
		t.Errorf("Expected at least 3 tasks in working set, got %d", ws.Size())
	}

	// Check that tasks are accessible by display ID
	task, err := ws.GetTaskByDisplayID(1)
	if err != nil {
		t.Fatalf("Failed to get task by display ID: %v", err)
	}

	if task == nil {
		t.Error("Task should not be nil")
	}

	// Verify tasks are in the set
	_, exists := ws.byUUID[task1.UUID]
	if !exists {
		t.Error("Task 1 should be in working set")
	}

	_, exists = ws.byUUID[task2.UUID]
	if !exists {
		t.Error("Task 2 should be in working set")
	}

	_, exists = ws.byUUID[task3.UUID]
	if !exists {
		t.Error("Task 3 should be in working set")
	}
}

func TestLoadWorkingSet(t *testing.T) {
	// Create and build a working set
	CreateTask("Load test 1")
	CreateTask("Load test 2")

	ws1, err := BuildWorkingSet(DefaultFilter())
	if err != nil {
		t.Fatalf("Failed to build working set: %v", err)
	}

	size1 := ws1.Size()

	// Load the working set
	ws2, err := LoadWorkingSet()
	if err != nil {
		t.Fatalf("Failed to load working set: %v", err)
	}

	if ws2.Size() != size1 {
		t.Errorf("Loaded working set size (%d) doesn't match built size (%d)", ws2.Size(), size1)
	}
}

func TestWorkingSetWithFilter(t *testing.T) {
	// Create tasks with different priorities
	task1, _ := CreateTask("High priority task")
	task1.Priority = PriorityHigh
	task1.Save()

	task2, _ := CreateTask("Low priority task")
	task2.Priority = PriorityLow
	task2.Save()

	// Build working set with high priority filter
	filter, _ := ParseFilter([]string{"priority:H"})
	ws, err := BuildWorkingSet(filter)
	if err != nil {
		t.Fatalf("Failed to build filtered working set: %v", err)
	}

	// Should only contain high priority task
	_, exists := ws.byUUID[task1.UUID]
	if !exists {
		t.Error("High priority task should be in working set")
	}

	_, exists = ws.byUUID[task2.UUID]
	if exists {
		t.Error("Low priority task should NOT be in working set")
	}
}

func TestGetTaskByDisplayID(t *testing.T) {
	// Create tasks
	CreateTask("Display ID test 1")
	CreateTask("Display ID test 2")
	CreateTask("Display ID test 3")

	ws, _ := BuildWorkingSet(DefaultFilter())

	// Test valid display IDs
	for i := 1; i <= ws.Size(); i++ {
		task, err := ws.GetTaskByDisplayID(i)
		if err != nil {
			t.Errorf("Failed to get task with display ID %d: %v", i, err)
		}
		if task == nil {
			t.Errorf("Task with display ID %d should not be nil", i)
		}
	}

	// Test invalid display ID
	_, err := ws.GetTaskByDisplayID(999)
	if err == nil {
		t.Error("Should return error for invalid display ID")
	}
}

func TestWorkingSetGetTasks(t *testing.T) {
	// Create tasks
	CreateTask("GetTasks test 1")
	CreateTask("GetTasks test 2")

	ws, _ := BuildWorkingSet(DefaultFilter())

	tasks := ws.GetTasks()
	if len(tasks) != ws.Size() {
		t.Errorf("GetTasks returned %d tasks, expected %d", len(tasks), ws.Size())
	}

	// Verify tasks are in order
	for i, task := range tasks {
		displayID := i + 1
		expectedUUID := ws.byID[displayID]
		if task.UUID != expectedUUID {
			t.Errorf("Task at position %d has wrong UUID", i)
		}
	}
}