package helpers

import (
	"bufio"
	"context"
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"sort"
	"strings"

	"github.com/spf13/cobra"
)

// keep-both 的本地保留副本通过同一个固定父目录 os.Root 原子建立硬链接；以下 seam
// 仅用于文件系统失败与并发替换的确定性测试，测试必须通过 testseam.Swap 替换。
var (
	syncRootLink          = func(root *os.Root, oldName, newName string) error { return root.Link(oldName, newName) }
	syncPullOneFilePinned = pullOneFilePinned
)

// ==========================================================
// drive sync — 本地与钉盘双向同步（本地 ⇄ Drive）
// ==========================================================
// ──────────────────────────────────────────────────────────
// dws drive sync — 把 --local-folder 与 --remote-folder 做文件级双向同步。
//
// 复用 status 的差异判定（exact MD5 / --quick modified_time）先算出 diff，再按方向执行：
//   new_local   仅本地存在   → push（缺失的远端目录按需创建，再上传）
//   new_remote  仅钉盘存在   → pull（下载到本地对应路径）
//   modified    两侧都变更   → 按 --on-conflict 解决：
//                 skip       默认：两侧都不动并保留两边内容
//                 remote-wins     ：拉取远端覆盖本地
//                 local-wins       ：上传本地覆盖远端
//                 keep-both        ：本地改名保留，再拉取远端到原路径
//                 ask              ：交互式逐个询问
//   unknown     exact 模式远端无可靠 md5、内容无法核对 → 跳过（记 skipped，提示改用 --quick）
//   unchanged   两侧一致                                → 不动
//
// 文件级同步——只新增/覆盖，不删除任何一侧的多余文件。summary.failed > 0 时以非零
// 退出码退出，结构化 summary + diff + items 仍打印在 stdout 上。
// ──────────────────────────────────────────────────────────

// --on-conflict 的五种冲突解决策略。
const (
	syncConflictLocalWins  = "local-wins"  // 上传本地覆盖远端
	syncConflictRemoteWins = "remote-wins" // 拉取远端覆盖本地
	syncConflictKeepBoth   = "keep-both"   // 本地改名保留，再拉取远端到原路径
	syncConflictAsk        = "ask"         // 交互式逐个询问
	syncConflictSkip       = "skip"        // 默认：两侧都变更时什么都不做，两边内容都保留
)

// sync 动作分类（direction 标注每条记录属于哪个方向）。
const (
	syncDirectionPull     = "pull"
	syncDirectionPush     = "push"
	syncDirectionConflict = "conflict"

	syncActionDownloaded    = "downloaded"
	syncActionUploaded      = "uploaded"
	syncActionOverwritten   = "overwritten"
	syncActionFolderCreated = "folder_created"
	syncActionRenamedLocal  = "renamed_local"
	syncActionSkipped       = "skipped"
	syncActionFailed        = "failed"

	syncActionPlannedDownload     = "planned_download"
	syncActionPlannedUpload       = "planned_upload"
	syncActionPlannedOverwrite    = "planned_overwrite"
	syncActionPlannedFolderCreate = "planned_folder_create"
	syncActionPlannedRenameLocal  = "planned_rename_local"
	syncActionPlannedSkip         = "planned_skip"
	syncActionDecisionRequired    = "decision_required"
)

// driveSyncItem 是输出 items[] 中每条操作的明细。
type driveSyncItem struct {
	RelPath   string `json:"rel_path"`
	Action    string `json:"action"`
	Direction string `json:"direction,omitempty"`
	Error     string `json:"error,omitempty"`
}

// driveSyncSummary 是各方向的计数汇总。
type driveSyncSummary struct {
	Pulled         int `json:"pulled"`
	Pushed         int `json:"pushed"`
	Skipped        int `json:"skipped"`
	Failed         int `json:"failed"`
	PlannedPulls   int `json:"planned_pulls,omitempty"`
	PlannedPushes  int `json:"planned_pushes,omitempty"`
	PlannedSkips   int `json:"planned_skips,omitempty"`
	PlannedFolders int `json:"planned_folders,omitempty"`
}

// driveSyncDiff 是本次同步前算出的五类差异（与 status 同源）。
type driveSyncDiff struct {
	NewLocal  []driveStatusEntry `json:"new_local"`
	NewRemote []driveStatusEntry `json:"new_remote"`
	Modified  []driveStatusEntry `json:"modified"`
	Unchanged []driveStatusEntry `json:"unchanged"`
	Unknown   []driveStatusEntry `json:"unknown"`
}

// driveSyncResult 是 sync 命令的输出 schema。
type driveSyncResult struct {
	Detection string           `json:"detection"`
	Diff      driveSyncDiff    `json:"diff"`
	Summary   driveSyncSummary `json:"summary"`
	Items     []driveSyncItem  `json:"items"`
}

type driveSyncDryRunResult struct {
	DryRun      bool            `json:"dry_run"`
	Executed    bool            `json:"executed"`
	PreviewKind string          `json:"preview_kind"`
	Operation   string          `json:"operation"`
	Plan        driveSyncResult `json:"plan"`
}

// driveSyncFailure 在 summary.failed > 0 时返回：结构化结果已打印到 stdout，
// 这里只负责以 exit=1 退出并向 stderr 输出一行简短说明（与 drivePushFailure 一致）。
type driveSyncFailure struct{ failed int }

func (e *driveSyncFailure) Error() string {
	return fmt.Sprintf("drive sync: %d item(s) failed", e.failed)
}
func (e *driveSyncFailure) RawStderr() string { return e.Error() }
func (e *driveSyncFailure) ExitCode() int     { return 1 }

func runDriveSync(cmd *cobra.Command, _ []string) error {
	if err := validateRequiredFlags(cmd, "local-folder", "remote-folder"); err != nil {
		return err
	}
	localDir := mustGetFlag(cmd, "local-folder")
	remoteDirID := mustGetFlag(cmd, "remote-folder")
	// space-id 可选：不传则由底层使用「我的文件」对应的空间。
	spaceID := mustGetFlag(cmd, "space-id")

	onConflict, _ := cmd.Flags().GetString("on-conflict")
	if onConflict == "" {
		// 安全默认：两侧都变更时不擅自覆盖任何一侧。
		onConflict = syncConflictSkip
	}
	switch onConflict {
	case syncConflictSkip, syncConflictLocalWins, syncConflictRemoteWins, syncConflictKeepBoth, syncConflictAsk:
	default:
		return fmt.Errorf("--on-conflict 取值非法: %s（可选 skip|local-wins|remote-wins|keep-both|ask）", onConflict)
	}

	quick, _ := cmd.Flags().GetBool("quick")
	detection := "exact"
	if quick {
		detection = "quick"
	}

	absDir, err := validateLocalDirAbs(localDir)
	if err != nil {
		return err
	}
	pinnedRoot, err := openExistingPinnedPullRoot(absDir)
	if err != nil {
		return fmt.Errorf("扫描本地目录失败: %w", err)
	}
	defer pinnedRoot.close()
	// sync 的本地快照与后续 hash / upload / pull 全部绑定到同一个固定根。
	localDirs, localFiles, err := runDriveMirrorWalkLocalForPushPinned(pinnedRoot)
	if err != nil {
		return fmt.Errorf("扫描本地目录失败: %w", err)
	}

	ctx := cmd.Context()

	// 远端现状：文件（含 hash/mtime/fileId）与目录（rel_path → fileId，"" 即根本身）。
	remoteFiles, remoteFolders, err := fetchRemoteTreeForPush(ctx, spaceID, remoteDirID)
	if err != nil {
		return err
	}
	localByRel := make(map[string]localPushFile, len(localFiles))
	for _, f := range localFiles {
		localByRel[f.RelPath] = f
	}
	preflight := buildMirrorPreflight(localDirs, localFiles, remoteFiles, remoteFolders)
	addPinnedLocalTargetPreflightFailures(pinnedRoot, remoteFiles, preflight)

	// 在计算 diff 前先识别文件/目录同路径冲突。冲突根及其全部后代都不能再进入
	// new_local / new_remote 或后续执行阶段，否则会在远端制造同名异类对象，或尝试
	// 把远端目录内容下载到本地文件之下。
	typeConflicts := make(map[string]string)
	for rel, msg := range preflight {
		typeConflicts[rel] = msg
	}
	for _, dir := range localDirs {
		if msg := pushTypeConflictError(dir, true, remoteFiles, remoteFolders); msg != "" {
			typeConflicts[dir] = msg
		}
	}
	for rel := range localByRel {
		if msg := pushTypeConflictError(rel, false, remoteFiles, remoteFolders); msg != "" {
			typeConflicts[rel] = msg
		}
	}

	// 计算 diff：双端都存在的文件复用 judgeFileMatch，保持与 status 完全一致的判定。
	diff := driveSyncDiff{
		NewLocal:  []driveStatusEntry{},
		NewRemote: []driveStatusEntry{},
		Modified:  []driveStatusEntry{},
		Unchanged: []driveStatusEntry{},
		Unknown:   []driveStatusEntry{},
	}
	var newLocal, newRemote, modified, unknown []string
	for rel, pf := range localByRel {
		if syncPathBlockedByTypeConflict(rel, typeConflicts) {
			continue
		}
		rf, ok := remoteFiles[rel]
		if !ok {
			newLocal = append(newLocal, rel)
			continue
		}
		verdict, jerr := judgePinnedPushFileMatch(pinnedRoot, pf, rf, quick)
		if jerr != nil {
			return jerr
		}
		switch verdict {
		case matchUnchanged:
			diff.Unchanged = append(diff.Unchanged, driveStatusEntry{RelPath: rel})
		case matchUnknown:
			unknown = append(unknown, rel)
		default:
			modified = append(modified, rel)
		}
	}
	for rel := range remoteFiles {
		if syncPathBlockedByTypeConflict(rel, typeConflicts) {
			continue
		}
		if _, ok := localByRel[rel]; !ok {
			newRemote = append(newRemote, rel)
		}
	}
	sort.Strings(newLocal)
	sort.Strings(newRemote)
	sort.Strings(modified)
	sort.Strings(unknown)
	for _, rel := range newLocal {
		diff.NewLocal = append(diff.NewLocal, driveStatusEntry{RelPath: rel})
	}
	for _, rel := range newRemote {
		diff.NewRemote = append(diff.NewRemote, driveStatusEntry{RelPath: rel})
	}
	for _, rel := range modified {
		diff.Modified = append(diff.Modified, driveStatusEntry{RelPath: rel})
	}
	for _, rel := range unknown {
		diff.Unknown = append(diff.Unknown, driveStatusEntry{RelPath: rel})
	}
	sortEntries(diff.Unchanged)

	res := driveSyncResult{Detection: detection, Diff: diff, Items: []driveSyncItem{}}
	conflictRels := make([]string, 0, len(typeConflicts))
	for rel := range typeConflicts {
		conflictRels = append(conflictRels, rel)
	}
	sort.Strings(conflictRels)
	for _, rel := range conflictRels {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{
			RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict,
			Error: typeConflicts[rel],
		})
	}
	if err := pinnedRoot.verify(); err != nil {
		return err
	}

	// --dry-run：只算差异、不执行任何同步动作。
	if deps.Caller.DryRun() {
		if len(preflight) == 0 && res.Summary.Failed == 0 {
			appendDriveSyncDryRunPlan(&res, driveSyncDryRunPlanInput{
				LocalDirs: localDirs, LocalByRel: localByRel, RemoteFiles: remoteFiles, RemoteFolders: remoteFolders,
				NewLocal: newLocal, NewRemote: newRemote, Modified: modified, Unknown: unknown, OnConflict: onConflict,
			})
		}
		return deps.Out.PrintJSON(driveSyncDryRunResult{
			DryRun: true, Executed: false, PreviewKind: "plan", Operation: "drive sync", Plan: res,
		})
	}
	// 镜像前置检查是整批门禁：发现任一本地非法名称或跨端等价路径歧义后，
	// sync 不得执行 create/download/upload 等任一写动作。
	if len(preflight) > 0 {
		if perr := deps.Out.PrintJSON(res); perr != nil {
			return perr
		}
		return &driveSyncFailure{failed: res.Summary.Failed}
	}

	// unknown：exact 模式下远端无可靠 md5、内容无法核对，不擅自覆盖任何一侧，记 skipped。
	for _, rel := range unknown {
		res.Summary.Skipped++
		res.Items = append(res.Items, driveSyncItem{
			RelPath: rel, Action: syncActionSkipped, Direction: syncDirectionConflict,
			Error: "远端无可靠 md5，内容无法核对，已跳过（可改用 --quick 按 modified_time 比对）",
		})
	}

	// ask 模式：先把所有 modified 的解决策略问全，再统一执行，避免边执行边交互。
	resolutions := make(map[string]string, len(modified))
	for _, rel := range modified {
		strategy := onConflict
		switch strategy {
		case syncConflictAsk:
			strategy, err = driveSyncAskConflict(rel)
			if err != nil {
				return err
			}
		case syncConflictSkip:
			strategy = "" // 与 ask 选择「跳过」同一条落地路径
		}
		resolutions[rel] = strategy
	}
	// 交互决策期间本地根也可能被替换；首个双端写动作前再次核对固定身份。
	if err := pinnedRoot.verify(); err != nil {
		return err
	}

	// occupied：keep-both 生成不冲突的本地重命名目标时用，覆盖两侧全部已知路径。
	occupied := make(map[string]bool)
	for rel := range localByRel {
		occupied[rel] = true
	}
	for _, d := range localDirs {
		occupied[d] = true
	}
	for rel := range remoteFiles {
		occupied[rel] = true
	}
	for rel := range remoteFolders {
		if rel != "" {
			occupied[rel] = true
		}
	}

	// 阶段 1：镜像本地目录结构到远端（缺失则创建），保证空目录与 push 目标的父目录先存在。
	for _, dir := range localDirs {
		if _, ok := remoteFolders[dir]; ok {
			continue // 远端已存在，复用 fileId
		}
		parentRel, name := splitRel(dir)
		parentID, ok := remoteFolders[parentRel]
		if !ok || parentID == "" {
			res.Summary.Failed++
			res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
			continue
		}
		if err := pinnedRoot.verify(); err != nil {
			return err
		}
		fid, cerr := pushCreateFolder(ctx, spaceID, parentID, name)
		if cerr != nil || fid == "" {
			res.Summary.Failed++
			msg := "create_folder 未返回 fileId"
			if cerr != nil {
				msg = cerr.Error()
			}
			res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionFailed, Direction: syncDirectionPush, Error: msg})
			continue
		}
		remoteFolders[dir] = fid
		res.Summary.Pushed++
		res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionFolderCreated, Direction: syncDirectionPush})
	}

	// 阶段 2：new_remote 下载到本地。
	for _, rel := range newRemote {
		syncPullFilePinned(&res, ctx, spaceID, remoteFiles[rel], pinnedRoot, rel, syncDirectionPull)
	}

	// 阶段 3：new_local 上传到远端。
	for _, rel := range newLocal {
		pf := localByRel[rel]
		syncPushFile(&res, ctx, spaceID, remoteFolders, pinnedRoot, pf, rel, "")
	}

	// 阶段 4：modified 按 --on-conflict 解决。
	for _, rel := range modified {
		pf := localByRel[rel]
		rf := remoteFiles[rel]
		switch resolutions[rel] {
		case syncConflictRemoteWins:
			syncPullFilePinned(&res, ctx, spaceID, rf, pinnedRoot, rel, syncDirectionPull)
		case syncConflictLocalWins:
			syncPushFile(&res, ctx, spaceID, remoteFolders, pinnedRoot, pf, rel, rf.FileID)
		case syncConflictKeepBoth:
			syncKeepBothPinned(&res, ctx, spaceID, rf, pinnedRoot, rel, occupied)
		default: // "" — ask 选择跳过
			res.Summary.Skipped++
			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionSkipped, Direction: syncDirectionConflict})
		}
	}

	// 结构化结果始终打印到 stdout；有失败则额外以非零退出码退出。
	if perr := deps.Out.PrintJSON(res); perr != nil {
		return perr
	}
	if res.Summary.Failed > 0 {
		return &driveSyncFailure{failed: res.Summary.Failed}
	}
	return nil
}

type driveSyncDryRunPlanInput struct {
	LocalDirs     []string
	LocalByRel    map[string]localPushFile
	RemoteFiles   map[string]*remoteFile
	RemoteFolders map[string]string
	NewLocal      []string
	NewRemote     []string
	Modified      []string
	Unknown       []string
	OnConflict    string
}

func appendDriveSyncDryRunPlan(res *driveSyncResult, input driveSyncDryRunPlanInput) {
	for _, rel := range input.Unknown {
		res.Summary.PlannedSkips++
		res.Items = append(res.Items, driveSyncItem{
			RelPath: rel, Action: syncActionPlannedSkip, Direction: syncDirectionConflict,
			Error: "远端无可靠 md5，内容无法核对，执行时会跳过（可改用 --quick 按 modified_time 比对）",
		})
	}

	plannedFolders := make(map[string]string, len(input.RemoteFolders)+len(input.LocalDirs))
	for rel, fileID := range input.RemoteFolders {
		plannedFolders[rel] = fileID
	}
	for _, dir := range input.LocalDirs {
		if _, ok := plannedFolders[dir]; ok {
			continue
		}
		parentRel, _ := splitRel(dir)
		if plannedFolders[parentRel] == "" {
			res.Summary.Failed++
			res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
			continue
		}
		plannedFolders[dir] = "dry-run-planned-folder"
		res.Summary.PlannedFolders++
		res.Items = append(res.Items, driveSyncItem{RelPath: dir, Action: syncActionPlannedFolderCreate, Direction: syncDirectionPush})
	}

	for _, rel := range input.NewRemote {
		res.Summary.PlannedPulls++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull})
	}
	for _, rel := range input.NewLocal {
		parentRel, _ := splitRel(rel)
		if plannedFolders[parentRel] == "" {
			res.Summary.Failed++
			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
			continue
		}
		res.Summary.PlannedPushes++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedUpload, Direction: syncDirectionPush})
	}

	occupied := make(map[string]bool, len(input.LocalByRel)+len(input.LocalDirs)+len(input.RemoteFiles)+len(input.RemoteFolders))
	for rel := range input.LocalByRel {
		occupied[rel] = true
	}
	for _, rel := range input.LocalDirs {
		occupied[rel] = true
	}
	for rel := range input.RemoteFiles {
		occupied[rel] = true
	}
	for rel := range input.RemoteFolders {
		if rel != "" {
			occupied[rel] = true
		}
	}
	for _, rel := range input.Modified {
		switch input.OnConflict {
		case syncConflictRemoteWins:
			res.Summary.PlannedPulls++
			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull})
		case syncConflictLocalWins:
			res.Summary.PlannedPushes++
			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedOverwrite, Direction: syncDirectionConflict})
		case syncConflictKeepBoth:
			candidate := driveSyncSuffixedRel(rel, input.RemoteFiles[rel].FileID, occupied)
			occupied[candidate] = true
			res.Summary.PlannedPulls++
			res.Items = append(res.Items,
				driveSyncItem{RelPath: candidate, Action: syncActionPlannedRenameLocal, Direction: syncDirectionConflict},
				driveSyncItem{RelPath: rel, Action: syncActionPlannedDownload, Direction: syncDirectionPull},
			)
		case syncConflictAsk:
			res.Items = append(res.Items, driveSyncItem{
				RelPath: rel, Action: syncActionDecisionRequired, Direction: syncDirectionConflict,
				Error: "执行时需要交互选择 remote-wins、local-wins、keep-both 或 skip",
			})
		default:
			res.Summary.PlannedSkips++
			res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionPlannedSkip, Direction: syncDirectionConflict})
		}
	}
}

// syncPathBlockedByTypeConflict 判断 rel 本身或任一祖先是否是文件/目录类型冲突根。
// 祖先检查保证冲突目录下的本地、远端后代不会绕过根路径的 fail-closed 结论。
func syncPathBlockedByTypeConflict(rel string, conflicts map[string]string) bool {
	for rel != "" {
		if _, blocked := conflicts[rel]; blocked {
			return true
		}
		rel, _ = splitRel(rel)
	}
	return false
}

// addPinnedLocalTargetPreflightFailures 从 sync 已固定的本地根核对所有远端落盘点。
// 每一层既有祖先都必须是真实目录，末段若存在则必须是常规文件；软链即使仍指向根内
// 也不属于可移植镜像树，必须在任何双端写之前整批拒绝。
func addPinnedLocalTargetPreflightFailures(root *pinnedPullRoot, remote map[string]*remoteFile, failures map[string]string) {
	for rel := range remote {
		if mirrorPreflightFailureForRel(rel, failures) != "" {
			continue
		}
		parts := strings.Split(filepath.FromSlash(rel), string(filepath.Separator))
		for i := range parts {
			name := filepath.Join(parts[:i+1]...)
			info, err := pullRootLstat(root.root, name)
			if err != nil {
				if os.IsNotExist(err) {
					break
				}
				failures[rel] = fmt.Sprintf("检查本地目标失败: %v", err)
				break
			}
			if i < len(parts)-1 {
				if !info.IsDir() {
					failures[rel] = fmt.Sprintf("本地目标 %q 的祖先 %q 已存在且不是目录，已拒绝镜像", rel, filepath.ToSlash(name))
					break
				}
				continue
			}
			if !info.Mode().IsRegular() {
				failures[rel] = fmt.Sprintf("本地目标 %q 已存在且不是常规文件，已拒绝覆盖", rel)
			}
		}
	}
}

// syncPullFile 下载单个远端文件到本地 rel 对应路径（总是覆盖，Drive 为该项权威源），
// 并把结果计入 res。命中大小写/规范化冲突或逃逸的路径记 failed、不落盘。
func syncPullFile(res *driveSyncResult, ctx context.Context, spaceID string, rf *remoteFile, absDir, rel, direction string) {
	root, err := openPinnedPullRoot(absDir)
	if err != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: direction, Error: err.Error()})
		return
	}
	defer root.close()
	syncPullFilePinned(res, ctx, spaceID, rf, root, rel, direction)
}

func syncPullFilePinned(res *driveSyncResult, ctx context.Context, spaceID string, rf *remoteFile, root *pinnedPullRoot, rel string, direction string) {
	action, perr := pullRemoteFilePinned(ctx, spaceID, rf, root, rel, ifExistsOverwrite)
	if action == pullActionDownloaded {
		res.Summary.Pulled++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionDownloaded, Direction: direction})
		return
	}
	res.Summary.Failed++
	item := driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: direction}
	if perr != nil {
		item.Error = perr.Error()
	}
	res.Items = append(res.Items, item)
}

// syncPushFile 上传单个本地文件到远端；overwriteID 非空时走覆盖上传（原地覆盖同名远端文件）。
func syncPushFile(res *driveSyncResult, ctx context.Context, spaceID string, remoteFolders map[string]string, root *pinnedPullRoot, pf localPushFile, rel, overwriteID string) {
	parentRel, name := splitRel(rel)
	parentID, ok := remoteFolders[parentRel]
	if !ok || parentID == "" {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionPush, Error: "父目录未能创建"})
		return
	}
	if err := pushUploadFilePinned(ctx, spaceID, parentID, overwriteID, name, root, pf); err != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionPush, Error: err.Error()})
		return
	}
	res.Summary.Pushed++
	action := syncActionUploaded
	direction := syncDirectionPush
	if overwriteID != "" {
		action = syncActionOverwritten
		direction = syncDirectionConflict
	}
	res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: action, Direction: direction})
}

// syncKeepBoth 解决 modified 冲突的 keep-both 策略：先为本地文件原子建立带冲突后缀
// 的 no-clobber 硬链接，再把远端文件拉取到原 rel 路径。拉取失败时保留两个本地名字，
// 不执行可能误删或覆盖并发文件的回滚。
func syncKeepBoth(res *driveSyncResult, ctx context.Context, spaceID string, rf *remoteFile, absDir, rel string, occupied map[string]bool) {
	root, err := openPinnedPullRoot(absDir)
	if err != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: err.Error()})
		return
	}
	defer root.close()
	syncKeepBothPinned(res, ctx, spaceID, rf, root, rel, occupied)
}

func syncKeepBothPinned(res *driveSyncResult, ctx context.Context, spaceID string, rf *remoteFile, root *pinnedPullRoot, rel string, occupied map[string]bool) {
	pinned, e1 := root.openTarget(rel)
	if e1 != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: e1.Error()})
		return
	}
	defer pinned.close()
	localInfo, err := pinned.regularTargetInfo()
	if err != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: err.Error()})
		return
	}
	if localInfo == nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: "本地保留版本不存在"})
		return
	}
	// Root.Link(original,candidate) 在同一固定父目录中原子 no-clobber 地保留本地版本。
	// occupied 的精确字符串查重覆盖不到的文件系统等价名称，由 Link 的 EEXIST 兜底。
	suffixedRel, newName, e2 := reserveSyncKeepBothTargetPinned(pinned, rel, rf.FileID, occupied)
	if e2 != nil {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: e2.Error()})
		return
	}
	savedInfo, err := pullRootLstat(pinned.parentRoot, newName)
	if err != nil || !sameKeepBothVersion(localInfo, savedInfo) {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: "本地保留版本身份不一致"})
		return
	}
	occupied[suffixedRel] = true

	action, perr := syncPullOneFilePinned(ctx, spaceID, rf, pinned, ifExistsOverwrite)
	if action != pullActionDownloaded {
		res.Summary.Failed++
		msg := ""
		if perr != nil {
			msg = perr.Error()
		}
		if msg == "" {
			msg = "远端版本未能拉取，本地保留版本已保留"
		}
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: msg})
		return
	}
	currentSaved, err := pullRootLstat(pinned.parentRoot, newName)
	if err != nil || !sameKeepBothVersion(savedInfo, currentSaved) {
		res.Summary.Failed++
		res.Items = append(res.Items, driveSyncItem{RelPath: rel, Action: syncActionFailed, Direction: syncDirectionConflict, Error: "本地保留版本在传输期间被删除、替换或修改"})
		return
	}
	res.Summary.Pulled++
	res.Items = append(res.Items,
		driveSyncItem{RelPath: suffixedRel, Action: syncActionRenamedLocal, Direction: syncDirectionConflict},
		driveSyncItem{RelPath: rel, Action: syncActionDownloaded, Direction: syncDirectionPull},
	)
}

func sameKeepBothVersion(expected, current os.FileInfo) bool {
	return expected != nil && current != nil && current.Mode().IsRegular() &&
		os.SameFile(expected, current) && expected.Size() == current.Size() &&
		expected.ModTime().Equal(current.ModTime())
}

// syncKeepBothCandidate 生成 keep-both 的第 n 个候选相对路径（n=0 为首选）：在扩展名前
// 插入基于远端 fileId 末段的后缀（缺失时用 conflict），n>0 再追加序号消歧。
func syncKeepBothCandidate(rel, fileID string, n int) string {
	suffix := "conflict"
	if fileID != "" {
		s := fileID
		if len(s) > 8 {
			s = s[len(s)-8:]
		}
		suffix = "conflict-" + s
	}
	dir, base := splitRel(rel)
	ext := filepath.Ext(base) // base 无路径分隔符，取末尾扩展名安全
	stem := strings.TrimSuffix(base, ext)
	name := stem + "." + suffix + ext
	if n > 0 {
		name = fmt.Sprintf("%s.%s.%d%s", stem, suffix, n, ext)
	}
	if dir == "" {
		return name
	}
	return dir + "/" + name
}

// driveSyncSuffixedRel 返回首个不在 occupied（纯字符串查重）中的候选。仅用于快速路径与
// 单元测试；keep-both 实际执行走 reserveSyncKeepBothTarget，以 OS 兜底等价性。
func driveSyncSuffixedRel(rel, fileID string, occupied map[string]bool) string {
	for n := 0; ; n++ {
		if cand := syncKeepBothCandidate(rel, fileID, n); !occupied[cand] {
			return cand
		}
	}
}

// reserveSyncKeepBothTarget 生成候选并通过 Root.Link(original,candidate) 原子建立
// no-clobber 本地保留版本。EEXIST（含文件系统等价名称）时换下一个候选。
func reserveSyncKeepBothTarget(absDir, rel, fileID string, occupied map[string]bool) (string, string, error) {
	target, err := openPinnedPullTarget(absDir, rel)
	if err != nil {
		return "", "", err
	}
	defer target.close()
	candidate, _, err := reserveSyncKeepBothTargetPinned(target, rel, fileID, occupied)
	if err != nil {
		return "", "", err
	}
	return candidate, filepath.Join(absDir, filepath.FromSlash(candidate)), nil
}

func reserveSyncKeepBothTargetPinned(target *pinnedPullTarget, rel, fileID string, occupied map[string]bool) (string, string, error) {
	parentRel, _ := splitRel(rel)
	for n := 0; ; n++ {
		cand := syncKeepBothCandidate(rel, fileID, n)
		if occupied[cand] {
			continue // 本次运行内已知占用，快速跳过
		}
		candidateParent, candidateName := splitRel(cand)
		if candidateParent != parentRel || !isSafeRemoteSegment(candidateName) {
			return "", "", fmt.Errorf("keep-both 候选路径 %q 不在原目标目录内", cand)
		}
		if err := target.verifyParent(); err != nil {
			return "", "", err
		}
		oerr := syncRootLink(target.parentRoot, target.name, filepath.FromSlash(candidateName))
		if oerr == nil {
			return cand, filepath.FromSlash(candidateName), nil
		}
		if os.IsExist(oerr) {
			occupied[cand] = true // 等价目标已存在，记下避免重试，换下一个后缀
			continue
		}
		return "", "", oerr
	}
}

// syncAskStdin 是 --on-conflict=ask 交互提问的输入源，默认 os.Stdin；测试可替换它以
// 注入非交互（EOF）场景。
var syncAskStdin io.Reader = os.Stdin

// driveSyncAskConflict 在 --on-conflict=ask 下交互式询问单个冲突文件的解决策略。
// 返回四种具体策略之一，或 ""（跳过）。当 stdin 在给出选择前结束（管道/无 TTY 等非交互
// 环境）时，按文档约定等价于「跳过」，返回 ""——绝不因此中止整个同步，new_local/new_remote
// 等其余差异仍会照常处理。
func driveSyncAskConflict(rel string) (string, error) {
	fmt.Fprintf(os.Stderr, "冲突: 本地与远端都修改了 %q。请选择 [R]远端优先 / [L]本地优先 / [K]保留两者 / [S]跳过 (默认 R): ", rel)
	line, err := bufio.NewReader(syncAskStdin).ReadString('\n')
	if err != nil && !errors.Is(err, io.EOF) {
		return "", fmt.Errorf("读取冲突选择失败 (%s): %w", rel, err)
	}
	switch strings.TrimSpace(strings.ToLower(line)) {
	case "r", "remote", "remote-wins":
		return syncConflictRemoteWins, nil
	case "l", "local", "local-wins":
		return syncConflictLocalWins, nil
	case "k", "keep", "keep-both":
		return syncConflictKeepBoth, nil
	case "s", "skip":
		return "", nil
	case "":
		if errors.Is(err, io.EOF) {
			// 非交互（管道/无 TTY）：stdin 在给出选择前结束。按文档约定等价于跳过，
			// 返回 "" 而非报错——否则单个冲突会让 runDriveSync 直接中止，连
			// new_local/new_remote 都不再处理。
			return "", nil
		}
		return syncConflictRemoteWins, nil // 交互式回车 → 默认远端优先
	default:
		return "", fmt.Errorf("无效的冲突选择: %q（可选 remote/local/keep/skip）", strings.TrimSpace(line))
	}
}