package helpers

import (
	"bytes"
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/DingTalk-Real-AI/dingtalk-workspace-cli/internal/testseam"
)

// pull / push / sync 声明 Safety.Confirmation = user_required。本文件断言两件事：
//   1. 未确认（无 --yes、非 dry-run）时命令必须在任何写操作之前拒绝执行；
//   2. 明确确认（--yes）后才发出精确的工具调用并落盘。
// status 是只读叶子（not_required），不受确认门约束。

// ──────────────────────────────────────────────────────────
// 1. 未确认即拒绝，且一个写操作都不发生
// ──────────────────────────────────────────────────────────

func TestCrossPlatformCoverageDriveSyncFamily_refusesWithoutConfirmation(t *testing.T) {
	cases := []struct {
		name     string
		args     []string
		setup    func(t *testing.T, dir string)
		listJSON string
	}{
		{
			name: "pull",
			args: []string{"pull"},
			// 远端有文件、本地为空：即便是纯新增也必须先确认。
			listJSON: `{"result":{"items":[{"name":"a.txt","type":"file","fileId":"A","modifyTime":1}],"nextToken":""}}`,
		},
		{
			name:     "push",
			args:     []string{"push"},
			setup:    func(t *testing.T, dir string) { mustWrite(t, filepath.Join(dir, "a.txt"), "local") },
			listJSON: `{"result":{"items":[],"nextToken":""}}`,
		},
		{
			name:     "sync",
			args:     []string{"sync", "--quick", "--on-conflict", "remote-wins"},
			setup:    func(t *testing.T, dir string) { mustWrite(t, filepath.Join(dir, "a.txt"), "local") },
			listJSON: `{"result":{"items":[{"name":"b.txt","type":"file","fileId":"B","modifyTime":2}],"nextToken":""}}`,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			dir := t.TempDir()
			if tc.setup != nil {
				tc.setup(t, dir)
			}

			caller := &driveScriptCaller{reply: func(tool string, _ map[string]any, nth int) (string, error) {
				switch tool {
				case "list_files":
					if nth > 0 {
						return `{"result":{"items":[],"nextToken":""}}`, nil
					}
					return tc.listJSON, nil
				case "download_file":
					return `{"result":{"downloadUrl":"https://oss.example.com/get","headers":{}}}`, nil
				case "get_upload_info":
					return `{"result":{"resourceUrls":[{"url":"https://oss.example.com/put","headers":{}}],"uploadId":"U1"}}`, nil
				}
				return `{"result":{"fileId":"NEW"},"success":true}`, nil
			}}
			swapPullDownloadPath(t, func(_ context.Context, _ string, _ map[string]string, dest string) error {
				t.Error("no download may happen before confirmation")
				return os.WriteFile(dest, []byte("leaked"), 0o644)
			})
			testseam.Swap(t, &pushPutOpenedFile, func(context.Context, string, map[string]string, *os.File, int64) error {
				t.Error("no upload may happen before confirmation")
				return nil
			})

			args := append(append([]string{}, tc.args...), "--local-folder", dir, "--remote-folder", "ROOT")
			err := runDriveCmdWithoutConfirm(t, caller, args...)
			if err == nil {
				t.Fatal("expected the command to refuse without --yes")
			}
			if !strings.Contains(err.Error(), "--yes") {
				t.Errorf("error must tell the user to confirm with --yes, got %q", err.Error())
			}
			// 拒绝必须发生在任何写工具调用之前。
			for _, tool := range []string{"download_file", "get_upload_info", "create_folder", "ln"} {
				if got := caller.callsFor(tool); len(got) != 0 {
					t.Errorf("%s must not be called before confirmation, got %v", tool, got)
				}
			}
			// 本地目录不得新增任何文件。
			entries, _ := os.ReadDir(dir)
			for _, e := range entries {
				if e.Name() == "b.txt" || e.Name() == "a.txt" && tc.name == "pull" {
					t.Errorf("%s must not be materialized before confirmation", e.Name())
				}
			}
		})
	}
}

// --dry-run 无需 --yes 也能预览：这是让用户看清将发生什么的必要出口，且不写任何东西。
func TestCrossPlatformCoverageDriveSyncFamily_dryRunNeedsNoConfirmation(t *testing.T) {
	dir := t.TempDir()
	mustWrite(t, filepath.Join(dir, "local.txt"), "l")

	caller := syncCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"remote.txt","type":"file","fileId":"R","modifyTime":2}],"nextToken":""}}`,
	})
	caller.dryRun = true
	swapPullDownloadPath(t, func(context.Context, string, map[string]string, string) error {
		t.Error("dry-run must not download")
		return nil
	})
	testseam.Swap(t, &pushPutOpenedFile, func(context.Context, string, map[string]string, *os.File, int64) error {
		t.Error("dry-run must not upload")
		return nil
	})

	if err := runDriveCmdWithoutConfirm(t, caller, "sync",
		"--local-folder", dir, "--remote-folder", "ROOT", "--quick"); err != nil {
		t.Fatalf("dry-run must not require confirmation: %v", err)
	}
	if _, err := os.Stat(filepath.Join(dir, "remote.txt")); !os.IsNotExist(err) {
		t.Error("dry-run must not write remote files locally")
	}
}

func TestCrossPlatformCoverageDrivePull_dryRunPlansWithoutLocalWrites(t *testing.T) {
	parent := t.TempDir()
	target := filepath.Join(parent, "not-created")
	caller := pullListingCaller(`{"name":"remote.txt","type":"file","fileId":"R","modifyTime":2}`)
	caller.dryRun = true
	swapPullDownloadPath(t, func(context.Context, string, map[string]string, string) error {
		t.Error("dry-run must not download")
		return nil
	})

	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
	testseam.Swap(t, &os.Args, []string{"dws", "drive", "pull"})
	cmd := findDriveSubcommand(t, "pull")
	mustSetFlags(t, cmd, map[string]string{"local-folder": target, "remote-folder": "ROOT"})
	if err := cmd.RunE(cmd, nil); err != nil {
		t.Fatalf("dry-run pull: %v", err)
	}
	if _, err := os.Stat(target); !os.IsNotExist(err) {
		t.Fatalf("dry-run must not create local root: %v", err)
	}
	if got := len(caller.callsFor("download_file")); got != 0 {
		t.Fatalf("download_file calls = %d, want 0", got)
	}
	if text := out.String(); !strings.Contains(text, `"dry_run": true`) || !strings.Contains(text, `"remote.txt"`) {
		t.Fatalf("missing pull plan: %s", text)
	}
}

func TestCrossPlatformCoverageDrivePush_dryRunPlansWithoutRemoteWrites(t *testing.T) {
	dir := t.TempDir()
	if err := os.MkdirAll(filepath.Join(dir, "sub"), 0o755); err != nil {
		t.Fatal(err)
	}
	mustWrite(t, filepath.Join(dir, "sub", "local.txt"), "local")
	caller := syncCaller(nil)
	caller.dryRun = true
	testseam.Swap(t, &pushPutOpenedFile, func(context.Context, string, map[string]string, *os.File, int64) error {
		t.Error("dry-run must not upload")
		return nil
	})

	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
	testseam.Swap(t, &os.Args, []string{"dws", "drive", "push"})
	cmd := findDriveSubcommand(t, "push")
	mustSetFlags(t, cmd, map[string]string{"local-folder": dir, "remote-folder": "ROOT"})
	if err := cmd.RunE(cmd, nil); err != nil {
		t.Fatalf("dry-run push: %v", err)
	}
	for _, tool := range []string{"create_folder", "get_upload_info", "commit_upload"} {
		if got := len(caller.callsFor(tool)); got != 0 {
			t.Fatalf("%s calls = %d, want 0", tool, got)
		}
	}
	if text := out.String(); !strings.Contains(text, `"dry_run": true`) || !strings.Contains(text, `"sub/local.txt"`) {
		t.Fatalf("missing push plan: %s", text)
	}
}

func TestCrossPlatformCoverageDrivePushDryRunPublishesPlannedNotExecutedActions(t *testing.T) {
	dir := t.TempDir()
	mustWrite(t, filepath.Join(dir, "local.txt"), "local")
	caller := syncCaller(nil)
	caller.dryRun = true

	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
	testseam.Swap(t, &os.Args, []string{"dws", "drive", "push"})
	cmd := findDriveSubcommand(t, "push")
	mustSetFlags(t, cmd, map[string]string{"local-folder": dir, "remote-folder": "ROOT"})
	if err := cmd.RunE(cmd, nil); err != nil {
		t.Fatalf("dry-run push: %v", err)
	}

	var payload map[string]any
	if err := json.Unmarshal(out.Bytes(), &payload); err != nil {
		t.Fatalf("decode dry-run push: %v\n%s", err, out.String())
	}
	plan := payload["plan"].(map[string]any)
	summary := plan["summary"].(map[string]any)
	if summary["uploaded"] != float64(0) || summary["planned_uploads"] != float64(1) {
		t.Fatalf("dry-run summary reports execution instead of a plan: %#v", summary)
	}
	items := plan["items"].([]any)
	if got := items[0].(map[string]any)["action"]; got != "planned_upload" {
		t.Fatalf("dry-run action = %v, want planned_upload", got)
	}
}

func TestCrossPlatformCoverageDriveSyncDryRunReturnsRealActionPlan(t *testing.T) {
	dir := t.TempDir()
	mustWrite(t, filepath.Join(dir, "local.txt"), "local")
	mustWrite(t, filepath.Join(dir, "shared.txt"), "shared")
	if err := os.Mkdir(filepath.Join(dir, "empty-folder"), 0o755); err != nil {
		t.Fatal(err)
	}
	caller := syncCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"remote.txt","type":"file","fileId":"R","modifyTime":2},{"name":"shared.txt","type":"file","fileId":"S","modifyTime":2}],"nextToken":""}}`,
	})
	caller.dryRun = true

	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Caller: caller, Out: &Formatter{w: &out}})
	testseam.Swap(t, &os.Args, []string{"dws", "drive", "sync"})
	cmd := findDriveSubcommand(t, "sync")
	mustSetFlags(t, cmd, map[string]string{"local-folder": dir, "remote-folder": "ROOT"})
	if err := cmd.RunE(cmd, nil); err != nil {
		t.Fatalf("dry-run sync: %v", err)
	}

	var payload driveSyncDryRunResult
	if err := json.Unmarshal(out.Bytes(), &payload); err != nil {
		t.Fatalf("decode dry-run sync: %v\n%s", err, out.String())
	}
	if payload.Executed || payload.Plan.Summary.Pulled != 0 || payload.Plan.Summary.Pushed != 0 || payload.Plan.Summary.Skipped != 0 {
		t.Fatalf("dry-run plan summary = %+v, executed=%v", payload.Plan.Summary, payload.Executed)
	}
	if payload.Plan.Summary.PlannedPulls != 1 || payload.Plan.Summary.PlannedPushes != 1 ||
		payload.Plan.Summary.PlannedSkips != 1 || payload.Plan.Summary.PlannedFolders != 1 {
		t.Fatalf("dry-run planned summary = %+v", payload.Plan.Summary)
	}
	actions := map[string]int{}
	for _, item := range payload.Plan.Items {
		actions[item.Action]++
	}
	if len(payload.Plan.Items) != 4 || actions["planned_download"] != 1 || actions["planned_upload"] != 1 ||
		actions["planned_skip"] != 1 || actions["planned_folder_create"] != 1 {
		t.Fatalf("dry-run action plan = %#v", payload.Plan.Items)
	}
	for _, tool := range []string{"download_file", "get_upload_info", "commit_upload", "create_folder"} {
		if calls := caller.callsFor(tool); len(calls) != 0 {
			t.Fatalf("dry-run called %s: %#v", tool, calls)
		}
	}
}

func TestCrossPlatformCoverageDriveSyncDryRunPlanBranchMatrix(t *testing.T) {
	remoteFiles := map[string]*remoteFile{
		"conflict.txt": {FileID: "remote-file"},
	}
	remoteFolders := map[string]string{"": "root", "existing": "existing-id"}
	localDirs := []string{"existing", "new", "missing/child"}
	localFiles := map[string]localPushFile{"conflict.txt": {}, "new/file.txt": {}}

	for _, policy := range []string{syncConflictRemoteWins, syncConflictLocalWins, syncConflictKeepBoth, syncConflictAsk, syncConflictSkip} {
		t.Run(policy, func(t *testing.T) {
			res := &driveSyncResult{}
			appendDriveSyncDryRunPlan(res, driveSyncDryRunPlanInput{
				LocalDirs: localDirs, LocalByRel: localFiles, RemoteFiles: remoteFiles, RemoteFolders: remoteFolders,
				NewLocal: []string{"new/file.txt", "missing/file.txt"}, NewRemote: []string{"remote.txt"},
				Modified: []string{"conflict.txt"}, Unknown: []string{"unknown.txt"}, OnConflict: policy,
			})
			if res.Summary.PlannedSkips == 0 || res.Summary.PlannedFolders == 0 || res.Summary.PlannedPulls == 0 || res.Summary.Failed != 2 {
				t.Fatalf("dry-run plan summary for %s = %#v; items=%#v", policy, res.Summary, res.Items)
			}
			switch policy {
			case syncConflictRemoteWins, syncConflictKeepBoth:
				if res.Summary.PlannedPulls < 2 {
					t.Fatalf("%s planned pulls = %d", policy, res.Summary.PlannedPulls)
				}
			case syncConflictLocalWins:
				if res.Summary.PlannedPushes < 2 {
					t.Fatalf("local wins planned pushes = %d", res.Summary.PlannedPushes)
				}
			}
		})
	}
}

func TestCrossPlatformCoverageDrivePull_dryRunPlanBranches(t *testing.T) {
	root := t.TempDir()
	mustWrite(t, filepath.Join(root, "skip.txt"), "skip")
	mustWrite(t, filepath.Join(root, "smart.txt"), "smart")
	remote := map[string]*remoteFile{
		"A.txt":     {RelPath: "A.txt"},
		"a.txt":     {RelPath: "a.txt"},
		"../escape": {RelPath: "../escape"},
		"skip.txt":  {RelPath: "skip.txt"},
		"smart.txt": {RelPath: "smart.txt", ModifiedTime: 1, ModifiedTimeValid: true},
		"new.txt":   {RelPath: "new.txt"},
	}
	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Out: &Formatter{w: &out}})

	if err := printDrivePullDryRun(root, ifExistsSkip, remote,
		[]string{"A.txt", "a.txt", "../escape", "skip.txt", "new.txt"}, true); err != nil {
		t.Fatalf("skip plan: %v", err)
	}
	if text := out.String(); !strings.Contains(text, pullActionFailed) || !strings.Contains(text, pullActionSkipped) || !strings.Contains(text, pullActionDownloaded) {
		t.Fatalf("skip plan did not cover failed/skipped/downloaded: %s", text)
	}
	out.Reset()
	if err := printDrivePullDryRun(root, ifExistsSmart, remote, []string{"smart.txt"}, false); err != nil {
		t.Fatalf("smart plan: %v", err)
	}
	if !strings.Contains(out.String(), pullActionSkipped) {
		t.Fatalf("smart plan must skip newer local file: %s", out.String())
	}
}

func TestCrossPlatformCoverageDrivePush_dryRunPlanBranches(t *testing.T) {
	var out bytes.Buffer
	testseam.Swap(t, &deps, &Deps{Out: &Formatter{w: &out}})
	remoteFolders := map[string]string{"": "ROOT", "existing": "EXISTING"}
	remoteFiles := map[string]*remoteFile{
		"skip.txt":            {RelPath: "skip.txt"},
		"smart-skip.txt":      {RelPath: "smart-skip.txt", ModifiedTime: 20, ModifiedTimeValid: true},
		"smart-overwrite.txt": {RelPath: "smart-overwrite.txt", ModifiedTime: 1, ModifiedTimeValid: true},
		"overwrite.txt":       {RelPath: "overwrite.txt"},
	}
	files := func(paths ...string) []localPushFile {
		result := make([]localPushFile, 0, len(paths))
		for _, path := range paths {
			result = append(result, localPushFile{RelPath: path, Size: 1, ModTimeMillis: 10})
		}
		return result
	}

	if err := printDrivePushDryRun(ifExistsSkip, remoteFiles, remoteFolders,
		[]string{"existing", "missing/child"}, files("orphan/a.txt", "skip.txt", "new.txt")); err != nil {
		t.Fatalf("skip plan: %v", err)
	}
	if text := out.String(); !strings.Contains(text, pushActionFailed) || !strings.Contains(text, pushActionPlannedSkip) || !strings.Contains(text, pushActionPlannedUpload) {
		t.Fatalf("skip plan did not cover failed/skipped/uploaded: %s", text)
	}
	out.Reset()
	if err := printDrivePushDryRun(ifExistsSmart, remoteFiles, remoteFolders, nil,
		files("smart-skip.txt", "smart-overwrite.txt")); err != nil {
		t.Fatalf("smart plan: %v", err)
	}
	if text := out.String(); !strings.Contains(text, pushActionPlannedSkip) || !strings.Contains(text, pushActionPlannedOverwrite) {
		t.Fatalf("smart plan did not cover skip/overwrite: %s", text)
	}
	out.Reset()
	if err := printDrivePushDryRun(ifExistsOverwrite, remoteFiles, remoteFolders, nil, files("overwrite.txt")); err != nil {
		t.Fatalf("overwrite plan: %v", err)
	}
	if !strings.Contains(out.String(), pushActionPlannedOverwrite) {
		t.Fatalf("overwrite plan must overwrite existing file: %s", out.String())
	}
}

// ──────────────────────────────────────────────────────────
// 2. 明确确认后才发出精确的工具调用
// ──────────────────────────────────────────────────────────

// sync --on-conflict remote-wins --yes：确认后只下载指定远端文件，且不上传。
func TestCrossPlatformCoverageDriveSync_confirmedRemoteWinsIssuesExactCalls(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "f.txt")
	mustWrite(t, p, "local-version")
	local := readFileMTimeMillis(t, p)
	withSyncTransport(t, "remote-version")

	caller := syncCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"f.txt","type":"file","fileId":"F","modifyTime":` +
			differentMillis(local) + `}],"nextToken":""}}`,
	})
	if err := runDriveCmdWithoutConfirm(t, caller, "sync", "--local-folder", dir,
		"--remote-folder", "ROOT", "--quick", "--on-conflict", "remote-wins", "--yes"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	dl := caller.callsFor("download_file")
	if len(dl) != 1 || dl[0].args["fileId"] != "F" {
		t.Fatalf("expected exactly one download_file(fileId=F), got %v", dl)
	}
	if up := caller.callsFor("get_upload_info"); len(up) != 0 {
		t.Errorf("remote-wins must not upload, got %v", up)
	}
	if b, _ := os.ReadFile(p); string(b) != "remote-version" {
		t.Errorf("remote-wins must replace the local content, got %q", string(b))
	}
}

// pull --if-exists overwrite --yes：确认后才 download_file(fileId=A) 并覆盖本地内容。
func TestCrossPlatformCoverageDrivePull_confirmedOverwriteIssuesExactCalls(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "a.txt")
	mustWrite(t, p, "local-old")

	caller := pullListingCaller(`{"name":"a.txt","type":"file","fileId":"A","modifyTime":9}`)
	swapPullDownloadPath(t, func(_ context.Context, _ string, _ map[string]string, dest string) error {
		return os.WriteFile(dest, []byte("remote-new"), 0o644)
	})

	if err := runDriveCmdWithoutConfirm(t, caller, "pull", "--local-folder", dir,
		"--remote-folder", "ROOT", "--if-exists", "overwrite", "--yes"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	dl := caller.callsFor("download_file")
	if len(dl) != 1 || dl[0].args["fileId"] != "A" {
		t.Fatalf("expected exactly one download_file(fileId=A), got %v", dl)
	}
	if b, _ := os.ReadFile(p); string(b) != "remote-new" {
		t.Errorf("confirmed overwrite must replace the local file, got %q", string(b))
	}
}

// push --if-exists overwrite --yes：确认后原地覆盖，必须带 overwriteFileId 且不带 parentId。
func TestCrossPlatformCoverageDrivePush_confirmedOverwriteIssuesExactCalls(t *testing.T) {
	dir := t.TempDir()
	mustWrite(t, filepath.Join(dir, "a.txt"), "local")
	withNoopPut(t)

	caller := pushOKCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"a.txt","type":"file","fileId":"A","modifyTime":1}],"nextToken":""}}`,
	})
	if err := runDriveCmdWithoutConfirm(t, caller, "push", "--local-folder", dir,
		"--remote-folder", "ROOT", "--if-exists", "overwrite", "--yes"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	up := caller.callsFor("get_upload_info")
	if len(up) != 1 || up[0].args["overwriteFileId"] != "A" {
		t.Fatalf("expected get_upload_info(overwriteFileId=A), got %v", up)
	}
	if _, has := up[0].args["parentId"]; has {
		t.Error("in-place overwrite must not carry parentId")
	}
}

// sync --on-conflict local-wins --yes：确认后覆盖上传远端，且不下载。
func TestCrossPlatformCoverageDriveSync_confirmedLocalWinsIssuesExactCalls(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "f.txt")
	mustWrite(t, p, "local-version")
	local := readFileMTimeMillis(t, p)
	withSyncTransport(t, "unused")

	caller := syncCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"f.txt","type":"file","fileId":"F","modifyTime":` +
			differentMillis(local) + `}],"nextToken":""}}`,
	})
	if err := runDriveCmdWithoutConfirm(t, caller, "sync", "--local-folder", dir,
		"--remote-folder", "ROOT", "--quick", "--on-conflict", "local-wins", "--yes"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	up := caller.callsFor("get_upload_info")
	if len(up) != 1 || up[0].args["overwriteFileId"] != "F" {
		t.Fatalf("expected get_upload_info(overwriteFileId=F), got %v", up)
	}
	if dl := caller.callsFor("download_file"); len(dl) != 0 {
		t.Errorf("local-wins must not download, got %v", dl)
	}
	if b, _ := os.ReadFile(p); string(b) != "local-version" {
		t.Errorf("local-wins must keep the local content, got %q", string(b))
	}
}

// ──────────────────────────────────────────────────────────
// 3. 安全默认值本身
// ──────────────────────────────────────────────────────────

// sync 默认 --on-conflict=skip：两侧都变更时两边内容都保留，且不发出任何传输调用。
func TestCrossPlatformCoverageDriveSync_defaultSkipsConflictsEntirely(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "f.txt")
	mustWrite(t, p, "local-version")
	local := readFileMTimeMillis(t, p)
	withSyncTransport(t, "remote-version")

	caller := syncCaller(map[string]string{
		"ROOT": `{"result":{"items":[{"name":"f.txt","type":"file","fileId":"F","modifyTime":` +
			differentMillis(local) + `}],"nextToken":""}}`,
	})
	if err := runDriveCmd(t, caller, "sync", "--local-folder", dir, "--remote-folder", "ROOT", "--quick"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if got := len(caller.callsFor("download_file")) + len(caller.callsFor("get_upload_info")); got != 0 {
		t.Errorf("default skip must not transfer anything, got %d calls", got)
	}
	if b, _ := os.ReadFile(p); string(b) != "local-version" {
		t.Errorf("default skip must keep the local content, got %q", string(b))
	}
}

// pull 默认 --if-exists=skip：本地已存在的文件不被覆盖。
func TestCrossPlatformCoverageDrivePull_defaultSkipsExistingLocalFiles(t *testing.T) {
	dir := t.TempDir()
	p := filepath.Join(dir, "a.txt")
	mustWrite(t, p, "local-old")

	caller := pullListingCaller(`{"name":"a.txt","type":"file","fileId":"A","modifyTime":9}`)
	swapPullDownloadPath(t, func(context.Context, string, map[string]string, string) error {
		t.Error("default skip must not download over an existing local file")
		return nil
	})

	if err := runDriveCmd(t, caller, "pull", "--local-folder", dir, "--remote-folder", "ROOT"); err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if b, _ := os.ReadFile(p); string(b) != "local-old" {
		t.Errorf("default skip must keep the local file, got %q", string(b))
	}
}