fs

func GetFileDiff(firstFile, secondFile string) (types.FileDiffInfo, error)

{
	firstContent, err := os.ReadFile(firstFile)
	if err != nil {
		return types.FileDiffInfo{}, err
	}

	secondContent, err := os.ReadFile(secondFile)
	if err != nil {
		return types.FileDiffInfo{}, err
	}

	diff := types.FileDiffInfo{}

	dmp := diffmatchpatch.New()
	diffs := dmp.DiffMain(string(firstContent), string(secondContent), false)
	for _, d := range diffs {
		switch d.Type {
		case diffmatchpatch.DiffInsert:
			diff.AddedLines = append(diff.AddedLines, d.Text)
		case diffmatchpatch.DiffDelete:
			diff.RemovedLines = append(diff.RemovedLines, d.Text)
		}
	}

	return diff, nil
}

func GetFilesystemInfo(path string) map[string]string

{
	info := make(map[string]string)

	u := udev.Udev{}
	d := u.NewDeviceFromSyspath(filepath.Join("/sys/class/block", filepath.Base(path)))
	info["LABEL"] = d.PropertyValue("ID_FS_LABEL")
	info["TYPE"] = d.PropertyValue("ID_FS_TYPE")
	info["UUID"] = d.PropertyValue("ID_FS_UUID")
	info["PARTUUID"] = d.PropertyValue("ID_PART_ENTRY_UUID")
	return info
}

func GetFileList(directory string, recursive, fullPaths bool) ([]types.FileInfo, error)

{
	var fileList []types.FileInfo

	walkFunc := func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !recursive && path != directory {
			return fs.SkipDir
		}
		if d.IsDir() {
			return nil
		}

		info, err := d.Info()
		if err != nil {
			return err
		}

		filePath := path
		if !fullPaths {
			filePath, _ = filepath.Rel(directory, path)
		}

		permissions := convertPermissions(info.Mode())

		fileList = append(fileList, types.FileInfo{
			Path:        filePath,
			ParentPath:  filepath.Dir(filePath),
			IsDirectory: false,
			Size:        info.Size(),
			Permissions: permissions,
			Extension:   GetFileExtension(path),
		})
		return nil
	}

	if err := filepath.WalkDir(directory, walkFunc); err != nil {
		return nil, err
	}

	return fileList, nil
}

func convertPermissions(mode os.FileMode) types.Permission

{
	return types.Permission{
		OwnerRead:     mode&0400 != 0,
		OwnerWrite:    mode&0200 != 0,
		OwnerExecute:  mode&0100 != 0,
		GroupRead:     mode&0040 != 0,
		GroupWrite:    mode&0020 != 0,
		GroupExecute:  mode&0010 != 0,
		OthersRead:    mode&0004 != 0,
		OthersWrite:   mode&0002 != 0,
		OthersExecute: mode&0001 != 0,
	}
}

func GetFile(filePath string, fullPath bool) (types.FileInfo, error)

{
	info, err := os.Stat(filePath)
	if err != nil {
		return types.FileInfo{}, err
	}

	permissions := convertPermissions(info.Mode())
	file := types.FileInfo{
		Path:        filePath,
		ParentPath:  filepath.Dir(filePath),
		IsDirectory: info.IsDir(),
		Size:        info.Size(),
		Permissions: permissions,
		Extension:   GetFileExtension(filePath),
	}

	if !fullPath {
		file.Path, _ = filepath.Rel(".", filePath)
	}

	return file, nil
}

func ListDirectories(directoryPath string) ([]string, error)

{
	var directories []string
	files, err := os.ReadDir(directoryPath)
	if err != nil {
		return nil, err
	}
	for _, file := range files {
		if file.IsDir() {
			directories = append(directories, file.Name())
		}
	}
	return directories, nil
}

func GetDiskList() ([]types.DiskInfo, error)

{
	var disks []types.DiskInfo

	files, err := os.ReadDir("/sys/class/block")
	if err != nil {
		return nil, err
	}

	diskMap := make(map[string]types.DiskInfo)

	for _, file := range files {
		name := file.Name()

		if isPartition(name) {
			continue
		}

		// Skip non-disk entries
		if strings.HasPrefix(name, "loop") ||
			strings.HasPrefix(name, "ram") ||
			strings.HasPrefix(name, "zram") {
			continue
		}

		diskPath := filepath.Join("/dev", name)
		info, err := GetDiskInfo(diskPath)
		if err != nil {
			return nil, err
		}

		partitions, err := GetPartitionList(diskPath)
		if err != nil {
			return nil, err
		}

		diskInfo := types.DiskInfo{
			BaseInfo:   info,
			Partitions: partitions,
		}

		diskMap[diskPath] = diskInfo
	}

	for _, disk := range diskMap {
		disks = append(disks, disk)
	}

	return disks, nil
}

func GetPartitionList(diskPath string) ([]types.PartitionInfo, error)

{
	var partitions []types.PartitionInfo

	files, err := os.ReadDir(filepath.Join("/sys/class/block", filepath.Base(diskPath)))
	if err != nil {
		return nil, err
	}

	for _, file := range files {
		name := file.Name()

		// Skip non-partition entries
		if !strings.HasPrefix(name, filepath.Base(diskPath)) {
			continue
		}

		partitionPath := filepath.Join("/dev", name)
		info, err := GetDiskInfo(partitionPath)
		if err != nil {
			return nil, err
		}

		partitionInfo := types.PartitionInfo{
			BaseInfo: info,
		}
		partitions = append(partitions, partitionInfo)
	}

	return partitions, nil
}

func GetDiskInfo(partitionPath string) (types.BaseInfo, error)

{
	info := types.BaseInfo{
		Path: partitionPath,
	}

	sizePath := filepath.Join("/sys/class/block", filepath.Base(partitionPath), "size")
	size, err := os.ReadFile(sizePath)
	if err != nil {
		return info, err
	}

	sectorSize := 512
	info.Size = int64(sectorSize) * int64(parseUint64(strings.TrimSpace(string(size))))
	info.HumanSize = GetHumanSize(info.Size)

	fsInfo := GetFilesystemInfo(partitionPath)
	info.Filesystem = fsInfo["TYPE"]
	info.Label = fsInfo["LABEL"]
	info.UUID = fsInfo["UUID"]
	info.PARTUUID = fsInfo["PARTUUID"]

	if mp, err := GetMountpoint(partitionPath); err == nil {
		info.Mountpoint = mp
	}

	return info, nil
}

func GetHumanSize(size int64) string

{
	const (
		kB = 1024.0
		mB = kB * 1024.0
		gB = mB * 1024.0
		tB = gB * 1024.0
	)

	sizeFloat := float64(size)

	switch {
	case size < int64(kB):
		return fmt.Sprintf("%d B", size)
	case size < int64(mB):
		return fmt.Sprintf("%.2f kB", sizeFloat/kB)
	case size < int64(gB):
		return fmt.Sprintf("%.2f MB", sizeFloat/mB)
	case size < int64(tB):
		return fmt.Sprintf("%.2f GB", sizeFloat/gB)
	default:
		return fmt.Sprintf("%.2f TB", sizeFloat/tB)
	}
}

func parseMountInfo(r io.Reader) ([]MountInfo, error)

{
	entries := make([]MountInfo, 0)

	scanner := bufio.NewScanner(r)
	for scanner.Scan() {
		line := scanner.Text()
		mi, err := parseMountInfoLine(line)
		if err != nil {
			return nil, err
		}
		entries = append(entries, mi)
	}

	if err := scanner.Err(); err != nil {
		return nil, err
	}

	return entries, nil
}

func parseMountInfoLine(line string) (MountInfo, error)

{
	// Split on the separator " - " (space, dash, space)
	parts := strings.SplitN(line, " - ", 2)
	if len(parts) != 2 {
		return MountInfo{}, fmt.Errorf("invalid mountinfo line: missing separator")
	}

	pre := strings.Fields(parts[0])
	if len(pre) < 6 {
		return MountInfo{}, fmt.Errorf("invalid mountinfo line: too few fields")
	}

	post := strings.Fields(parts[1])
	if len(post) < 3 {
		return MountInfo{}, fmt.Errorf("invalid mountinfo line: too few post-separator fields")
	}

	mountID, err := strconv.Atoi(pre[0])
	if err != nil {
		return MountInfo{}, err
	}
	parentID, err := strconv.Atoi(pre[1])
	if err != nil {
		return MountInfo{}, err
	}

	majMin := strings.SplitN(pre[2], ":", 2)
	if len(majMin) != 2 {
		return MountInfo{}, fmt.Errorf("invalid mountinfo line: invalid major:minor")
	}
	major, err := strconv.Atoi(majMin[0])
	if err != nil {
		return MountInfo{}, err
	}
	minor, err := strconv.Atoi(majMin[1])
	if err != nil {
		return MountInfo{}, err
	}

	root := unescapeMountField(pre[3])
	mountPoint := unescapeMountField(pre[4])
	options := splitComma(pre[5])

	optional := make([]string, 0)
	if len(pre) > 6 {
		for _, f := range pre[6:] {
			optional = append(optional, unescapeMountField(f))
		}
	}

	fsType := post[0]
	source := unescapeMountField(post[1])
	superOptions := splitComma(post[2])

	return MountInfo{
		MountID:        mountID,
		ParentID:       parentID,
		Major:          major,
		Minor:          minor,
		Root:           root,
		MountPoint:     mountPoint,
		Options:        options,
		OptionalFields: optional,
		FSType:         fsType,
		Source:         source,
		SuperOptions:   superOptions,
	}, nil
}

func unescapeMountField(s string) string

{
	// mountinfo uses octal escapes for special characters (e.g. \040 for space)
	if !strings.Contains(s, "\\") {
		return s
	}

	b := make([]byte, 0, len(s))
	for i := 0; i < len(s); i++ {
		if s[i] != '\\' || i+3 >= len(s) {
			b = append(b, s[i])
			continue
		}

		o := s[i+1 : i+4]
		v, err := strconv.ParseInt(o, 8, 32)
		if err != nil {
			b = append(b, s[i])
			continue
		}
		b = append(b, byte(v))
		i += 3
	}
	return string(b)
}

func GetMountpoint(source string) (string, error)

{
	entries, err := GetMountInfo()
	if err != nil {
		return "", err
	}
	for _, e := range entries {
		if e.Source == source {
			return e.MountPoint, nil
		}
	}
	return "", nil
}

func CopyTree(source, destination string, opts CopyTreeOptions) error

{
	if opts.Workers <= 0 {
		opts.Workers = runtime.GOMAXPROCS(0)
		if opts.Workers < 1 {
			opts.Workers = 1
		}
	}
	if !opts.PreservePermissions {
		opts.PreservePermissions = true
	}
	if !opts.PreserveOwnership {
		opts.PreserveOwnership = true
	}
	if !opts.PreserveTimestamps {
		opts.PreserveTimestamps = true
	}

	if err := os.MkdirAll(destination, 0o755); err != nil {
		return err
	}

	jobs := make(chan fileJob, opts.Workers*2)
	var wg sync.WaitGroup

	var firstErr error
	var errMu sync.Mutex
	setErr := func(err error) {
		errMu.Lock()
		defer errMu.Unlock()
		if firstErr == nil {
			firstErr = err
		}
	}

	progress := func(p CopyTreeProgress) {
		if opts.OnProgress != nil {
			opts.OnProgress(p)
		}
	}

	for i := 0; i < opts.Workers; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := range jobs {
				if err := copyRegularFile(j.src, j.dst, j.mode, j.uid, j.gid, j.at, j.mt, opts, progress); err != nil {
					setErr(err)
				}
			}
		}()
	}

	dirs := make([]dirMeta, 0)

	walkErr := filepath.WalkDir(source, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		rel, err := filepath.Rel(source, path)
		if err != nil {
			return err
		}
		if rel == "." {
			return nil
		}
		dst := filepath.Join(destination, rel)

		info, err := d.Info()
		if err != nil {
			return err
		}

		mode := info.Mode()
		uid, gid, at, mt := extractUnixMeta(info)

		switch {
		case mode.IsDir():
			if err := os.MkdirAll(dst, 0o755); err != nil {
				return err
			}
			dirs = append(dirs, dirMeta{path: dst, mode: mode, uid: uid, gid: gid, at: at, mt: mt})
			return nil

		case mode&os.ModeSymlink != 0:
			link, err := os.Readlink(path)
			if err != nil {
				return err
			}
			if err := os.Symlink(link, dst); err != nil {
				if errors.Is(err, os.ErrExist) {
					_ = os.Remove(dst)
					return os.Symlink(link, dst)
				}
				return err
			}
			if opts.PreserveOwnership {
				_ = os.Lchown(dst, uid, gid)
			}
			return nil

		case mode.IsRegular():
			jobs <- fileJob{src: path, dst: dst, mode: mode, uid: uid, gid: gid, at: at, mt: mt}
			return nil

		default:
			if opts.AllowSpecial {
				// Special files support can be added later via mknod.
				return nil
			}
			return fmt.Errorf("unsupported file type: %s", path)
		}
	})

	close(jobs)
	wg.Wait()

	if walkErr != nil {
		return walkErr
	}
	if firstErr != nil {
		return firstErr
	}

	// Apply dir metadata bottom-up to keep directory mtimes stable.
	for i := len(dirs) - 1; i >= 0; i-- {
		dm := dirs[i]
		if opts.PreservePermissions {
			_ = os.Chmod(dm.path, dm.mode)
		}
		if opts.PreserveOwnership {
			_ = os.Chown(dm.path, dm.uid, dm.gid)
		}
		if opts.PreserveTimestamps {
			_ = os.Chtimes(dm.path, dm.at, dm.mt)
		}
	}

	return nil
}

func copyRegularFile(src, dst string, mode os.FileMode, uid, gid int, at, mt time.Time, opts CopyTreeOptions, progress func(CopyTreeProgress)) error

{
	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
		return err
	}

	in, err := os.Open(src)
	if err != nil {
		return err
	}
	defer in.Close()

	out, err := os.OpenFile(dst, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
	if err != nil {
		return err
	}

	buf := make([]byte, 1024*1024)
	n, copyErr := io.CopyBuffer(out, in, buf)
	closeErr := out.Close()
	if copyErr != nil {
		return copyErr
	}
	if closeErr != nil {
		return closeErr
	}

	if opts.PreservePermissions {
		_ = os.Chmod(dst, mode)
	}
	if opts.PreserveOwnership {
		_ = os.Chown(dst, uid, gid)
	}
	if opts.PreserveTimestamps {
		_ = os.Chtimes(dst, at, mt)
	}

	progress(CopyTreeProgress{SourcePath: src, DestinationPath: dst, BytesCopied: n})
	return nil
}

func extractUnixMeta(info os.FileInfo) (uid, gid int, at, mt time.Time)

{
	mt = info.ModTime()
	at = mt

	st, ok := info.Sys().(*syscall.Stat_t)
	if !ok {
		return 0, 0, at, mt
	}

	uid = int(st.Uid)
	gid = int(st.Gid)

	at = time.Unix(int64(st.Atim.Sec), int64(st.Atim.Nsec))
	mt = time.Unix(int64(st.Mtim.Sec), int64(st.Mtim.Nsec))
	return uid, gid, at, mt
}

func resolveDiskSymlink(dir, value string) (string, error)

{
	p := filepath.Join(dir, value)
	_, err := os.Lstat(p)
	if err != nil {
		return "", err
	}
	resolved, err := filepath.EvalSymlinks(p)
	if err != nil {
		return "", err
	}
	return resolved, nil
}

func CopyFile(sourcePath, destinationPath string) error

{
	source, err := os.ReadFile(sourcePath)
	if err != nil {
		return err
	}
	err = os.WriteFile(destinationPath, source, 0644)
	if err != nil {
		return err
	}
	return nil
}

func IsMounted(source string, destination string) (bool, error)

{
	entries, err := GetMountInfo()
	if err != nil {
		return false, err
	}
	for _, e := range entries {
		if e.Source == source && e.MountPoint == destination {
			return true, nil
		}
	}
	return false, nil
}

func Mount(source, destination, fsType, data string, mode uintptr) error

{
	info, err := os.Stat(source)
	if err != nil {
		return err
	}

	if info.IsDir() {
		_ = os.MkdirAll(destination, 0o755)
	} else {
		file, _ := os.Create(destination)

		defer func() { _ = file.Close() }()
	}

	return syscall.Mount(source, destination, fsType, mode, data)
}

func MountBind(src, dest string) error

{
	return Mount(
		src,
		dest,
		"bind",
		"",
		syscall.MS_BIND|
			syscall.MS_REC|
			syscall.MS_RDONLY|
			syscall.MS_NOSUID|
			syscall.MS_NOEXEC|
			syscall.MS_NODEV|
			syscall.MS_PRIVATE,
	)
}

func MountOverlay(lowerDir, upperDir, workDir string) error

{
	return Mount(
		"overlay",
		lowerDir,
		"overlay",
		fmt.Sprintf(
			"lowerdir=%s,upperdir=%s,workdir=%s,userxattr",
			lowerDir, upperDir, workDir,
		),
		0,
	)
}

func MountFuseOverlay(targetDir, lowerDir, upperDir, workDir string) error

{
	// Note: implemented via kernel overlayfs to avoid spawning external commands.
	return Mount(
		"overlay",
		targetDir,
		"overlay",
		fmt.Sprintf(
			"lowerdir=%s,upperdir=%s,workdir=%s,userxattr",
			lowerDir, upperDir, workDir,
		),
		0,
	)
}

func AtomicSwap(sourcePath, destinationPath string) error

{
	orig, err := os.Open(sourcePath)
	if err != nil {
		return err
	}

	newfile, err := os.Open(destinationPath)
	if err != nil {
		return err
	}

	err = unix.Renameat2(int(orig.Fd()), sourcePath, int(newfile.Fd()), destinationPath, unix.RENAME_EXCHANGE)
	if err != nil {
		return err
	}

	return nil
}

func IsWritableDir(dir string) (bool, error)

{
	testPath := filepath.Join(dir, ".vos-sdk-writable-check")
	f, err := os.OpenFile(testPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
	if err != nil {
		if os.IsPermission(err) {
			return false, nil
		}
		return false, err
	}
	_ = f.Close()
	_ = os.Remove(testPath)
	return true, nil
}