package github

import (
	"context"
	"encoding/json"
	"io"
	"net/http"
	"strings"
	"sync"
	"testing"

	"github.com/github/github-mcp-server/internal/githubv4mock"
	gogithub "github.com/google/go-github/v89/github"
	"github.com/shurcooL/githubv4"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// Test_IssueRequest_EmptyFieldValues_OmittedByJSON pins the omitempty
// behaviour that makes the DELETE fallback necessary. If go-github ever drops
// the tag, the REST PATCH alone could clear field values and this test would
// fail to remind us.
func Test_IssueRequest_EmptyFieldValues_OmittedByJSON(t *testing.T) {
	t.Parallel()

	req := &gogithub.IssueRequest{
		Title:            gogithub.Ptr("still here"),
		IssueFieldValues: []*gogithub.IssueRequestFieldValue{},
	}
	body, err := json.Marshal(req)
	require.NoError(t, err)

	assert.NotContains(t, string(body), "issue_field_values",
		"empty IssueFieldValues should be dropped by omitempty — this is why the REST PATCH alone can't clear field values when the merged list ends up empty, and why we fall back to the dedicated DELETE endpoint")
	assert.Contains(t, string(body), `"title":"still here"`,
		"sanity check: other fields still serialise")
}

// Test_UpdateIssue_DeleteLastFieldValueCallsDeleteEndpoint covers the bug fix:
// when the kept set ends up empty, the PATCH alone can't clear the field
// (omitempty strips the empty slice), so UpdateIssue follows up with a DELETE
// to the dedicated endpoint.
func Test_UpdateIssue_DeleteLastFieldValueCallsDeleteEndpoint(t *testing.T) {
	t.Parallel()

	mockIssue := &gogithub.Issue{
		Number:  gogithub.Ptr(42),
		Title:   gogithub.Ptr("Test issue"),
		State:   gogithub.Ptr("open"),
		HTMLURL: gogithub.Ptr("https://github.com/owner/repo/issues/42"),
	}

	var (
		mu                sync.Mutex
		capturedPatchBody []byte
		deletePaths       []string
	)

	restClient := mustNewGHClient(t, MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
		PatchReposIssuesByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			body, _ := io.ReadAll(r.Body)
			mu.Lock()
			capturedPatchBody = body
			mu.Unlock()
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			_ = json.NewEncoder(w).Encode(mockIssue)
		},
		DeleteReposIssuesIssueFieldValueByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			mu.Lock()
			deletePaths = append(deletePaths, r.URL.Path)
			mu.Unlock()
			w.WriteHeader(http.StatusNoContent)
		},
	}))

	// Existing field values for the merge step. Returning the field we're
	// about to delete makes the kept list empty, triggering the fallback DELETE.
	existingFieldsResponse := githubv4mock.DataResponse(map[string]any{
		"repository": map[string]any{
			"issue": map[string]any{
				"issueFieldValues": map[string]any{
					"nodes": []any{
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field": map[string]any{
								"fullDatabaseId": "101",
								"name":           "Priority",
							},
							"value": "P1",
						},
					},
				},
			},
		},
	})

	gqlClient := githubv4.NewClient(githubv4mock.NewMockedHTTPClient(
		githubv4mock.NewQueryMatcher(
			struct {
				Repository struct {
					Issue struct {
						IssueFieldValues struct {
							Nodes []IssueFieldValueFragment
						} `graphql:"issueFieldValues(first: 25)"`
					} `graphql:"issue(number: $number)"`
				} `graphql:"repository(owner: $owner, name: $repo)"`
			}{},
			map[string]any{
				"owner":  githubv4.String("owner"),
				"repo":   githubv4.String("repo"),
				"number": githubv4.Int(42),
			},
			existingFieldsResponse,
		),
	))

	result, err := UpdateIssue(
		context.Background(),
		restClient,
		gqlClient,
		"owner", "repo", 42,
		"", "", nil, nil, 0, "",
		nil,
		[]int64{101},
		"", "", 0,
	)
	require.NoError(t, err)
	if result.IsError {
		t.Fatalf("expected non-error result, got: %s", getTextResult(t, result).Text)
	}

	mu.Lock()
	defer mu.Unlock()
	require.NotContains(t, string(capturedPatchBody), "issue_field_values",
		"REST PATCH body must not carry issue_field_values when the kept set is empty (PATCH body was: %s)", string(capturedPatchBody))
	require.Equal(t, []string{"/repos/owner/repo/issues/42/issue-field-values/101"}, deletePaths,
		"expected exactly one DELETE call to the dedicated endpoint for field id 101")
}

// Test_UpdateIssue_DeleteOneOfManyUsesSetSemantics: when the kept set is
// non-empty, set semantics handle the deletion implicitly via the PATCH — no
// DELETE follow-up needed.
func Test_UpdateIssue_DeleteOneOfManyUsesSetSemantics(t *testing.T) {
	t.Parallel()

	mockIssue := &gogithub.Issue{
		Number:  gogithub.Ptr(42),
		Title:   gogithub.Ptr("Test issue"),
		State:   gogithub.Ptr("open"),
		HTMLURL: gogithub.Ptr("https://github.com/owner/repo/issues/42"),
	}

	var (
		mu          sync.Mutex
		deletePaths []string
	)

	restClient := mustNewGHClient(t, MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
		PatchReposIssuesByOwnerByRepoByIssueNumber: expectRequestBody(t, map[string]any{
			"issue_field_values": []any{
				map[string]any{"field_id": float64(202), "value": "High"},
			},
		}).andThen(
			mockResponse(t, http.StatusOK, mockIssue),
		),
		DeleteReposIssuesIssueFieldValueByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			mu.Lock()
			deletePaths = append(deletePaths, r.URL.Path)
			mu.Unlock()
			w.WriteHeader(http.StatusNoContent)
		},
	}))

	existingFieldsResponse := githubv4mock.DataResponse(map[string]any{
		"repository": map[string]any{
			"issue": map[string]any{
				"issueFieldValues": map[string]any{
					"nodes": []any{
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field":      map[string]any{"fullDatabaseId": "101", "name": "Priority"},
							"value":      "P1",
						},
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field":      map[string]any{"fullDatabaseId": "202", "name": "Impact"},
							"value":      "High",
						},
					},
				},
			},
		},
	})

	gqlClient := githubv4.NewClient(githubv4mock.NewMockedHTTPClient(
		githubv4mock.NewQueryMatcher(
			struct {
				Repository struct {
					Issue struct {
						IssueFieldValues struct {
							Nodes []IssueFieldValueFragment
						} `graphql:"issueFieldValues(first: 25)"`
					} `graphql:"issue(number: $number)"`
				} `graphql:"repository(owner: $owner, name: $repo)"`
			}{},
			map[string]any{
				"owner":  githubv4.String("owner"),
				"repo":   githubv4.String("repo"),
				"number": githubv4.Int(42),
			},
			existingFieldsResponse,
		),
	))

	result, err := UpdateIssue(
		context.Background(),
		restClient,
		gqlClient,
		"owner", "repo", 42,
		"", "", nil, nil, 0, "",
		nil,
		[]int64{101},
		"", "", 0,
	)
	require.NoError(t, err)
	if result.IsError {
		t.Fatalf("expected non-error result, got: %s", getTextResult(t, result).Text)
	}

	mu.Lock()
	defer mu.Unlock()
	require.Empty(t, deletePaths,
		"no DELETE call should fire when the kept set is non-empty — the PATCH's set semantics clear the deleted field on the server side")
}

// Test_UpdateIssue_DeleteAbsentFieldIsNoOp: deleting a field that isn't set
// must not fire a DELETE (the endpoint would 404), preserving the pre-fix
// silent-no-op behaviour so idempotent delete:true callers don't break on
// retry.
func Test_UpdateIssue_DeleteAbsentFieldIsNoOp(t *testing.T) {
	t.Parallel()

	mockIssue := &gogithub.Issue{
		Number:  gogithub.Ptr(42),
		Title:   gogithub.Ptr("Test issue"),
		State:   gogithub.Ptr("open"),
		HTMLURL: gogithub.Ptr("https://github.com/owner/repo/issues/42"),
	}

	var (
		mu                sync.Mutex
		capturedPatchBody []byte
		deletePaths       []string
	)

	restClient := mustNewGHClient(t, MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
		PatchReposIssuesByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			body, _ := io.ReadAll(r.Body)
			mu.Lock()
			capturedPatchBody = body
			mu.Unlock()
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			_ = json.NewEncoder(w).Encode(mockIssue)
		},
		DeleteReposIssuesIssueFieldValueByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			mu.Lock()
			deletePaths = append(deletePaths, r.URL.Path)
			mu.Unlock()
			// Fail loudly: if we get here, the fix is wrong.
			w.WriteHeader(http.StatusNotFound)
		},
	}))

	// Issue has no field values at all.
	existingFieldsResponse := githubv4mock.DataResponse(map[string]any{
		"repository": map[string]any{
			"issue": map[string]any{
				"issueFieldValues": map[string]any{
					"nodes": []any{},
				},
			},
		},
	})

	gqlClient := githubv4.NewClient(githubv4mock.NewMockedHTTPClient(
		githubv4mock.NewQueryMatcher(
			struct {
				Repository struct {
					Issue struct {
						IssueFieldValues struct {
							Nodes []IssueFieldValueFragment
						} `graphql:"issueFieldValues(first: 25)"`
					} `graphql:"issue(number: $number)"`
				} `graphql:"repository(owner: $owner, name: $repo)"`
			}{},
			map[string]any{
				"owner":  githubv4.String("owner"),
				"repo":   githubv4.String("repo"),
				"number": githubv4.Int(42),
			},
			existingFieldsResponse,
		),
	))

	result, err := UpdateIssue(
		context.Background(),
		restClient,
		gqlClient,
		"owner", "repo", 42,
		"", "", nil, nil, 0, "",
		nil,
		[]int64{101}, // ask to delete a field that isn't set
		"", "", 0,
	)
	require.NoError(t, err)
	if result.IsError {
		t.Fatalf("expected non-error result, got: %s", getTextResult(t, result).Text)
	}

	mu.Lock()
	defer mu.Unlock()
	require.NotContains(t, string(capturedPatchBody), "issue_field_values",
		"PATCH body must not carry issue_field_values when nothing changed")
	require.Empty(t, deletePaths,
		"no DELETE call should fire for a field that isn't present on the issue — preserves the pre-fix silent-no-op behaviour and avoids a guaranteed 404")
}

// Test_UpdateIssue_DeleteFallbackContinuesOnPartialFailure: a failing DELETE
// must not short-circuit subsequent ones, and the error must name which IDs
// succeeded and which failed so callers can retry the right ones.
func Test_UpdateIssue_DeleteFallbackContinuesOnPartialFailure(t *testing.T) {
	t.Parallel()

	mockIssue := &gogithub.Issue{
		Number:  gogithub.Ptr(42),
		Title:   gogithub.Ptr("Test issue"),
		State:   gogithub.Ptr("open"),
		HTMLURL: gogithub.Ptr("https://github.com/owner/repo/issues/42"),
	}

	var (
		mu          sync.Mutex
		deletePaths []string
	)

	restClient := mustNewGHClient(t, MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
		PatchReposIssuesByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, _ *http.Request) {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			_ = json.NewEncoder(w).Encode(mockIssue)
		},
		DeleteReposIssuesIssueFieldValueByOwnerByRepoByIssueNumber: func(w http.ResponseWriter, r *http.Request) {
			mu.Lock()
			deletePaths = append(deletePaths, r.URL.Path)
			mu.Unlock()
			// Field 202 fails; 101 and 303 succeed. All three should fire and
			// the error must name 202 as failed and 101/303 as cleared.
			if strings.HasSuffix(r.URL.Path, "/202") {
				w.WriteHeader(http.StatusInternalServerError)
				_, _ = w.Write([]byte(`{"message":"simulated failure"}`))
				return
			}
			w.WriteHeader(http.StatusNoContent)
		},
	}))

	existingFieldsResponse := githubv4mock.DataResponse(map[string]any{
		"repository": map[string]any{
			"issue": map[string]any{
				"issueFieldValues": map[string]any{
					"nodes": []any{
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field":      map[string]any{"fullDatabaseId": "101", "name": "Priority"},
							"value":      "P1",
						},
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field":      map[string]any{"fullDatabaseId": "202", "name": "Visibility"},
							"value":      "High",
						},
						map[string]any{
							"__typename": "IssueFieldSingleSelectValue",
							"field":      map[string]any{"fullDatabaseId": "303", "name": "Impact"},
							"value":      "Critical",
						},
					},
				},
			},
		},
	})

	gqlClient := githubv4.NewClient(githubv4mock.NewMockedHTTPClient(
		githubv4mock.NewQueryMatcher(
			struct {
				Repository struct {
					Issue struct {
						IssueFieldValues struct {
							Nodes []IssueFieldValueFragment
						} `graphql:"issueFieldValues(first: 25)"`
					} `graphql:"issue(number: $number)"`
				} `graphql:"repository(owner: $owner, name: $repo)"`
			}{},
			map[string]any{
				"owner":  githubv4.String("owner"),
				"repo":   githubv4.String("repo"),
				"number": githubv4.Int(42),
			},
			existingFieldsResponse,
		),
	))

	result, err := UpdateIssue(
		context.Background(),
		restClient,
		gqlClient,
		"owner", "repo", 42,
		"", "", nil, nil, 0, "",
		nil,
		[]int64{101, 202, 303},
		"", "", 0,
	)
	require.NoError(t, err)
	require.True(t, result.IsError, "expected an error result because field 202 failed")

	mu.Lock()
	defer mu.Unlock()
	// All three DELETEs must have fired — the middle failure must not short-circuit the third.
	require.Len(t, deletePaths, 3,
		"all three DELETE calls should fire even though one fails; got paths: %v", deletePaths)

	resultText := getTextResult(t, result).Text
	require.Contains(t, resultText, "failed=[202]",
		"error must name the failed field ID so the caller can retry it; got: %s", resultText)
	require.Contains(t, resultText, "cleared=[101 303]",
		"error must name the cleared field IDs so the caller knows what's already done; got: %s", resultText)
}