// Package mover 负责"搬文件"这一步：把一批文件从老地方移到新目录。
//
// 大白话理解：
//   - 同一个磁盘里移动 = 改个目录记录而已，瞬间完成（改名操作）；
//   - 跨磁盘移动 = 系统不让"改名"，只能老老实实把内容复制过去再删掉原来的。
//     这个包会自动判断，跨盘时偷偷用"复制+删除"顶上，调用方感觉不到区别。
//
// 搬文件比较慢（尤其跨盘复制），所以用几个工人并行搬，能快不少。
package mover

import (
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"sync/atomic"

	"kenaito-media-picker/internal/config"

	uuid "github.com/satori/go.uuid"
)

// MoveJob 一次"搬文件"的任务：把 Source 这个文件搬进 TargetDir 目录。
type MoveJob struct {
	Source    string // 文件现在在哪
	TargetDir string // 要搬进哪个目录
}

// Mover 文件移动器。目前不需要记录任何状态，所以是个空壳结构体。
type Mover struct{}

// workerCount 并行搬文件的工人数：默认 4 个（配置 organize.workers 可调，0 表示用满 CPU）。
// 搬文件时磁盘 IO 才是瓶颈，并发太大反而把 CPU/磁盘都拖垮，给个配置让用户自行权衡。
func workerCount() int {
	return config.WorkerCount()
}

// MoveAll 把一批"搬文件任务"全局并行搬完——不管任务分散在几个目录，
// 所有文件同时开搬（最多 8 个工人），这才是真正的并行。
//
// 目标文件名会加一长串随机前缀（uuid），这样即使两个文件同名也不会互相覆盖。
// 返回"移动成功的 源路径 → 新位置完整路径"的对照表，方便调用方记录每个文件去哪了。
// onProgress 每搬完一个文件调一次，参数是"已累计搬完多少个"（只会涨不会退，并发安全）。
func (m *Mover) MoveAll(jobs []MoveJob, onProgress func(done int)) map[string]string {
	moved := make(map[string]string)
	if len(jobs) == 0 {
		return moved
	}
	// 先把所有目标目录建好（去重，每个目录只需建一次；MkdirAll 建已存在的目录也没关系）
	created := make(map[string]bool)
	for _, j := range jobs {
		if created[j.TargetDir] {
			continue
		}
		created[j.TargetDir] = true
		if err := os.MkdirAll(j.TargetDir, 0755); err != nil {
			fmt.Printf("=== 创建目录失败: %s, 错误: %v\n", j.TargetDir, err)
		}
	}

	// 全局并行搬：results[i] 存 jobs[i] 搬完之后的新路径（失败为空串）
	results := make([]string, len(jobs))
	workers := workerCount()
	if workers > len(jobs) {
		workers = len(jobs)
	}
	var wg sync.WaitGroup
	var doneCount int32
	ch := make(chan int)
	for w := 0; w < workers; w++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for i := range ch {
				if target, ok := moveOne(jobs[i].Source, jobs[i].TargetDir); ok {
					results[i] = target
				}
				if onProgress != nil {
					onProgress(int(atomic.AddInt32(&doneCount, 1)))
				}
			}
		}()
	}
	for i := range jobs {
		ch <- i
	}
	close(ch)
	wg.Wait()

	// 把搬成功的整理成 源路径 → 新路径 的对照表
	for i, target := range results {
		if target != "" {
			moved[jobs[i].Source] = target
		}
	}
	return moved
}

// moveOne 移动单个文件；跨磁盘搬不动时，自动降级为"复制 + 删除源文件"。
// 成功返回新位置的完整路径；连复制都失败返回 false。
// 注意一种特殊情况：复制成功了但删源文件失败（比如源文件被占用），
// 这时源和目标会同时存在，但依然算"移动成功"，返回新路径。
func moveOne(src, targetDir string) (string, bool) {
	// 新文件名 = 随机前缀 + 原文件名，防止重名覆盖
	fileName := strings.ReplaceAll(uuid.NewV4().String(), "-", "") + "_" + filepath.Base(src)
	target := filepath.Join(targetDir, fileName)
	// 先在同一个磁盘里直接改名（秒完成）
	if err := os.Rename(src, target); err == nil {
		return target, true
	}
	// 改名失败（大概率是跨磁盘）→ 复制 + 删除
	if err := copyFile(src, target); err != nil {
		fmt.Printf("=== 复制文件失败, 源: %s, 目标: %s, 错误: %v\n", src, target, err)
		return "", false
	}
	if err := os.Remove(src); err != nil {
		fmt.Printf("=== 警告: 复制成功但删除源文件失败, 源与目标同时存在, 源: %s, 错误: %v\n", src, err)
	}
	return target, true
}

// copyFile 把一个文件的内容完整复制到另一个位置。
// 复制到一半失败时，会把已经写出来的半截文件删掉，不给磁盘留垃圾。
func copyFile(src, dst string) error {
	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.Create(dst)
	if err != nil {
		return err
	}
	// 复制途中出错：关掉并删掉半截文件
	if _, err := io.Copy(out, in); err != nil {
		out.Close()
		_ = os.Remove(dst)
		return err
	}
	// 写完收尾出错：同样删掉
	if err := out.Close(); err != nil {
		_ = os.Remove(dst)
		return err
	}
	return nil
}