package queue

import (
	"testing"

	scanner "atcr.io/scanner"
)

func TestTierToPriority(t *testing.T) {
	tests := []struct {
		tier     string
		expected int
	}{
		{"owner", PriorityOwner},
		{"quartermaster", PriorityQuartermaster},
		{"bosun", PriorityBosun},
		{"deckhand", PriorityDeckhand},
		{"unknown", PriorityDeckhand},
		{"", PriorityDeckhand},
	}

	for _, tt := range tests {
		if got := TierToPriority(tt.tier); got != tt.expected {
			t.Errorf("TierToPriority(%q) = %d, want %d", tt.tier, got, tt.expected)
		}
	}
}

func TestJobQueue_PriorityOrder(t *testing.T) {
	q := NewJobQueue(10)

	// Enqueue jobs in reverse priority order
	q.Enqueue(&scanner.ScanJob{Seq: 1, Tier: "deckhand", Repository: "free-1"})
	q.Enqueue(&scanner.ScanJob{Seq: 2, Tier: "owner", Repository: "owner-1"})
	q.Enqueue(&scanner.ScanJob{Seq: 3, Tier: "bosun", Repository: "bosun-1"})
	q.Enqueue(&scanner.ScanJob{Seq: 4, Tier: "quartermaster", Repository: "qm-1"})

	// Should dequeue in priority order: owner, quartermaster, bosun, deckhand
	expected := []string{"owner-1", "qm-1", "bosun-1", "free-1"}
	for _, exp := range expected {
		job := q.Dequeue()
		if job.Repository != exp {
			t.Errorf("expected %q, got %q", exp, job.Repository)
		}
	}
}

func TestJobQueue_FIFOWithinSamePriority(t *testing.T) {
	q := NewJobQueue(10)

	q.Enqueue(&scanner.ScanJob{Seq: 10, Tier: "deckhand", Repository: "first"})
	q.Enqueue(&scanner.ScanJob{Seq: 20, Tier: "deckhand", Repository: "second"})
	q.Enqueue(&scanner.ScanJob{Seq: 30, Tier: "deckhand", Repository: "third"})

	// Should dequeue in FIFO order within same priority
	expected := []string{"first", "second", "third"}
	for _, exp := range expected {
		job := q.Dequeue()
		if job.Repository != exp {
			t.Errorf("expected %q, got %q", exp, job.Repository)
		}
	}
}

func TestJobQueue_Full(t *testing.T) {
	q := NewJobQueue(2)

	ok1 := q.Enqueue(&scanner.ScanJob{Seq: 1, Tier: "deckhand"})
	ok2 := q.Enqueue(&scanner.ScanJob{Seq: 2, Tier: "deckhand"})
	ok3 := q.Enqueue(&scanner.ScanJob{Seq: 3, Tier: "deckhand"})

	if !ok1 || !ok2 {
		t.Error("first two enqueues should succeed")
	}
	if ok3 {
		t.Error("third enqueue should fail (queue full)")
	}
}

func TestJobQueue_CloseUnblocks(t *testing.T) {
	q := NewJobQueue(10)

	done := make(chan struct{})
	go func() {
		job := q.Dequeue()
		if job != nil {
			t.Error("expected nil from closed queue")
		}
		close(done)
	}()

	q.Close()
	<-done
}