package homeplugins

import (
	"archive/zip"
	"bytes"
	"context"
	"crypto/sha256"
	"encoding/hex"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
	"time"

	"github.com/router-for-me/CLIProxyAPI/v7/internal/config"
	sdkpluginstore "github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginstore"
	"gopkg.in/yaml.v3"
)

type fakePluginRuntime struct {
	busy     bool
	unloaded []string
}

type fakePluginLoadInspector map[string]bool

func (r *fakePluginRuntime) PluginBusy(id string) bool {
	return r.busy
}

func (r *fakePluginRuntime) UnloadPlugin(id string) bool {
	r.unloaded = append(r.unloaded, id)
	r.busy = false
	return true
}

func (i fakePluginLoadInspector) PluginRegistered(id string) bool {
	return i[id]
}

type contextPluginRuntime struct {
	fakePluginRuntime
	unloadContext context.Context
}

func (r *contextPluginRuntime) UnloadPluginContext(ctx context.Context, id string) bool {
	r.unloadContext = ctx
	return r.UnloadPlugin(id)
}

func TestSyncPlatformInstallsManifestArtifact(t *testing.T) {
	root := t.TempDir()
	archiveData := makeZip(t, map[string]string{"sample.dll": "library-data"})
	archiveName := "sample_0.2.0_windows_amd64.zip"
	checksum := sha256.Sum256(archiveData)
	httpClient := mapHTTPDoer{
		"https://api.github.com/repos/owner/sample-plugin/releases/tags/v0.2.0": []byte(`{
			"tag_name": "v0.2.0",
			"assets": [
				{"name": "` + archiveName + `", "browser_download_url": "https://downloads.example/` + archiveName + `"},
				{"name": "checksums.txt", "browser_download_url": "https://downloads.example/checksums.txt"}
			]
		}`),
		"https://downloads.example/" + archiveName: archiveData,
		"https://downloads.example/checksums.txt":  []byte(hex.EncodeToString(checksum[:]) + "  " + archiveName + "\n"),
	}
	restore := replacePluginStoreClientForTest(httpClient)
	defer restore()

	if errSync := SyncPlatform(context.Background(), syncTestConfig(t, root), nil, Platform{GOOS: "windows", GOARCH: "amd64"}); errSync != nil {
		t.Fatalf("SyncPlatform() error = %v", errSync)
	}
	target := pluginTestPath(root, "windows", "amd64", "sample", "0.2.0")
	got, errRead := os.ReadFile(target)
	if errRead != nil {
		t.Fatalf("read target: %v", errRead)
	}
	if string(got) != "library-data" {
		t.Fatalf("target data = %q, want library-data", string(got))
	}
}

func TestSyncResolvedWithReportUsesTemporaryAuthAndClearsIt(t *testing.T) {
	root := t.TempDir()
	libraryName := "sample" + pluginExtension(runtime.GOOS)
	archiveData := makeZip(t, map[string]string{libraryName: "library-data"})
	checksum := sha256.Sum256(archiveData)
	var authenticated bool
	server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Header.Get("Authorization") != "Bearer temporary-token" {
			http.Error(w, "unauthorized", http.StatusUnauthorized)
			return
		}
		authenticated = true
		_, _ = w.Write(archiveData)
	}))
	t.Cleanup(server.Close)
	response, errUnauthenticated := server.Client().Get(server.URL + "/private/sample.zip")
	if errUnauthenticated != nil {
		t.Fatalf("unauthenticated GET error = %v", errUnauthenticated)
	}
	_ = response.Body.Close()
	if response.StatusCode != http.StatusUnauthorized {
		t.Fatalf("unauthenticated status = %d, want 401", response.StatusCode)
	}

	originalClient := newResolvedPluginStoreClient
	newResolvedPluginStoreClient = func(_ *config.Config, auth []sdkpluginstore.ResolvedAuthConfig, expiresAt time.Time) sdkpluginstore.Client {
		return sdkpluginstore.NewClientWithResolvedAuthExpiry(server.Client(), "", auth, expiresAt)
	}
	defer func() { newResolvedPluginStoreClient = originalClient }()
	token := sdkpluginstore.Secret("temporary-token")
	backing := token
	items := []sdkpluginstore.PluginSyncItem{{
		Manifest: sdkpluginstore.Manifest{
			SchemaVersion: sdkpluginstore.SchemaVersionV2,
			ID:            "sample",
			Version:       "1.0.0",
			Install: sdkpluginstore.InstallPlan{Type: sdkpluginstore.InstallTypeDirect, Artifacts: []sdkpluginstore.Artifact{{
				GOOS: runtime.GOOS, GOARCH: runtime.GOARCH, URL: server.URL + "/private/sample.zip",
				SHA256: hex.EncodeToString(checksum[:]), Size: int64(len(archiveData)),
			}}},
		},
		Auth: []sdkpluginstore.ResolvedAuthConfig{{
			Match: server.URL + "/private/", ApplyTo: []string{sdkpluginstore.RequestKindArtifact}, Type: sdkpluginstore.AuthTypeBearer, Token: token,
		}},
	}}
	enabled := true
	cfg := &config.Config{
		Home:    config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{Enabled: true, Dir: root, Configs: map[string]config.PluginInstanceConfig{"sample": {Enabled: &enabled}}},
	}

	report, errSync := SyncResolvedWithReport(context.Background(), cfg, items, time.Now().UTC().Add(time.Minute), map[string]string{"sample": "0.9.0"}, nil)
	if errSync != nil {
		t.Fatalf("SyncResolvedWithReport() error = %v", errSync)
	}
	if !authenticated || !report.OK || len(report.Plugins) != 1 || report.Plugins[0].Version != "1.0.0" {
		t.Fatalf("authenticated=%v report=%+v, want successful authenticated install", authenticated, report)
	}
	for index, value := range backing {
		if value != 0 {
			t.Fatalf("token byte %d = %d, want zero after sync", index, value)
		}
	}
	if items[0].Auth != nil {
		t.Fatalf("sync item retained auth references: %#v", items[0].Auth)
	}
	target := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "1.0.0")
	if got, errRead := os.ReadFile(target); errRead != nil || string(got) != "library-data" {
		t.Fatalf("installed plugin = %q, error = %v", got, errRead)
	}
}

func TestSyncResolvedWithReportIncludesUnchangedInstalledPlugins(t *testing.T) {
	root := t.TempDir()
	target := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "1.0.0")
	if errMkdir := os.MkdirAll(filepath.Dir(target), 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	if errWrite := os.WriteFile(target, []byte("plugin"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     root,
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `
enabled: true
store:
  id: sample
  name: Sample
  description: Adds sample support.
  author: owner
  version: 1.0.0
  release-tag: v1.0.0
  repository: https://github.com/owner/sample-plugin
`),
			},
		},
	}

	report, errSync := SyncResolvedWithReport(
		context.Background(),
		cfg,
		nil,
		time.Now().UTC().Add(time.Minute),
		map[string]string{"sample": "1.0.0"},
		nil,
	)
	if errSync != nil {
		t.Fatalf("SyncResolvedWithReport() error = %v", errSync)
	}
	if len(report.Plugins) != 1 || report.Plugins[0].ID != "sample" || report.Plugins[0].InstallStatus != pluginInstallStatusSkipped {
		t.Fatalf("report plugins = %+v, want unchanged installed sample", report.Plugins)
	}
	status := report.Plugins[0]
	if status.Path != target || status.ReleaseTag != "v1.0.0" || status.Repository != "https://github.com/owner/sample-plugin" || status.InstallType != sdkpluginstore.InstallTypeGitHubRelease {
		t.Fatalf("unchanged plugin status = %+v, want preserved path and manifest metadata", status)
	}
	if errLoad := MarkLoadResults(&report, fakePluginLoadInspector{}); errLoad == nil {
		t.Fatal("MarkLoadResults() error = nil, want installed plugin load failure")
	}
	if report.Plugins[0].LoadStatus != pluginLoadStatusFailed {
		t.Fatalf("load status = %q, want failed", report.Plugins[0].LoadStatus)
	}
}

func TestSyncResolvedWithReportDoesNotMixInstalledAndConfiguredMetadata(t *testing.T) {
	root := t.TempDir()
	target := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "1.0.0")
	if errMkdir := os.MkdirAll(filepath.Dir(target), 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	if errWrite := os.WriteFile(target, []byte("plugin"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     root,
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `
enabled: true
store:
  id: sample
  name: Sample
  description: Adds sample support.
  author: owner
  version: 2.0.0
  release-tag: v2.0.0
  repository: https://github.com/owner/sample-plugin-v2
`),
			},
		},
	}

	report, errSync := SyncResolvedWithReport(
		context.Background(),
		cfg,
		nil,
		time.Now().UTC().Add(time.Minute),
		map[string]string{"sample": "1.0.0"},
		nil,
	)
	if errSync != nil {
		t.Fatalf("SyncResolvedWithReport() error = %v", errSync)
	}
	if len(report.Plugins) != 1 {
		t.Fatalf("report plugins = %+v, want one installed sample", report.Plugins)
	}
	status := report.Plugins[0]
	if status.Version != "1.0.0" || status.Path != target {
		t.Fatalf("installed plugin status = %+v, want version 1.0.0 at %s", status, target)
	}
	if status.ReleaseTag != "" || status.Repository != "" || status.InstallType != "" {
		t.Fatalf("installed plugin status = %+v, want no metadata from configured version 2.0.0", status)
	}
}

func TestInstalledVersionsUsesPluginFilesOnDisk(t *testing.T) {
	root := t.TempDir()
	target := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "2.3.4")
	if errMkdir := os.MkdirAll(filepath.Dir(target), 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	if errWrite := os.WriteFile(target, []byte("plugin"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	cfg := &config.Config{Plugins: config.PluginsConfig{Dir: root, Configs: map[string]config.PluginInstanceConfig{"sample": {}}}}

	versions, errVersions := InstalledVersions(cfg)
	if errVersions != nil {
		t.Fatalf("InstalledVersions() error = %v", errVersions)
	}
	if versions["sample"] != "2.3.4" {
		t.Fatalf("InstalledVersions() = %#v, want sample 2.3.4", versions)
	}
}

func TestSyncPlatformWithReportRecordsSuccessfulInstall(t *testing.T) {
	root := t.TempDir()
	archiveData := makeZip(t, map[string]string{"sample.dll": "library-data"})
	archiveName := "sample_0.2.0_windows_amd64.zip"
	checksum := sha256.Sum256(archiveData)
	httpClient := mapHTTPDoer{
		"https://api.github.com/repos/owner/sample-plugin/releases/tags/v0.2.0": []byte(`{
			"tag_name": "v0.2.0",
			"assets": [
				{"name": "` + archiveName + `", "browser_download_url": "https://downloads.example/` + archiveName + `"},
				{"name": "checksums.txt", "browser_download_url": "https://downloads.example/checksums.txt"}
			]
		}`),
		"https://downloads.example/" + archiveName: archiveData,
		"https://downloads.example/checksums.txt":  []byte(hex.EncodeToString(checksum[:]) + "  " + archiveName + "\n"),
	}
	restore := replacePluginStoreClientForTest(httpClient)
	defer restore()

	report, errSync := SyncPlatformWithReport(context.Background(), syncTestConfig(t, root), nil, Platform{GOOS: "windows", GOARCH: "amd64"})
	if errSync != nil {
		t.Fatalf("SyncPlatformWithReport() error = %v", errSync)
	}
	if !report.OK || report.Status != pluginTaskStatusOK || report.Phase != pluginTaskPhaseInstall {
		t.Fatalf("report status = %+v, want successful install phase", report)
	}
	if len(report.Plugins) != 1 {
		t.Fatalf("report plugins len = %d, want 1", len(report.Plugins))
	}
	plugin := report.Plugins[0]
	if plugin.ID != "sample" || plugin.InstallStatus != pluginInstallStatusInstalled || plugin.Version != "0.2.0" {
		t.Fatalf("plugin report = %+v, want installed sample 0.2.0", plugin)
	}
	if wantPath := pluginTestPath(root, "windows", "amd64", "sample", "0.2.0"); plugin.Path != wantPath {
		t.Fatalf("plugin path = %q, want %q", plugin.Path, wantPath)
	}
}

func TestSyncPlatformWithReportRecordsSkippedIdenticalArtifact(t *testing.T) {
	root := t.TempDir()
	targetDir := filepath.Join(root, "windows", "amd64")
	if errMkdir := os.MkdirAll(targetDir, 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	target := filepath.Join(targetDir, "sample-v0.2.0.dll")
	if errWrite := os.WriteFile(target, []byte("library-data"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	archiveData := makeZip(t, map[string]string{"sample.dll": "library-data"})
	archiveName := "sample_0.2.0_windows_amd64.zip"
	checksum := sha256.Sum256(archiveData)
	httpClient := mapHTTPDoer{
		"https://api.github.com/repos/owner/sample-plugin/releases/tags/v0.2.0": []byte(`{
			"tag_name": "v0.2.0",
			"assets": [
				{"name": "` + archiveName + `", "browser_download_url": "https://downloads.example/` + archiveName + `"},
				{"name": "checksums.txt", "browser_download_url": "https://downloads.example/checksums.txt"}
			]
		}`),
		"https://downloads.example/" + archiveName: archiveData,
		"https://downloads.example/checksums.txt":  []byte(hex.EncodeToString(checksum[:]) + "  " + archiveName + "\n"),
	}
	restore := replacePluginStoreClientForTest(httpClient)
	defer restore()

	report, errSync := SyncPlatformWithReport(context.Background(), syncTestConfig(t, root), nil, Platform{GOOS: "windows", GOARCH: "amd64"})
	if errSync != nil {
		t.Fatalf("SyncPlatformWithReport() error = %v", errSync)
	}
	if !report.OK || len(report.Plugins) != 1 {
		t.Fatalf("report = %+v, want one successful skipped plugin", report)
	}
	plugin := report.Plugins[0]
	if plugin.ID != "sample" || plugin.InstallStatus != pluginInstallStatusSkipped || !plugin.Skipped {
		t.Fatalf("plugin report = %+v, want skipped identical sample", plugin)
	}
	if plugin.Path != target {
		t.Fatalf("plugin path = %q, want %q", plugin.Path, target)
	}
}

func TestSyncPlatformSkipsIdenticalBusyPlugin(t *testing.T) {
	root := t.TempDir()
	targetDir := filepath.Join(root, "windows", "amd64")
	if errMkdir := os.MkdirAll(targetDir, 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	target := filepath.Join(targetDir, "sample-v0.2.0.dll")
	if errWrite := os.WriteFile(target, []byte("library-data"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	archiveData := makeZip(t, map[string]string{"sample.dll": "library-data"})
	archiveName := "sample_0.2.0_windows_amd64.zip"
	checksum := sha256.Sum256(archiveData)
	httpClient := mapHTTPDoer{
		"https://api.github.com/repos/owner/sample-plugin/releases/tags/v0.2.0": []byte(`{
			"tag_name": "v0.2.0",
			"assets": [
				{"name": "` + archiveName + `", "browser_download_url": "https://downloads.example/` + archiveName + `"},
				{"name": "checksums.txt", "browser_download_url": "https://downloads.example/checksums.txt"}
			]
		}`),
		"https://downloads.example/" + archiveName: archiveData,
		"https://downloads.example/checksums.txt":  []byte(hex.EncodeToString(checksum[:]) + "  " + archiveName + "\n"),
	}
	restore := replacePluginStoreClientForTest(httpClient)
	defer restore()

	runtime := &fakePluginRuntime{busy: true}
	if errSync := SyncPlatform(context.Background(), syncTestConfig(t, root), runtime, Platform{GOOS: "windows", GOARCH: "amd64"}); errSync != nil {
		t.Fatalf("SyncPlatform() error = %v", errSync)
	}
	if len(runtime.unloaded) != 0 {
		t.Fatalf("UnloadPlugin() calls = %v, want none", runtime.unloaded)
	}
	got, errRead := os.ReadFile(target)
	if errRead != nil {
		t.Fatalf("read target: %v", errRead)
	}
	if string(got) != "library-data" {
		t.Fatalf("target data = %q, want library-data", string(got))
	}
}

func TestSyncPlatformSkipsConfigWithoutManifest(t *testing.T) {
	restore := replacePluginStoreClientForTest(mapHTTPDoer{})
	defer restore()

	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     t.TempDir(),
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `enabled: true`),
			},
		},
	}
	if errSync := SyncPlatform(context.Background(), cfg, nil, Platform{GOOS: "linux", GOARCH: "amd64"}); errSync != nil {
		t.Fatalf("SyncPlatform() error = %v", errSync)
	}
}

func TestSyncPlatformRejectsInvalidManifest(t *testing.T) {
	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     t.TempDir(),
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `
enabled: true
store:
  id: sample
`),
			},
		},
	}
	if errSync := SyncPlatform(context.Background(), cfg, nil, Platform{GOOS: "linux", GOARCH: "amd64"}); errSync == nil {
		t.Fatal("SyncPlatform() error = nil, want invalid manifest")
	}
}

func TestSyncPlatformWithReportRecordsInvalidManifest(t *testing.T) {
	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     t.TempDir(),
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `
enabled: true
store:
  id: sample
`),
			},
		},
	}
	report, errSync := SyncPlatformWithReport(context.Background(), cfg, nil, Platform{GOOS: "linux", GOARCH: "amd64"})
	if errSync == nil {
		t.Fatal("SyncPlatformWithReport() error = nil, want invalid manifest")
	}
	if report.OK || report.Status != pluginTaskStatusError || len(report.Plugins) != 1 {
		t.Fatalf("report = %+v, want one failed plugin", report)
	}
	if report.Plugins[0].ID != "sample" || report.Plugins[0].InstallStatus != pluginInstallStatusFailed || !strings.Contains(report.Plugins[0].Error, "invalid store manifest") {
		t.Fatalf("plugin report = %+v, want invalid manifest failure", report.Plugins[0])
	}
}

func TestMarkLoadResultsFailsWhenInstalledPluginDidNotLoad(t *testing.T) {
	report := SyncReport{
		Status:  pluginTaskStatusOK,
		OK:      true,
		Phase:   pluginTaskPhaseInstall,
		Plugins: []PluginInstallStatus{{ID: "sample", InstallStatus: pluginInstallStatusInstalled}},
	}

	errLoad := MarkLoadResults(&report, fakePluginLoadInspector{})
	if errLoad == nil {
		t.Fatal("MarkLoadResults() error = nil, want load failure")
	}
	if report.OK || report.Status != pluginTaskStatusError || report.Phase != pluginTaskPhaseLoad {
		t.Fatalf("report = %+v, want failed load phase", report)
	}
	if report.Plugins[0].LoadStatus != pluginLoadStatusFailed || !strings.Contains(report.Plugins[0].Error, "installed but not loaded") {
		t.Fatalf("plugin report = %+v, want load failure", report.Plugins[0])
	}
}

func TestMarkLoadResultsPreservesInstallFailure(t *testing.T) {
	report := SyncReport{
		Status:  pluginTaskStatusError,
		OK:      false,
		Phase:   pluginTaskPhaseInstall,
		Plugins: []PluginInstallStatus{{ID: "sample", InstallStatus: pluginInstallStatusFailed, Error: "install boom"}},
	}

	errLoad := MarkLoadResults(&report, fakePluginLoadInspector{"sample": true})
	if errLoad == nil {
		t.Fatal("MarkLoadResults() error = nil, want install failure to remain fatal")
	}
	if report.OK || report.Status != pluginTaskStatusError {
		t.Fatalf("report = %+v, want failed status", report)
	}
	if report.Plugins[0].LoadStatus != pluginInstallStatusSkipped {
		t.Fatalf("load status = %q, want skipped", report.Plugins[0].LoadStatus)
	}
}

func TestMarkLoadResultsPreservesGlobalSyncFailure(t *testing.T) {
	report := newSyncReport(Platform{GOOS: "linux", GOARCH: "amd64"})
	report.Plugins = append(report.Plugins, PluginInstallStatus{
		ID: "installed", InstallStatus: pluginInstallStatusInstalled,
	})
	errExpired := errors.New("home plugins: plugin sync response expired")
	finishReport(&report, errExpired)

	errLoad := MarkLoadResults(&report, fakePluginLoadInspector{"installed": true})
	if errLoad == nil || !strings.Contains(errLoad.Error(), "plugin sync response expired") {
		t.Fatalf("MarkLoadResults() error = %v, want preserved sync expiry", errLoad)
	}
	if report.OK || report.Status != pluginTaskStatusError || report.Phase != pluginTaskPhaseLoad {
		t.Fatalf("report = %+v, want failed load phase", report)
	}
	if !strings.Contains(report.Error, "plugin sync response expired") {
		t.Fatalf("report error = %q, want preserved sync expiry", report.Error)
	}
	if report.Plugins[0].LoadStatus != pluginLoadStatusLoaded {
		t.Fatalf("load status = %q, want loaded", report.Plugins[0].LoadStatus)
	}
}

func TestCompletedSyncReport(t *testing.T) {
	tests := []struct {
		name    string
		errSync error
		wantOK  bool
	}{
		{name: "success", wantOK: true},
		{name: "failure", errSync: errors.New("home plugins: inspect installed plugins: access denied")},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			report := CompletedSyncReport(Platform{GOOS: "linux", GOARCH: "amd64"}, tt.errSync)
			if report.OK != tt.wantOK || report.Task != pluginTaskName || report.FinishedAt.IsZero() {
				t.Fatalf("report = %+v, want completed plugin sync report with ok=%v", report, tt.wantOK)
			}
			if tt.errSync != nil && (report.Status != pluginTaskStatusError || report.Error != tt.errSync.Error()) {
				t.Fatalf("report = %+v, want error %q", report, tt.errSync.Error())
			}
		})
	}
}

func TestDeleteWithReportRejectsUnresolvedPluginsDir(t *testing.T) {
	workspace := t.TempDir()
	t.Setenv("HOME", "")
	t.Setenv("USERPROFILE", "")
	t.Chdir(workspace)

	literalPluginsDir := filepath.Join(workspace, "~", ".cli-proxy-api", "plugins")
	targetDir := filepath.Join(literalPluginsDir, runtime.GOOS, runtime.GOARCH)
	if errMkdir := os.MkdirAll(targetDir, 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll(%s) error = %v", targetDir, errMkdir)
	}
	target := filepath.Join(targetDir, "sample"+pluginExtension(runtime.GOOS))
	if errWrite := os.WriteFile(target, []byte("library-data"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile(%s) error = %v", target, errWrite)
	}
	cfg := &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Dir: "~/.cli-proxy-api/plugins",
		},
	}

	report := DeleteWithReport(context.Background(), cfg, nil, 41, "sample")

	if report.OK || report.Status != pluginTaskStatusError {
		t.Fatalf("report = %+v, want failed delete task", report)
	}
	if len(report.Plugins) != 1 || report.Plugins[0].InstallStatus != pluginInstallStatusFailed {
		t.Fatalf("plugin report = %+v, want failed status", report.Plugins)
	}
	if !strings.Contains(report.Plugins[0].Error, "resolve plugins directory") {
		t.Fatalf("plugin error = %q, want directory resolution error", report.Plugins[0].Error)
	}
	if _, errStat := os.Stat(target); errStat != nil {
		t.Fatalf("literal tilde target stat error = %v, want retained", errStat)
	}
}

func TestDeleteWithReportRemovesCurrentPlatformPlugin(t *testing.T) {
	root := t.TempDir()
	targetDir := filepath.Join(root, runtime.GOOS, runtime.GOARCH)
	if errMkdir := os.MkdirAll(targetDir, 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	target := filepath.Join(targetDir, "sample"+pluginExtension(runtime.GOOS))
	if errWrite := os.WriteFile(target, []byte("library-data"), 0o644); errWrite != nil {
		t.Fatalf("WriteFile() error = %v", errWrite)
	}
	runtimeHost := &fakePluginRuntime{busy: true}

	report := DeleteWithReport(context.Background(), syncTestConfig(t, root), runtimeHost, 42, "sample")
	if !report.OK || report.TaskID != 42 || report.Task != pluginDeleteTaskName || report.Phase != pluginTaskPhaseDelete {
		t.Fatalf("report = %+v, want successful delete task", report)
	}
	if len(runtimeHost.unloaded) != 1 || runtimeHost.unloaded[0] != "sample" {
		t.Fatalf("UnloadPlugin calls = %v, want sample", runtimeHost.unloaded)
	}
	if len(report.Plugins) != 1 || report.Plugins[0].InstallStatus != pluginInstallStatusDeleted || report.Plugins[0].Path != target {
		t.Fatalf("plugin report = %+v, want deleted target", report.Plugins)
	}
	if _, errStat := os.Stat(target); !os.IsNotExist(errStat) {
		t.Fatalf("target stat error = %v, want not exist", errStat)
	}
}

func TestDeleteWithReportRemovesAllCurrentPlatformPluginVersions(t *testing.T) {
	root := t.TempDir()
	targetDir := filepath.Join(root, runtime.GOOS, runtime.GOARCH)
	if errMkdir := os.MkdirAll(targetDir, 0o755); errMkdir != nil {
		t.Fatalf("MkdirAll() error = %v", errMkdir)
	}
	extension := pluginExtension(runtime.GOOS)
	olderTarget := filepath.Join(targetDir, "sample-v0.2.0"+extension)
	newerTarget := filepath.Join(targetDir, "sample-v0.3.0"+extension)
	otherTarget := filepath.Join(targetDir, "other-v0.3.0"+extension)
	for _, target := range []string{olderTarget, newerTarget, otherTarget} {
		if errWrite := os.WriteFile(target, []byte("library-data"), 0o644); errWrite != nil {
			t.Fatalf("WriteFile(%s) error = %v", target, errWrite)
		}
	}
	runtimeHost := &fakePluginRuntime{busy: true}

	report := DeleteWithReport(context.Background(), syncTestConfig(t, root), runtimeHost, 43, "sample")
	if !report.OK {
		t.Fatalf("report = %+v, want successful delete task", report)
	}
	if len(runtimeHost.unloaded) != 1 || runtimeHost.unloaded[0] != "sample" {
		t.Fatalf("UnloadPlugin calls = %v, want sample", runtimeHost.unloaded)
	}
	if len(report.Plugins) != 1 || report.Plugins[0].InstallStatus != pluginInstallStatusDeleted || report.Plugins[0].Path != newerTarget {
		t.Fatalf("plugin report = %+v, want deleted representative target %s", report.Plugins, newerTarget)
	}
	for _, target := range []string{olderTarget, newerTarget} {
		if _, errStat := os.Stat(target); !os.IsNotExist(errStat) {
			t.Fatalf("target %s stat error = %v, want not exist", target, errStat)
		}
	}
	if _, errStat := os.Stat(otherTarget); errStat != nil {
		t.Fatalf("other plugin stat error = %v, want retained", errStat)
	}
}

func TestDeleteWithReportStopsBeforeUnloadWhenContextCanceled(t *testing.T) {
	root := t.TempDir()
	path := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "1.0.0")
	if errMkdir := os.MkdirAll(filepath.Dir(path), 0o755); errMkdir != nil {
		t.Fatal(errMkdir)
	}
	if errWrite := os.WriteFile(path, []byte("plugin"), 0o644); errWrite != nil {
		t.Fatal(errWrite)
	}
	runtimeHost := &contextPluginRuntime{fakePluginRuntime: fakePluginRuntime{busy: true}}
	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	report := DeleteWithReport(ctx, syncTestConfig(t, root), runtimeHost, 44, "sample")

	if report.OK || !strings.Contains(report.Error, context.Canceled.Error()) {
		t.Fatalf("canceled delete report = %+v, want context cancellation", report)
	}
	if runtimeHost.unloadContext != nil || len(runtimeHost.unloaded) != 0 {
		t.Fatalf("canceled delete unloaded plugin: context=%v unloads=%v", runtimeHost.unloadContext, runtimeHost.unloaded)
	}
	if _, errStat := os.Stat(path); errStat != nil {
		t.Fatalf("canceled delete removed plugin artifact: %v", errStat)
	}
}

func TestDeleteWithReportUsesContextualUnload(t *testing.T) {
	root := t.TempDir()
	path := pluginTestPath(root, runtime.GOOS, runtime.GOARCH, "sample", "1.0.0")
	if errMkdir := os.MkdirAll(filepath.Dir(path), 0o755); errMkdir != nil {
		t.Fatal(errMkdir)
	}
	if errWrite := os.WriteFile(path, []byte("plugin"), 0o644); errWrite != nil {
		t.Fatal(errWrite)
	}
	runtimeHost := &contextPluginRuntime{fakePluginRuntime: fakePluginRuntime{busy: true}}
	ctx := context.WithValue(context.Background(), struct{}{}, "contextual")

	report := DeleteWithReport(ctx, syncTestConfig(t, root), runtimeHost, 45, "sample")

	if !report.OK {
		t.Fatalf("contextual delete report = %+v", report)
	}
	if runtimeHost.unloadContext != ctx || len(runtimeHost.unloaded) != 1 || runtimeHost.unloaded[0] != "sample" {
		t.Fatalf("contextual unload = context=%v unloads=%v", runtimeHost.unloadContext, runtimeHost.unloaded)
	}
}

func TestDeleteWithReportMissingPluginIsSuccess(t *testing.T) {
	report := DeleteWithReport(context.Background(), syncTestConfig(t, t.TempDir()), nil, 7, "missing")
	if !report.OK || report.Status != pluginTaskStatusOK {
		t.Fatalf("report = %+v, want missing plugin delete success", report)
	}
	if len(report.Plugins) != 1 || report.Plugins[0].InstallStatus != pluginInstallStatusMissing {
		t.Fatalf("plugin report = %+v, want missing status", report.Plugins)
	}
}

func syncTestConfig(t *testing.T, root string) *config.Config {
	t.Helper()
	return &config.Config{
		Home: config.HomeConfig{Enabled: true},
		Plugins: config.PluginsConfig{
			Enabled: true,
			Dir:     root,
			Configs: map[string]config.PluginInstanceConfig{
				"sample": pluginConfigFromYAML(t, `
enabled: true
store:
  id: sample
  name: Sample
  description: Adds sample support.
  author: owner
  version: 0.2.0
  release-tag: v0.2.0
  repository: https://github.com/owner/sample-plugin
`),
			},
		},
	}
}

func pluginTestPath(root string, goos string, goarch string, id string, version string) string {
	name := strings.TrimSpace(id)
	version = strings.TrimSpace(version)
	if version != "" {
		name += "-v" + version
	}
	return filepath.Join(root, goos, goarch, name+pluginExtension(goos))
}

func pluginConfigFromYAML(t *testing.T, text string) config.PluginInstanceConfig {
	t.Helper()
	var item config.PluginInstanceConfig
	if errUnmarshal := yaml.Unmarshal([]byte(text), &item); errUnmarshal != nil {
		t.Fatalf("unmarshal plugin config: %v", errUnmarshal)
	}
	return item
}

func replacePluginStoreClientForTest(httpClient sdkpluginstore.HTTPDoer) func() {
	previous := newPluginStoreClient
	newPluginStoreClient = func(cfg *config.Config) sdkpluginstore.Client {
		return sdkpluginstore.NewClient(httpClient, "")
	}
	return func() {
		newPluginStoreClient = previous
	}
}

func makeZip(t *testing.T, files map[string]string) []byte {
	t.Helper()

	var buffer bytes.Buffer
	writer := zip.NewWriter(&buffer)
	for name, content := range files {
		file, errCreate := writer.Create(name)
		if errCreate != nil {
			t.Fatalf("Create(%s) error = %v", name, errCreate)
		}
		if _, errWrite := file.Write([]byte(content)); errWrite != nil {
			t.Fatalf("Write(%s) error = %v", name, errWrite)
		}
	}
	if errClose := writer.Close(); errClose != nil {
		t.Fatalf("Close() error = %v", errClose)
	}
	return buffer.Bytes()
}

type mapHTTPDoer map[string][]byte

func (c mapHTTPDoer) Do(req *http.Request) (*http.Response, error) {
	body, ok := c[req.URL.String()]
	if !ok {
		return &http.Response{
			StatusCode: http.StatusNotFound,
			Body:       io.NopCloser(strings.NewReader("not found")),
			Header:     make(http.Header),
			Request:    req,
		}, nil
	}
	return &http.Response{
		StatusCode: http.StatusOK,
		Body:       io.NopCloser(bytes.NewReader(body)),
		Header:     make(http.Header),
		Request:    req,
	}, nil
}