fs

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

{
	mounts, err := os.Open("/proc/mounts")
	if err != nil {
		return false, fmt.Errorf("error opening /proc/mounts: %w", err)
	}
	defer mounts.Close()

	scanner := bufio.NewScanner(mounts)
	for scanner.Scan() {
		line := scanner.Text()
		if strings.Contains(line, source) && strings.Contains(line, 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) (err error)

{
	// TODO: Replace the command-line tool with a Go library, if available.
	c := exec.Command(
		"fuse-overlayfs",
		targetDir,
		"-o",
		fmt.Sprintf(
			"lowerdir=%s,upperdir=%s,workdir=%s",
			lowerDir, upperDir, workDir,
		),
	)
	c.Stdout = os.Stdout
	c.Stderr = os.Stderr
	return c.Run()
}

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 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 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"]

	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 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 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
}