package task

import (
	"strings"
	"testing"
)

func validTask() *Task {
	return &Task{
		ID:   "test-id",
		Name: "Valid Task",
		Agent: AgentConfig{
			Type:         "claude",
			Instructions: "do something",
			ProjectDir:   "/tmp",
		},
		Priority: PriorityNormal,
		Retry:    RetryConfig{MaxAttempts: 1, Backoff: "exponential"},
	}
}

func TestValidate_ValidTask_NoError(t *testing.T) {
	task := validTask()
	if err := Validate(task); err != nil {
		t.Errorf("expected no error, got: %v", err)
	}
}

func TestValidate_MissingName_ReturnsError(t *testing.T) {
	task := validTask()
	task.Name = ""
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "name is required") {
		t.Errorf("expected 'name is required' in error, got: %v", err)
	}
}

func TestValidate_MissingInstructions_ReturnsError(t *testing.T) {
	task := validTask()
	task.Agent.Instructions = ""
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "instructions is required") {
		t.Errorf("expected 'instructions is required' in error, got: %v", err)
	}
}

func TestValidate_NegativeBudget_ReturnsError(t *testing.T) {
	task := validTask()
	task.Agent.MaxBudgetUSD = -1.0
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "max_budget_usd") {
		t.Errorf("expected budget error, got: %v", err)
	}
}

func TestValidate_InvalidBackoff_ReturnsError(t *testing.T) {
	task := validTask()
	task.Retry.Backoff = "random"
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "backoff") {
		t.Errorf("expected backoff error, got: %v", err)
	}
}

func TestValidate_InvalidPriority_ReturnsError(t *testing.T) {
	task := validTask()
	task.Priority = "urgent"
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "invalid priority") {
		t.Errorf("expected priority error, got: %v", err)
	}
}

func TestValidate_InvalidPermissionMode_ReturnsError(t *testing.T) {
	task := validTask()
	task.Agent.PermissionMode = "yolo"
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	if !strings.Contains(err.Error(), "permission_mode") {
		t.Errorf("expected permission_mode error, got: %v", err)
	}
}

func TestValidate_MultipleErrors(t *testing.T) {
	task := &Task{
		Retry: RetryConfig{MaxAttempts: 0, Backoff: "bad"},
	}
	err := Validate(task)
	if err == nil {
		t.Fatal("expected error")
	}
	ve, ok := err.(*ValidationError)
	if !ok {
		t.Fatalf("expected *ValidationError, got %T", err)
	}
	if len(ve.Errors) < 3 {
		t.Errorf("expected at least 3 errors, got %d: %v", len(ve.Errors), ve.Errors)
	}
}