package web

import (
	"encoding/json"
	"errors"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"time"

	"gitgud.io/mike/mpv-manager/pkg/constants"
	"gitgud.io/mike/mpv-manager/pkg/platform"
	"gitgud.io/mike/mpv-manager/pkg/version"
)

func TestMutatingRefreshAndShortcutHandlersRejectGET(t *testing.T) {
	server := &Server{}
	for path, handler := range map[string]http.HandlerFunc{
		"/api/apps/check-updates":     server.handleCheckAppUpdatesAPI,
		"/api/apps/refresh-installed": server.handleRefreshInstalledAppsAPI,
		"/api/settings/shortcut":      server.handleSettingsShortcutAPI,
	} {
		t.Run(path, func(t *testing.T) {
			response := httptest.NewRecorder()
			handler(response, httptest.NewRequest(http.MethodGet, path, nil))
			if response.Code != http.StatusMethodNotAllowed {
				t.Fatalf("status = %d, want %d", response.Code, http.StatusMethodNotAllowed)
			}
		})
	}
}

func TestInstallAndUpdateJobsRejectInvalidUIType(t *testing.T) {
	for name, handler := range map[string]func(*Server, http.ResponseWriter, *http.Request){
		"install": (*Server).handleInstallJobAPI,
		"update":  (*Server).handleAppUpdateJobAPI,
	} {
		t.Run(name, func(t *testing.T) {
			server := &Server{
				platform:   &platform.Platform{OSType: platform.Linux},
				jobManager: NewJobManager(),
			}
			body := `{"method_id":"` + constants.MethodModernZ + `","ui_type":"../../invalid"}`
			response := httptest.NewRecorder()
			handler(server, response, httptest.NewRequest(http.MethodPost, "/api/"+name+"/job", strings.NewReader(body)))
			if response.Code != http.StatusBadRequest {
				t.Fatalf("status = %d, want %d: %s", response.Code, http.StatusBadRequest, response.Body.String())
			}
			if jobs := server.jobManager.GetActiveJobs(); len(jobs) != 0 {
				t.Fatalf("invalid request created %d job(s)", len(jobs))
			}
		})
	}
}

func TestHandleModalAPI_Shutdown(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=shutdown", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	err := json.Unmarshal(w.Body.Bytes(), &config)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if config.Title != "Close MPV.Rocks Installer" {
		t.Errorf("Expected title 'Close MPV.Rocks Installer', got '%s'", config.Title)
	}

	if config.Danger != true {
		t.Errorf("Expected danger to be true for shutdown")
	}
}

func TestHandleModalAPI_UpdateManager(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=update-manager&version=1.2.3", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	err := json.Unmarshal(w.Body.Bytes(), &config)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if config.Title != "Update MPV Manager" {
		t.Errorf("Expected title 'Update MPV Manager', got '%s'", config.Title)
	}

	if config.Message != "Update MPV Manager to version 1.2.3?" {
		t.Errorf("Expected message 'Update MPV Manager to version 1.2.3?', got '%s'", config.Message)
	}

	if config.Danger != false {
		t.Errorf("Expected danger to be false for update manager")
	}
}

func TestHandleModalAPI_UpdateManagerSuccess(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=update-manager-success", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	err := json.Unmarshal(w.Body.Bytes(), &config)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if config.Title != "Update Ready" {
		t.Errorf("Expected title 'Update Ready', got '%s'", config.Title)
	}

	if config.ConfirmText != "Close & Exit" {
		t.Errorf("Expected confirm text 'Close & Exit', got '%s'", config.ConfirmText)
	}

	if config.CancelText != "" {
		t.Errorf("Expected cancel text to be empty, got '%s'", config.CancelText)
	}

	if config.ConfirmURL != "/api/shutdown" {
		t.Errorf("Expected confirm URL '/api/shutdown', got '%s'", config.ConfirmURL)
	}

	if config.Success != true {
		t.Errorf("Expected success to be true for update manager success modal")
	}

	if config.Danger != false {
		t.Errorf("Expected danger to be false for update manager success modal")
	}
}

func TestHandleModalAPI_RemoveFileAssociations(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=remove-file-associations", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	err := json.Unmarshal(w.Body.Bytes(), &config)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if config.Title != "Remove File Associations" {
		t.Errorf("Expected title 'Remove File Associations', got '%s'", config.Title)
	}

	if config.Danger != true {
		t.Errorf("Expected danger to be true for remove file associations")
	}
}

func TestHandleModalAPI_ResetConfig(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=reset-config", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Errorf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	err := json.Unmarshal(w.Body.Bytes(), &config)
	if err != nil {
		t.Fatalf("Failed to parse JSON: %v", err)
	}

	if config.Title != "Reset MPV Config" {
		t.Errorf("Expected title 'Reset MPV Config', got '%s'", config.Title)
	}

	if config.Danger != true {
		t.Errorf("Expected danger to be true for reset config")
	}
}

func TestHandleModalAPI_RestoreConfig(t *testing.T) {
	// Use a valid backup path that matches the expected pattern: YYYY-MM-DD-HHMMSS_mpv.conf
	// Note: This test will fail with 400 because the path doesn't actually exist in the filesystem,
	// but that's expected behavior for the validation. We're testing that the API handles validation correctly.
	server := &Server{}
	backupPath := "2026-01-31-123456_mpv.conf"
	req := httptest.NewRequest("GET", "/api/modal?type=restore-config&backup_path="+backupPath, nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	// The test now expects 400 because validation will fail (path doesn't exist on filesystem)
	// This is the correct behavior - we validate the path before proceeding
	if w.Code != http.StatusBadRequest {
		t.Errorf("Expected status Bad Request (400), got %d", w.Code)
	}
}

func TestHandleModalAPI_MissingType(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("Expected status Bad Request, got %d", w.Code)
	}
}

func TestHandleModalAPI_UnknownType(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=unknown-type", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("Expected status Bad Request, got %d", w.Code)
	}
}

func TestHandleModalAPI_MissingRestoreParams(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=restore-config", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusBadRequest {
		t.Errorf("Expected status Bad Request, got %d", w.Code)
	}
}

func TestModalConfig_JSONSerialization(t *testing.T) {
	config := ModalConfig{
		Title:       "Test Title",
		Message:     "Test Message",
		ConfirmText: "Confirm",
		CancelText:  "Cancel",
		ConfirmURL:  "/api/test",
		ConfirmData: `{"key": "value"}`,
		Danger:      true,
	}

	data, err := json.Marshal(config)
	if err != nil {
		t.Fatalf("Failed to marshal JSON: %v", err)
	}

	var decoded ModalConfig
	err = json.Unmarshal(data, &decoded)
	if err != nil {
		t.Fatalf("Failed to unmarshal JSON: %v", err)
	}

	if decoded.Title != config.Title {
		t.Errorf("Title mismatch: got %s, want %s", decoded.Title, config.Title)
	}

	if decoded.Danger != config.Danger {
		t.Errorf("Danger mismatch: got %v, want %v", decoded.Danger, config.Danger)
	}
}

// TestPOSTOnlyHandlers verifies that mutating endpoints reject GET with 405
func TestPOSTOnlyHandlers(t *testing.T) {
	server := &Server{}

	handlers := []struct {
		name    string
		handler http.HandlerFunc
	}{
		{"handleConfigResetAPI", server.handleConfigResetAPI},
		{"handleLogsClearAPI", server.handleLogsClearAPI},
		{"handleManagerUpdateAPI", server.handleManagerUpdateAPI},
		{"handleSettingsResetAPI", server.handleSettingsResetAPI},
		{"handleSettingsInstallPathAPI", server.handleSettingsInstallPathAPI},
		{"handleShortcutsCreateAPI", server.handleShortcutsCreateAPI},
		{"handleFileAssociationsSetupAPI", server.handleFileAssociationsSetupAPI},
		{"handleFileAssociationsRemoveAPI", server.handleFileAssociationsRemoveAPI},
	}

	for _, h := range handlers {
		t.Run(h.name, func(t *testing.T) {
			req := httptest.NewRequest("GET", "/api/test", nil)
			w := httptest.NewRecorder()

			h.handler(w, req)

			if w.Code != http.StatusMethodNotAllowed {
				t.Errorf("Expected status 405 for GET, got %d", w.Code)
			}
			if ct := w.Header().Get("Content-Type"); !strings.Contains(ct, "application/json") {
				t.Errorf("Expected JSON error response, got Content-Type %q", ct)
			}
		})
	}
}

func TestHandleModalAPI_UpdateManagerSanitizesVersion(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=update-manager&version=%3Cscript%3Ealert(1)%3C/script%3E", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("Expected status OK, got %d", w.Code)
	}

	var config ModalConfig
	if err := json.Unmarshal(w.Body.Bytes(), &config); err != nil {
		t.Fatalf("Failed to parse modal config JSON: %v", err)
	}

	// Invalid version strings fall back to "latest"
	if config.Message != "Update MPV Manager to version latest?" {
		t.Errorf("Expected sanitized version in message, got %q", config.Message)
	}
}

func TestHandleLanguagesSaveAPI_RejectsInjection(t *testing.T) {
	tests := []struct {
		name string
		body string
	}{
		{"audio newline injection", `{"audio_languages":["en\nscript=x"],"subtitle_languages":[]}`},
		{"subtitle newline injection", `{"audio_languages":[],"subtitle_languages":["en","es\nconfig=1"]}`},
		{"audio carriage return", `{"audio_languages":["pt\rBR"]}`},
		{"audio garbage", `{"audio_languages":["<script>"]}`},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			server := &Server{}
			req := httptest.NewRequest("POST", "/api/languages/save", strings.NewReader(tt.body))
			w := httptest.NewRecorder()

			server.handleLanguagesSaveAPI(w, req)

			if w.Code != http.StatusBadRequest {
				t.Errorf("Expected status 400 for injected language code, got %d", w.Code)
			}
		})
	}
}

// TestHandleModalAPI_UpdateManagerSuccessAutoClose verifies the success modal
// carries auto_close_seconds so the web UI counts down and closes the app by
// itself — the manager update only takes effect after a restart.
func TestHandleModalAPI_UpdateManagerSuccessAutoClose(t *testing.T) {
	server := &Server{}
	req := httptest.NewRequest("GET", "/api/modal?type=update-manager-success", nil)
	w := httptest.NewRecorder()

	server.handleModalAPI(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf("Expected status OK, got %d", w.Code)
	}

	var payload struct {
		ModalConfig
		AutoCloseSeconds int  `json:"auto_close_seconds"`
		Dismissible      bool `json:"dismissible"`
	}
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("Failed to parse modal config JSON: %v", err)
	}

	if payload.AutoCloseSeconds != updateManagerSuccessAutoCloseSeconds {
		t.Errorf("Expected auto_close_seconds %d, got %d", updateManagerSuccessAutoCloseSeconds, payload.AutoCloseSeconds)
	}

	// The countdown fires the confirm action, which must be the shutdown endpoint
	if payload.ConfirmURL != "/api/shutdown" {
		t.Errorf("Expected confirm URL '/api/shutdown', got '%s'", payload.ConfirmURL)
	}
	if payload.Dismissible {
		t.Error("Expected update success modal to remain visible until shutdown")
	}

	// The message must clearly state that a restart is required
	if !strings.Contains(strings.ToLower(payload.Message), "restart") {
		t.Errorf("Expected message to state a restart is required, got %q", payload.Message)
	}
}

// TestHandleModalAPI_NoAutoCloseForOtherModals ensures the auto-close field is
// gated on the update-manager-success modal only — no other modal type may
// shut the app down automatically.
func TestHandleModalAPI_NoAutoCloseForOtherModals(t *testing.T) {
	modalTypes := []string{"shutdown", "update-manager", "reset-config"}

	for _, modalType := range modalTypes {
		t.Run(modalType, func(t *testing.T) {
			server := &Server{}
			req := httptest.NewRequest("GET", "/api/modal?type="+modalType, nil)
			w := httptest.NewRecorder()

			server.handleModalAPI(w, req)

			if w.Code != http.StatusOK {
				t.Fatalf("Expected status OK, got %d", w.Code)
			}

			var raw map[string]interface{}
			if err := json.Unmarshal(w.Body.Bytes(), &raw); err != nil {
				t.Fatalf("Failed to parse modal config JSON: %v", err)
			}

			if _, exists := raw["auto_close_seconds"]; exists {
				t.Errorf("Modal type %q must not include auto_close_seconds", modalType)
			}
		})
	}
}

// TestHandleManagerUpdateAPI_SelfUpdateDisabled verifies the update handler
// rejects self-updates for package-manager builds. This is the only handler
// path reachable without network access (the success path requires
// version.CheckForUpdate, which talks to the release server).
func TestHandleManagerUpdateAPI_SelfUpdateDisabled(t *testing.T) {
	old := version.SelfUpdateDisabled
	version.SelfUpdateDisabled = "true"
	defer func() { version.SelfUpdateDisabled = old }()

	server := &Server{}
	req := httptest.NewRequest("POST", "/api/manager/update", nil)
	w := httptest.NewRecorder()

	server.handleManagerUpdateAPI(w, req)

	if w.Code != http.StatusForbidden {
		t.Errorf("Expected status 403 when self-update is disabled, got %d", w.Code)
	}

	var resp APIResponse
	if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
		t.Fatalf("Failed to parse error JSON: %v", err)
	}
	if resp.Status != "error" {
		t.Errorf("Expected status 'error', got '%s'", resp.Status)
	}
}

func TestHandleManagerUpdateAPI_BackgroundLifecycle(t *testing.T) {
	oldDisabled := version.SelfUpdateDisabled
	version.SelfUpdateDisabled = ""
	t.Cleanup(func() { version.SelfUpdateDisabled = oldDisabled })

	selected := &version.VersionCheckResult{
		LatestVersion:   "1.3.0",
		UpdateAvailable: true,
		URL:             "https://example.invalid/mpv-manager",
		BLAKE3:          strings.Repeat("a", 64),
	}
	prepareStarted := make(chan struct{})
	releasePrepare := make(chan struct{})
	shutdownCalled := make(chan struct{})
	checkCalls := 0
	var preparedSelection *version.VersionCheckResult
	preparedUpdate := &version.PreparedSelfUpdate{TransactionID: "test-transaction"}
	launchCalls := 0

	manager := NewJobManager()
	events := manager.RegisterClient()
	defer manager.UnregisterClient(events)
	server := &Server{
		jobManager: manager,
		managerUpdateCheck: func() *version.VersionCheckResult {
			checkCalls++
			return selected
		},
		executablePath: func() (string, error) { return "/tmp/mpv-manager", nil },
		managerUpdatePrepare: func(_ string, check *version.VersionCheckResult, callback version.SelfUpdateProgressCallback) (*version.PreparedSelfUpdate, error) {
			preparedSelection = check
			close(prepareStarted)
			<-releasePrepare
			callback(version.SelfUpdateProgress{Phase: version.SelfUpdateDownloading, Written: 50, Total: 100, Message: "Downloading update"})
			callback(version.SelfUpdateProgress{Phase: version.SelfUpdateVerifying, Message: "Verifying update"})
			callback(version.SelfUpdateProgress{Phase: version.SelfUpdateReadyToRestart, Message: "Update ready"})
			return preparedUpdate, nil
		},
		managerUpdateLaunch: func(prepared *version.PreparedSelfUpdate, mode string) error {
			launchCalls++
			if prepared != preparedUpdate || mode != "none" {
				t.Errorf("unexpected helper launch: prepared=%p mode=%q", prepared, mode)
			}
			return nil
		},
		managerUpdateShutdownDelay: time.Millisecond,
		shutdownHook: func() error {
			close(shutdownCalled)
			return nil
		},
	}

	req := httptest.NewRequest(http.MethodPost, "/api/manager/update", nil)
	w := httptest.NewRecorder()
	server.handleManagerUpdateAPI(w, req)

	if w.Code != http.StatusAccepted {
		t.Fatalf("Expected status 202, got %d: %s", w.Code, w.Body.String())
	}
	var response map[string]interface{}
	if err := json.Unmarshal(w.Body.Bytes(), &response); err != nil {
		t.Fatalf("Failed to decode response: %v", err)
	}
	if response["action"] != "job_started" || response["id"] == "" {
		t.Fatalf("Expected a background job response, got %#v", response)
	}

	select {
	case <-prepareStarted:
	case <-time.After(time.Second):
		t.Fatal("background update did not start")
	}
	if checkCalls != 1 {
		t.Fatalf("Expected exactly one manifest selection, got %d", checkCalls)
	}
	if preparedSelection != selected {
		t.Fatal("Updater did not receive the immutable selected release")
	}
	close(releasePrepare)

	select {
	case <-shutdownCalled:
	case <-time.After(time.Second):
		t.Fatal("successful update did not schedule backend-owned shutdown")
	}

	recent := manager.GetRecentJobs()
	if len(recent) != 1 {
		t.Fatalf("Expected one completed manager job, got %d", len(recent))
	}
	if recent[0].Status != "handed_off" || recent[0].Phase != string(version.SelfUpdateRestarting) {
		t.Fatalf("Unexpected terminal job: status=%q phase=%q", recent[0].Status, recent[0].Phase)
	}
	if launchCalls != 1 {
		t.Fatalf("Expected one updater helper handoff, got %d", launchCalls)
	}

	wantPhases := map[string]bool{
		string(version.SelfUpdateChecking):       false,
		string(version.SelfUpdateDownloading):    false,
		string(version.SelfUpdateVerifying):      false,
		string(version.SelfUpdateReadyToRestart): false,
		string(version.SelfUpdateRestarting):     false,
	}
	for {
		select {
		case event, ok := <-events:
			if !ok {
				for phase, observed := range wantPhases {
					if !observed {
						t.Errorf("Expected lifecycle phase %q", phase)
					}
				}
				return
			}
			if data, ok := event.Data.(JobProgressData); ok {
				if _, tracked := wantPhases[data.Phase]; tracked {
					wantPhases[data.Phase] = true
				}
			}
		default:
			for phase, observed := range wantPhases {
				if !observed {
					t.Errorf("Expected lifecycle phase %q", phase)
				}
			}
			return
		}
	}
}

func TestHandleManagerUpdateAPI_FailureDoesNotShutdown(t *testing.T) {
	oldDisabled := version.SelfUpdateDisabled
	version.SelfUpdateDisabled = ""
	t.Cleanup(func() { version.SelfUpdateDisabled = oldDisabled })

	shutdownCalled := make(chan struct{})
	manager := NewJobManager()
	server := &Server{
		jobManager: manager,
		managerUpdateCheck: func() *version.VersionCheckResult {
			return &version.VersionCheckResult{Error: errors.New("manifest unavailable")}
		},
		shutdownHook: func() error {
			close(shutdownCalled)
			return nil
		},
	}
	w := httptest.NewRecorder()
	server.handleManagerUpdateAPI(w, httptest.NewRequest(http.MethodPost, "/api/manager/update", nil))
	if w.Code != http.StatusAccepted {
		t.Fatalf("Expected status 202, got %d", w.Code)
	}

	deadline := time.Now().Add(time.Second)
	for len(manager.GetRecentJobs()) == 0 && time.Now().Before(deadline) {
		time.Sleep(time.Millisecond)
	}
	recent := manager.GetRecentJobs()
	if len(recent) != 1 || recent[0].Status != "error" || recent[0].Phase != string(version.SelfUpdateFailed) {
		t.Fatalf("Expected failed manager job, got %#v", recent)
	}
	select {
	case <-shutdownCalled:
		t.Fatal("failed update must not shut down the app")
	case <-time.After(20 * time.Millisecond):
	}
}

func TestHandleManagerUpdateAPI_HelperLaunchFailureDoesNotShutdown(t *testing.T) {
	oldDisabled := version.SelfUpdateDisabled
	version.SelfUpdateDisabled = ""
	t.Cleanup(func() { version.SelfUpdateDisabled = oldDisabled })

	shutdownCalled := make(chan struct{})
	manager := NewJobManager()
	server := &Server{
		jobManager: manager,
		managerUpdateCheck: func() *version.VersionCheckResult {
			return &version.VersionCheckResult{UpdateAvailable: true, LatestVersion: "1.3.0", URL: "https://example.invalid/manager"}
		},
		executablePath: func() (string, error) { return "/tmp/mpv-manager", nil },
		managerUpdatePrepare: func(string, *version.VersionCheckResult, version.SelfUpdateProgressCallback) (*version.PreparedSelfUpdate, error) {
			return &version.PreparedSelfUpdate{TransactionID: "prepared"}, nil
		},
		managerUpdateLaunch: func(*version.PreparedSelfUpdate, string) error {
			return errors.New("helper could not start")
		},
		shutdownHook: func() error {
			close(shutdownCalled)
			return nil
		},
	}
	w := httptest.NewRecorder()
	server.handleManagerUpdateAPI(w, httptest.NewRequest(http.MethodPost, "/api/manager/update", nil))
	if w.Code != http.StatusAccepted {
		t.Fatalf("Expected status 202, got %d", w.Code)
	}

	deadline := time.Now().Add(time.Second)
	for len(manager.GetRecentJobs()) == 0 && time.Now().Before(deadline) {
		time.Sleep(time.Millisecond)
	}
	recent := manager.GetRecentJobs()
	if len(recent) != 1 || recent[0].Status != "error" || !strings.Contains(recent[0].Error, "helper could not start") {
		t.Fatalf("Expected failed helper handoff job, got %#v", recent)
	}
	select {
	case <-shutdownCalled:
		t.Fatal("helper launch failure must not shut down the app")
	case <-time.After(20 * time.Millisecond):
	}
}

func TestHandleShutdownAPI_UsesGracefulServerOwner(t *testing.T) {
	shutdownCalled := make(chan struct{})
	server := &Server{
		shutdownRequestDelay: time.Millisecond,
		shutdownHook: func() error {
			close(shutdownCalled)
			return nil
		},
	}
	w := httptest.NewRecorder()
	server.handleShutdownAPI(w, httptest.NewRequest(http.MethodPost, "/api/shutdown", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("Expected status 200, got %d", w.Code)
	}
	select {
	case <-shutdownCalled:
	case <-time.After(time.Second):
		t.Fatal("shutdown request did not reach the graceful server owner")
	}
}