package gitea

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"
)

func TestNewClient(t *testing.T) {
	c := NewClient("https://gitea.example.com")
	if c.baseURL != "https://gitea.example.com" {
		t.Errorf("baseURL = %q, want %q", c.baseURL, "https://gitea.example.com")
	}
	if c.maxConcurrent != 5 {
		t.Errorf("maxConcurrent = %d, want 5", c.maxConcurrent)
	}
	if c.cacheTTL != 30*time.Second {
		t.Errorf("cacheTTL = %v, want 30s", c.cacheTTL)
	}
}

func TestNewClient_TrailingSlash(t *testing.T) {
	c := NewClient("https://gitea.example.com/")
	if c.baseURL != "https://gitea.example.com" {
		t.Errorf("baseURL = %q, want trailing slash removed", c.baseURL)
	}
}

func TestCache(t *testing.T) {
	c := NewClient("https://gitea.example.com")

	// Cache miss.
	_, ok := c.getFromCache("key1")
	if ok {
		t.Error("expected cache miss")
	}

	// Cache set and hit.
	c.setCache("key1", "value1")
	val, ok := c.getFromCache("key1")
	if !ok {
		t.Fatal("expected cache hit")
	}
	if val.(string) != "value1" {
		t.Errorf("got %q, want %q", val, "value1")
	}

	// Invalidate.
	c.invalidateCache("key")
	_, ok = c.getFromCache("key1")
	if ok {
		t.Error("expected cache miss after invalidation")
	}
}

func TestCacheExpiry(t *testing.T) {
	c := NewClient("https://gitea.example.com")
	c.cacheTTL = 1 * time.Millisecond

	c.setCache("key1", "value1")
	time.Sleep(5 * time.Millisecond)

	_, ok := c.getFromCache("key1")
	if ok {
		t.Error("expected cache miss after TTL expiry")
	}
}

func TestInvalidateAll(t *testing.T) {
	c := NewClient("https://gitea.example.com")
	c.setCache("key1", "value1")
	c.setCache("key2", "value2")

	c.InvalidateAll()

	_, ok1 := c.getFromCache("key1")
	_, ok2 := c.getFromCache("key2")
	if ok1 || ok2 {
		t.Error("expected all cache entries to be invalidated")
	}
}

func TestPriorityScore(t *testing.T) {
	tests := []struct {
		labels []string
		want   int
	}{
		{[]string{"P1", "bug"}, 1},
		{[]string{"P2"}, 2},
		{[]string{"P3", "enhancement"}, 3},
		{[]string{"bug", "enhancement"}, 4},
		{nil, 4},
	}

	for _, tt := range tests {
		got := priorityScore(tt.labels)
		if got != tt.want {
			t.Errorf("priorityScore(%v) = %d, want %d", tt.labels, got, tt.want)
		}
	}
}

func TestListOrgs(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/v1/user/orgs" {
			t.Errorf("unexpected path: %s", r.URL.Path)
			http.NotFound(w, r)
			return
		}
		if r.Header.Get("Authorization") != "token test-token" {
			t.Error("missing or wrong Authorization header")
		}

		orgs := []Org{
			{Name: "org1", FullName: "Organization 1"},
			{Name: "org2", FullName: "Organization 2"},
		}
		json.NewEncoder(w).Encode(orgs)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	orgs, err := c.ListOrgs(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(orgs) != 2 {
		t.Fatalf("got %d orgs, want 2", len(orgs))
	}
	if orgs[0].Name != "org1" {
		t.Errorf("orgs[0].Name = %q, want %q", orgs[0].Name, "org1")
	}
}

func TestListOrgs_Cached(t *testing.T) {
	callCount := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		callCount++
		json.NewEncoder(w).Encode([]Org{{Name: "org1"}})
	}))
	defer server.Close()

	c := NewClient(server.URL)

	// First call should hit the server.
	_, err := c.ListOrgs(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Second call should use cache.
	_, err = c.ListOrgs(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if callCount != 1 {
		t.Errorf("server called %d times, want 1 (cached)", callCount)
	}
}

func TestListOrgRepos(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		repos := []Repo{
			{ID: 1, Name: "repo1", FullName: "org1/repo1"},
			{ID: 2, Name: "repo2", FullName: "org1/repo2"},
		}
		json.NewEncoder(w).Encode(repos)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	repos, err := c.ListOrgRepos(context.Background(), "test-token", "org1")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if len(repos) != 2 {
		t.Fatalf("got %d repos, want 2", len(repos))
	}
}

func TestGetTriageQueue_Sorting(t *testing.T) {
	queue := []TriageItem{
		{Title: "low", Labels: []string{"P3"}, UpdatedAt: time.Now()},
		{Title: "high", Labels: []string{"P1"}, UpdatedAt: time.Now()},
		{Title: "medium", Labels: []string{"P2"}, UpdatedAt: time.Now()},
		{Title: "none", Labels: nil, UpdatedAt: time.Now()},
	}

	// Apply the same sort as GetTriageQueue.
	sortTriageQueue(queue)

	expected := []string{"high", "medium", "low", "none"}
	for i, item := range queue {
		if item.Title != expected[i] {
			t.Errorf("queue[%d].Title = %q, want %q", i, item.Title, expected[i])
		}
	}
}

func TestCloseIssue(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPatch {
			t.Errorf("expected PATCH, got %s", r.Method)
		}
		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if r.Header.Get("Authorization") != "token test-token" {
			t.Error("missing or wrong Authorization header")
		}

		var body map[string]string
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}
		if body["state"] != "closed" {
			t.Errorf("expected state=closed, got %q", body["state"])
		}

		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(map[string]string{"state": "closed"})
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("issues-org1", "should-be-invalidated")

	err := c.CloseIssue(context.Background(), "test-token", "owner1", "repo1", 42)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify cache was invalidated.
	_, ok := c.getFromCache("issues-org1")
	if ok {
		t.Error("expected cache to be invalidated after CloseIssue")
	}
}

func TestSetIssueState(t *testing.T) {
	tests := []struct {
		name  string
		state string
	}{
		{"close", "closed"},
		{"reopen", "open"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if r.Method != http.MethodPatch {
					t.Errorf("expected PATCH, got %s", r.Method)
				}
				if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42" {
					t.Errorf("unexpected path: %s", r.URL.Path)
				}

				var body map[string]string
				if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
					t.Fatalf("failed to decode body: %v", err)
				}
				if body["state"] != tt.state {
					t.Errorf("expected state=%q, got %q", tt.state, body["state"])
				}

				w.WriteHeader(http.StatusOK)
				json.NewEncoder(w).Encode(map[string]string{"state": tt.state})
			}))
			defer server.Close()

			c := NewClient(server.URL)
			c.setCache("issues-org1", "should-be-invalidated")

			err := c.SetIssueState(context.Background(), "test-token", "owner1", "repo1", 42, tt.state)
			if err != nil {
				t.Fatalf("unexpected error: %v", err)
			}

			_, ok := c.getFromCache("issues-org1")
			if ok {
				t.Error("expected cache to be invalidated after SetIssueState")
			}
		})
	}
}

func TestAddComment(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		comment := map[string]interface{}{
			"id":         1,
			"body":       "test",
			"user":       map[string]string{"login": "testuser"},
			"created_at": "2026-03-26T12:00:00Z",
		}
		json.NewEncoder(w).Encode(comment)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	comment, err := c.AddComment(context.Background(), "test-token", "owner1", "repo1", 42, "test")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if comment.Body != "test" {
		t.Errorf("comment.Body = %q, want %q", comment.Body, "test")
	}
}

func TestPostComment(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			t.Errorf("expected POST, got %s", r.Method)
		}
		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/comments" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}

		var body map[string]string
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}
		if body["body"] != "test comment" {
			t.Errorf("expected body='test comment', got %q", body["body"])
		}

		comment := map[string]interface{}{
			"id":   1,
			"body": body["body"],
			"user": map[string]string{"login": "testuser"},
			"created_at": "2026-03-26T12:00:00Z",
		}
		json.NewEncoder(w).Encode(comment)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("issues-org1", "should-be-invalidated")

	comment, err := c.PostComment(context.Background(), "test-token", "owner1", "repo1", 42, "test comment")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if comment.Body != "test comment" {
		t.Errorf("comment.Body = %q, want %q", comment.Body, "test comment")
	}
	if comment.User != "testuser" {
		t.Errorf("comment.User = %q, want %q", comment.User, "testuser")
	}
	if comment.ID != 1 {
		t.Errorf("comment.ID = %d, want 1", comment.ID)
	}

	// Verify cache was invalidated.
	_, ok := c.getFromCache("issues-org1")
	if ok {
		t.Error("expected cache to be invalidated after PostComment")
	}
}

// sortTriageQueue is a test helper applying the same sort as GetTriageQueue.
func sortTriageQueue(queue []TriageItem) {
	for i := 0; i < len(queue); i++ {
		for j := i + 1; j < len(queue); j++ {
			pi := priorityScore(queue[i].Labels)
			pj := priorityScore(queue[j].Labels)
			if pj < pi || (pj == pi && queue[j].UpdatedAt.After(queue[i].UpdatedAt)) {
				queue[i], queue[j] = queue[j], queue[i]
			}
		}
	}
}

// --- Issue #122: Tests for ListOrgsAndRepos and CreateIssue ---

func TestListOrgsAndRepos(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/api/v1/user/orgs":
			orgs := []Org{
				{Name: "org1", FullName: "Organization 1"},
				{Name: "org2", FullName: "Organization 2"},
			}
			json.NewEncoder(w).Encode(orgs)
		case "/api/v1/orgs/org1/repos":
			repos := []Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a"},
				{ID: 2, Name: "repo-b", FullName: "org1/repo-b"},
			}
			json.NewEncoder(w).Encode(repos)
		case "/api/v1/orgs/org2/repos":
			repos := []Repo{
				{ID: 3, Name: "repo-c", FullName: "org2/repo-c"},
			}
			json.NewEncoder(w).Encode(repos)
		default:
			t.Errorf("unexpected request path: %s", r.URL.Path)
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	result, err := c.ListOrgsAndRepos(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if len(result) != 2 {
		t.Fatalf("got %d orgs, want 2", len(result))
	}
	if len(result["org1"]) != 2 {
		t.Errorf("org1 has %d repos, want 2", len(result["org1"]))
	}
	if len(result["org2"]) != 1 {
		t.Errorf("org2 has %d repos, want 1", len(result["org2"]))
	}
	if result["org1"][0].Name != "repo-a" {
		t.Errorf("org1 repos[0].Name = %q, want %q", result["org1"][0].Name, "repo-a")
	}
	if result["org2"][0].Name != "repo-c" {
		t.Errorf("org2 repos[0].Name = %q, want %q", result["org2"][0].Name, "repo-c")
	}
}

func TestListOrgsAndRepos_Cached(t *testing.T) {
	orgCallCount := 0
	repoCallCount := 0
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.URL.Path {
		case "/api/v1/user/orgs":
			orgCallCount++
			json.NewEncoder(w).Encode([]Org{{Name: "org1"}})
		case "/api/v1/orgs/org1/repos":
			repoCallCount++
			json.NewEncoder(w).Encode([]Repo{{ID: 1, Name: "repo1", FullName: "org1/repo1"}})
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)

	// First call populates cache.
	_, err := c.ListOrgsAndRepos(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("first call: %v", err)
	}

	// Second call should use cached orgs and repos (ListOrgs and ListOrgRepos both cache).
	_, err = c.ListOrgsAndRepos(context.Background(), "test-token")
	if err != nil {
		t.Fatalf("second call: %v", err)
	}

	if orgCallCount != 1 {
		t.Errorf("org endpoint called %d times, want 1 (cached)", orgCallCount)
	}
	if repoCallCount != 1 {
		t.Errorf("repo endpoint called %d times, want 1 (cached)", repoCallCount)
	}
}

func TestCreateIssue(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			t.Errorf("expected POST, got %s", r.Method)
		}
		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if r.Header.Get("Authorization") != "token test-token" {
			t.Error("missing or wrong Authorization header")
		}

		var body map[string]interface{}
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}
		if body["title"] != "Test Issue" {
			t.Errorf("expected title='Test Issue', got %q", body["title"])
		}
		if body["body"] != "Issue body here" {
			t.Errorf("expected body='Issue body here', got %q", body["body"])
		}

		issue := map[string]interface{}{
			"id":         1,
			"number":     42,
			"title":      body["title"],
			"body":       body["body"],
			"state":      "open",
			"created_at": "2026-03-28T00:00:00Z",
			"updated_at": "2026-03-28T00:00:00Z",
		}
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(issue)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	// Pre-populate cache to verify invalidation.
	c.setCache("issues-org1", "should-be-invalidated")

	issue, err := c.CreateIssue(context.Background(), "test-token", "owner1", "repo1", "Test Issue", "Issue body here", nil)
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if issue.Title != "Test Issue" {
		t.Errorf("issue.Title = %q, want %q", issue.Title, "Test Issue")
	}
	if issue.Number != 42 {
		t.Errorf("issue.Number = %d, want 42", issue.Number)
	}
	if issue.RepoOwner != "owner1" {
		t.Errorf("issue.RepoOwner = %q, want %q", issue.RepoOwner, "owner1")
	}
	if issue.RepoName != "repo1" {
		t.Errorf("issue.RepoName = %q, want %q", issue.RepoName, "repo1")
	}

	// Verify cache was invalidated.
	_, ok := c.getFromCache("issues-org1")
	if ok {
		t.Error("expected cache to be invalidated after CreateIssue")
	}
}

func TestCreateIssue_WithLabels(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body map[string]interface{}
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}

		labels, ok := body["labels"]
		if !ok {
			t.Error("expected labels in request body")
		}
		labelSlice, ok := labels.([]interface{})
		if !ok || len(labelSlice) != 2 {
			t.Errorf("expected 2 labels, got %v", labels)
		}

		issue := map[string]interface{}{
			"id":         2,
			"number":     43,
			"title":      body["title"],
			"body":       body["body"],
			"state":      "open",
			"created_at": "2026-03-28T00:00:00Z",
			"updated_at": "2026-03-28T00:00:00Z",
		}
		w.WriteHeader(http.StatusCreated)
		json.NewEncoder(w).Encode(issue)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	issue, err := c.CreateIssue(context.Background(), "test-token", "owner1", "repo1", "Labeled Issue", "body", []int64{10, 20})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if issue.Number != 43 {
		t.Errorf("issue.Number = %d, want 43", issue.Number)
	}
}

// --- Issue #121: Tests for ListAllIssues and ListAllPullRequests ---

// newFanOutServer creates a mock HTTP server that serves orgs, repos, issues, and PRs
// for testing the fan-out aggregation functions.
func newFanOutServer(t *testing.T) *httptest.Server {
	t.Helper()

	now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)

	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			repos := []Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
				{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			}
			json.NewEncoder(w).Encode(repos)

		case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
			issues := []Issue{
				{ID: 1, Number: 1, Title: "Issue A1", State: "open", UpdatedAt: now.Add(-1 * time.Hour)},
				{ID: 2, Number: 2, Title: "Issue A2", State: "open", UpdatedAt: now.Add(-3 * time.Hour)},
			}
			json.NewEncoder(w).Encode(issues)

		case r.URL.Path == "/api/v1/repos/org1/repo-b/issues":
			issues := []Issue{
				{ID: 3, Number: 1, Title: "Issue B1", State: "open", UpdatedAt: now.Add(-2 * time.Hour)},
			}
			json.NewEncoder(w).Encode(issues)

		case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
			prs := []PullRequest{
				{ID: 10, Number: 5, Title: "PR A1", State: "open", UpdatedAt: now.Add(-30 * time.Minute)},
			}
			json.NewEncoder(w).Encode(prs)

		case r.URL.Path == "/api/v1/repos/org1/repo-b/pulls":
			prs := []PullRequest{
				{ID: 11, Number: 6, Title: "PR B1", State: "open", UpdatedAt: now.Add(-10 * time.Minute)},
				{ID: 12, Number: 7, Title: "PR B2", State: "open", UpdatedAt: now.Add(-1 * time.Hour)},
			}
			json.NewEncoder(w).Encode(prs)

		default:
			t.Errorf("unexpected request path: %s", r.URL.Path)
			http.NotFound(w, r)
		}
	}))
}

func TestListAllIssues_Sorting(t *testing.T) {
	server := newFanOutServer(t)
	defer server.Close()

	c := NewClient(server.URL)
	// Pre-populate org repos cache to avoid needing the /user/orgs endpoint.
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
		{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	result, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if len(result.Issues) != 3 {
		t.Fatalf("got %d issues, want 3", len(result.Issues))
	}

	// Should be sorted by UpdatedAt descending (newest first).
	// Issue A1 (-1h), Issue B1 (-2h), Issue A2 (-3h).
	expected := []string{"Issue A1", "Issue B1", "Issue A2"}
	for i, title := range expected {
		if result.Issues[i].Title != title {
			t.Errorf("issues[%d].Title = %q, want %q", i, result.Issues[i].Title, title)
		}
	}
}

func TestListAllIssues_StateFilter(t *testing.T) {
	stateReceived := ""
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			repos := []Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			}
			json.NewEncoder(w).Encode(repos)
		case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
			stateReceived = r.URL.Query().Get("state")
			json.NewEncoder(w).Encode([]Issue{})
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	_, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "closed", 1, "", "")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if stateReceived != "closed" {
		t.Errorf("state query param = %q, want %q", stateReceived, "closed")
	}
}

func TestListAllIssues_DefaultState(t *testing.T) {
	stateReceived := ""
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			json.NewEncoder(w).Encode([]Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			})
		case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
			stateReceived = r.URL.Query().Get("state")
			json.NewEncoder(w).Encode([]Issue{})
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	_, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "", 1, "", "")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if stateReceived != "open" {
		t.Errorf("default state = %q, want %q", stateReceived, "open")
	}
}

func TestListAllIssues_RepoFilter(t *testing.T) {
	server := newFanOutServer(t)
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
		{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	result, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "repo-a")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Only issues from repo-a should be returned.
	if len(result.Issues) != 2 {
		t.Fatalf("got %d issues, want 2 (only from repo-a)", len(result.Issues))
	}
	for _, issue := range result.Issues {
		if issue.RepoName != "repo-a" {
			t.Errorf("issue %q has RepoName=%q, want repo-a", issue.Title, issue.RepoName)
		}
	}
}

func TestListAllIssues_Pagination(t *testing.T) {
	now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)

	// Create enough issues to test pagination (PageSize = 20).
	var issues []Issue
	for i := 0; i < 25; i++ {
		issues = append(issues, Issue{
			ID:        int64(i + 1),
			Number:    int64(i + 1),
			Title:     fmt.Sprintf("Issue %d", i+1),
			State:     "open",
			UpdatedAt: now.Add(time.Duration(-i) * time.Hour),
		})
	}

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			json.NewEncoder(w).Encode([]Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			})
		case r.URL.Path == "/api/v1/repos/org1/repo-a/issues":
			json.NewEncoder(w).Encode(issues)
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	// Page 1: should have 20 items with HasMore=true.
	page1, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
	if err != nil {
		t.Fatalf("page 1: %v", err)
	}
	if len(page1.Issues) != 20 {
		t.Errorf("page 1: got %d issues, want 20", len(page1.Issues))
	}
	if !page1.HasMore {
		t.Error("page 1: HasMore should be true")
	}

	// Page 2: should have 5 items with HasMore=false.
	page2, err := c.ListAllIssues(context.Background(), "test-token", []string{"org1"}, "open", 2, "", "")
	if err != nil {
		t.Fatalf("page 2: %v", err)
	}
	if len(page2.Issues) != 5 {
		t.Errorf("page 2: got %d issues, want 5", len(page2.Issues))
	}
	if page2.HasMore {
		t.Error("page 2: HasMore should be false")
	}
}

func TestListAllPullRequests_Sorting(t *testing.T) {
	server := newFanOutServer(t)
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
		{ID: 2, Name: "repo-b", FullName: "org1/repo-b", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	result, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	if len(result.Pulls) != 3 {
		t.Fatalf("got %d PRs, want 3", len(result.Pulls))
	}

	// Should be sorted by UpdatedAt descending.
	// PR B1 (-10m), PR A1 (-30m), PR B2 (-1h).
	expected := []string{"PR B1", "PR A1", "PR B2"}
	for i, title := range expected {
		if result.Pulls[i].Title != title {
			t.Errorf("pulls[%d].Title = %q, want %q", i, result.Pulls[i].Title, title)
		}
	}
}

func TestListAllPullRequests_StateFilter(t *testing.T) {
	stateReceived := ""
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			json.NewEncoder(w).Encode([]Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			})
		case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
			stateReceived = r.URL.Query().Get("state")
			json.NewEncoder(w).Encode([]PullRequest{})
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	_, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "closed", 1, "", "")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if stateReceived != "closed" {
		t.Errorf("state query param = %q, want %q", stateReceived, "closed")
	}
}

// --- Issue #127: Tests for ApplyLabel and SubmitReview ---

func TestApplyLabel(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			t.Errorf("expected POST, got %s", r.Method)
		}
		if r.URL.Path != "/api/v1/repos/owner1/repo1/issues/42/labels" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if r.Header.Get("Authorization") != "token test-token" {
			t.Error("missing or wrong Authorization header")
		}

		var body map[string]interface{}
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}
		labels, ok := body["labels"].([]interface{})
		if !ok {
			t.Fatalf("expected labels array, got %T", body["labels"])
		}
		if len(labels) != 2 {
			t.Errorf("expected 2 label IDs, got %d", len(labels))
		}
		// Verify the label IDs are correct (JSON numbers are float64).
		if labels[0].(float64) != 10 || labels[1].(float64) != 20 {
			t.Errorf("expected label IDs [10, 20], got %v", labels)
		}

		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode([]map[string]interface{}{
			{"id": 10, "name": "bug"},
			{"id": 20, "name": "enhancement"},
		})
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("issues-org1", "should-be-invalidated")

	err := c.ApplyLabel(context.Background(), "test-token", "owner1", "repo1", 42, []int64{10, 20})
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify cache was invalidated.
	_, ok := c.getFromCache("issues-org1")
	if ok {
		t.Error("expected cache to be invalidated after ApplyLabel")
	}
}

func TestApplyLabel_Error(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNotFound)
		fmt.Fprintln(w, `{"message":"issue not found"}`)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	err := c.ApplyLabel(context.Background(), "test-token", "owner1", "repo1", 999, []int64{10})
	if err == nil {
		t.Fatal("expected error for 404 response, got nil")
	}
	if !strings.Contains(err.Error(), "404") {
		t.Errorf("error should contain status code 404, got: %v", err)
	}
}

func TestSubmitReview(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			t.Errorf("expected POST, got %s", r.Method)
		}
		if r.URL.Path != "/api/v1/repos/owner1/repo1/pulls/7/reviews" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if r.Header.Get("Authorization") != "token test-token" {
			t.Error("missing or wrong Authorization header")
		}

		var body map[string]string
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			t.Fatalf("failed to decode body: %v", err)
		}
		if body["event"] != "APPROVED" {
			t.Errorf("expected event=APPROVED, got %q", body["event"])
		}
		if body["body"] != "Looks good!" {
			t.Errorf("expected body='Looks good!', got %q", body["body"])
		}

		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(map[string]interface{}{
			"id":    1,
			"state": "APPROVED",
			"body":  body["body"],
		})
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("pulls-org1", "should-be-invalidated")

	err := c.SubmitReview(context.Background(), "test-token", "owner1", "repo1", 7, "APPROVED", "Looks good!")
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}

	// Verify cache was invalidated.
	_, ok := c.getFromCache("pulls-org1")
	if ok {
		t.Error("expected cache to be invalidated after SubmitReview")
	}
}

func TestSubmitReview_Error(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusUnprocessableEntity)
		fmt.Fprintln(w, `{"message":"validation failed"}`)
	}))
	defer server.Close()

	c := NewClient(server.URL)
	err := c.SubmitReview(context.Background(), "test-token", "owner1", "repo1", 7, "INVALID", "")
	if err == nil {
		t.Fatal("expected error for 422 response, got nil")
	}
	if !strings.Contains(err.Error(), "422") {
		t.Errorf("error should contain status code 422, got: %v", err)
	}
}

func TestListAllPullRequests_Pagination(t *testing.T) {
	now := time.Date(2026, 3, 28, 12, 0, 0, 0, time.UTC)

	var prs []PullRequest
	for i := 0; i < 25; i++ {
		prs = append(prs, PullRequest{
			ID:        int64(i + 1),
			Number:    int64(i + 1),
			Title:     fmt.Sprintf("PR %d", i+1),
			State:     "open",
			UpdatedAt: now.Add(time.Duration(-i) * time.Hour),
		})
	}

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.URL.Path == "/api/v1/orgs/org1/repos":
			json.NewEncoder(w).Encode([]Repo{
				{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
					Login string `json:"login"`
				}{Login: "org1"}},
			})
		case r.URL.Path == "/api/v1/repos/org1/repo-a/pulls":
			json.NewEncoder(w).Encode(prs)
		default:
			http.NotFound(w, r)
		}
	}))
	defer server.Close()

	c := NewClient(server.URL)
	c.setCache("repos-org1", []Repo{
		{ID: 1, Name: "repo-a", FullName: "org1/repo-a", Owner: struct {
			Login string `json:"login"`
		}{Login: "org1"}},
	})

	page1, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 1, "", "")
	if err != nil {
		t.Fatalf("page 1: %v", err)
	}
	if len(page1.Pulls) != 20 {
		t.Errorf("page 1: got %d PRs, want 20", len(page1.Pulls))
	}
	if !page1.HasMore {
		t.Error("page 1: HasMore should be true")
	}

	page2, err := c.ListAllPullRequests(context.Background(), "test-token", []string{"org1"}, "open", 2, "", "")
	if err != nil {
		t.Fatalf("page 2: %v", err)
	}
	if len(page2.Pulls) != 5 {
		t.Errorf("page 2: got %d PRs, want 5", len(page2.Pulls))
	}
	if page2.HasMore {
		t.Error("page 2: HasMore should be false")
	}
}

func TestDoRequest_RateLimitRetry(t *testing.T) {
	attempts := 0
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		if attempts <= 2 {
			w.Header().Set("Retry-After", "0")
			w.WriteHeader(http.StatusTooManyRequests)
			return
		}
		w.WriteHeader(http.StatusOK)
		fmt.Fprint(w, `[{"username":"test-org"}]`)
	}))
	defer srv.Close()

	c := NewClient(srv.URL)
	c.maxRetries = 3
	c.baseRetryDelay = 1 * time.Millisecond // Fast for tests.

	resp, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
	if err != nil {
		t.Fatalf("expected success after retries, got: %v", err)
	}
	resp.Body.Close()

	if attempts != 3 {
		t.Errorf("expected 3 attempts, got %d", attempts)
	}
}

func TestDoRequest_RateLimitExhausted(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusTooManyRequests)
	}))
	defer srv.Close()

	c := NewClient(srv.URL)
	c.maxRetries = 2
	c.baseRetryDelay = 1 * time.Millisecond

	_, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
	if err == nil {
		t.Fatal("expected error after exhausting retries")
	}
	if !strings.Contains(err.Error(), "rate limit exceeded") {
		t.Errorf("expected rate limit error, got: %v", err)
	}
}

func TestDoRequest_RateLimitWithRetryAfterHeader(t *testing.T) {
	attempts := 0
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		if attempts == 1 {
			w.Header().Set("Retry-After", "1")
			w.WriteHeader(http.StatusTooManyRequests)
			return
		}
		w.WriteHeader(http.StatusOK)
		fmt.Fprint(w, `[]`)
	}))
	defer srv.Close()

	c := NewClient(srv.URL)
	c.maxRetries = 3
	c.baseRetryDelay = 1 * time.Millisecond

	start := time.Now()
	resp, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
	elapsed := time.Since(start)
	if err != nil {
		t.Fatalf("expected success, got: %v", err)
	}
	resp.Body.Close()

	// Retry-After: 1 means 1 second delay.
	if elapsed < 900*time.Millisecond {
		t.Errorf("expected at least ~1s delay from Retry-After header, got %v", elapsed)
	}
}

func TestDoRequest_RateLimitCancelledContext(t *testing.T) {
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Retry-After", "60")
		w.WriteHeader(http.StatusTooManyRequests)
	}))
	defer srv.Close()

	c := NewClient(srv.URL)
	c.maxRetries = 3
	c.baseRetryDelay = 1 * time.Millisecond

	ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
	defer cancel()

	_, err := c.doRequest(ctx, "test-token", "GET", "/user/orgs", nil)
	if err == nil {
		t.Fatal("expected error from cancelled context")
	}
}

func TestDoRequest_NonRateLimitErrorNotRetried(t *testing.T) {
	attempts := 0
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		attempts++
		w.WriteHeader(http.StatusForbidden)
		fmt.Fprint(w, `{"message":"forbidden"}`)
	}))
	defer srv.Close()

	c := NewClient(srv.URL)
	c.maxRetries = 3
	c.baseRetryDelay = 1 * time.Millisecond

	_, err := c.doRequest(context.Background(), "test-token", "GET", "/user/orgs", nil)
	if err == nil {
		t.Fatal("expected error for 403")
	}
	if attempts != 1 {
		t.Errorf("expected only 1 attempt for non-429 error, got %d", attempts)
	}
}

func TestRetryDelay_WithRetryAfterHeader(t *testing.T) {
	c := NewClient("https://example.com")
	c.baseRetryDelay = 1 * time.Second

	resp := &http.Response{Header: http.Header{}}
	resp.Header.Set("Retry-After", "5")

	delay := c.retryDelay(resp, 0)
	if delay != 5*time.Second {
		t.Errorf("expected 5s from Retry-After, got %v", delay)
	}
}

func TestRetryDelay_ExponentialBackoff(t *testing.T) {
	c := NewClient("https://example.com")
	c.baseRetryDelay = 1 * time.Second

	resp := &http.Response{Header: http.Header{}}

	tests := []struct {
		attempt int
		want    time.Duration
	}{
		{0, 1 * time.Second},
		{1, 2 * time.Second},
		{2, 4 * time.Second},
	}

	for _, tt := range tests {
		delay := c.retryDelay(resp, tt.attempt)
		if delay != tt.want {
			t.Errorf("attempt %d: got %v, want %v", tt.attempt, delay, tt.want)
		}
	}
}