gt/internal/files/trash.go

package files

import (
	"fmt"
	"io/fs"
	"math/rand"
	"os"
	"os/user"
	"path/filepath"
	"slices"
	"strings"
	"time"

	"git.burning.moe/celediel/gt/internal/dirs"
	"git.burning.moe/celediel/gt/internal/filter"
	"git.burning.moe/celediel/gt/internal/prompt"

	"github.com/adrg/xdg"
	"github.com/charmbracelet/log"
	"github.com/dustin/go-humanize"
	"github.com/moby/sys/mountinfo"
	"gitlab.com/tymonx/go-formatter/formatter"
	"gopkg.in/ini.v1"
)

const (
	executePerm              = fs.FileMode(0755)
	noExecutePerm            = fs.FileMode(0644)
	noExecuteUserPerm        = fs.FileMode(0600)
	randomStrLength   int    = 8
	trashName         string = ".Trash"
	trashInfoExt      string = ".trashinfo"
	trashInfoSec      string = "Trash Info"
	trashInfoPath     string = "Path"
	trashInfoDate     string = "DeletionDate"
	trashInfoDateFmt  string = "2006-01-02T15:04:05"
	trashInfoTemplate string = `[Trash Info]
Path={path}
DeletionDate={date}
`
)

var homeTrash = filepath.Join(xdg.DataHome, "Trash")

type TrashInfo struct {
	name, ogpath    string
	path, trashinfo string
	isdir           bool
	trashed         time.Time
	filesize        int64
	mode            fs.FileMode
}

func (t TrashInfo) Name() string      { return t.name }
func (t TrashInfo) TrashPath() string { return t.path }
func (t TrashInfo) Path() string      { return t.ogpath }
func (t TrashInfo) TrashInfo() string { return t.trashinfo }
func (t TrashInfo) Date() time.Time   { return t.trashed }
func (t TrashInfo) IsDir() bool       { return t.isdir }
func (t TrashInfo) Mode() fs.FileMode { return t.mode }
func (t TrashInfo) Filesize() int64   { return t.filesize }

func (t TrashInfo) String() string {
	return t.name + t.path + t.ogpath + t.trashinfo
}

func FindInAllTrashes(ogdir string, fltr *filter.Filter) Files {
	var files Files

	for _, trash := range getAllTrashes() {
		fls, err := findTrash(trash, ogdir, fltr)
		if err != nil {
			log.Errorf("error reading trash dir '%s': %s", trash, err)
			continue
		}
		files = append(files, fls...)
	}

	return files
}

func ConfirmRestore(confirm bool, fs Files) error {
	if !confirm || prompt.YesNo(fmt.Sprintf("restore %d selected files?", len(fs))) {
		log.Info("doing the thing")
		restored, err := restore(fs)
		if err != nil {
			return fmt.Errorf("restored %d files before error %w", restored, err)
		}
		fmt.Fprintf(os.Stdout, "restored %d files\n", restored)
	} else {
		fmt.Fprintf(os.Stdout, "not doing anything\n")
	}
	return nil
}

func ConfirmClean(confirm bool, fs Files) error {
	if prompt.YesNo(fmt.Sprintf("remove %d selected files permanently from the trash?", len(fs))) &&
		(!confirm || prompt.YesNo(fmt.Sprintf("really remove all these %d selected files permanently from the trash forever??", len(fs)))) {
		removed, err := remove(fs)
		if err != nil {
			return fmt.Errorf("removed %d files before error %w", removed, err)
		}
		fmt.Fprintf(os.Stdout, "removed %d files\n", removed)
	} else {
		fmt.Fprintf(os.Stdout, "not doing anything\n")
	}
	return nil
}

func ConfirmTrash(confirm bool, fs Files) error {
	if !confirm || prompt.YesNo(fmt.Sprintf("trash %d selected files?", len(fs))) {
		tfs := make([]string, 0, len(fs))
		for _, file := range fs {
			tfs = append(tfs, file.Path())
		}

		trashed := trashFiles(tfs)

		var s string
		if trashed > 1 {
			s = "s"
		}
		fmt.Fprintf(os.Stdout, "trashed %d file%s\n", trashed, s)
	} else {
		fmt.Fprintf(os.Stdout, "not doing anything\n")
		return nil
	}
	return nil
}

func findTrash(trashdir, ogdir string, fltr *filter.Filter) (Files, error) {
	log.Debugf("searching for trashinfo files in %s", trashdir)
	var files Files

	infodir := filepath.Join(trashdir, "info")
	entries, err := os.ReadDir(infodir)
	if err != nil {
		return nil, err
	}

	for _, entry := range entries {
		if entry.IsDir() || filepath.Ext(entry.Name()) != trashInfoExt {
			continue
		}

		path := filepath.Join(infodir, entry.Name())

		// trashinfo is just an ini file, so
		trashInfo, err := ini.Load(path)
		if err != nil {
			log.Errorf("error reading %s: %s", path, err)
			continue
		}

		section := trashInfo.Section(trashInfoSec)
		if section == nil {
			continue
		}

		basepath := dirs.PercentDecode(section.Key(trashInfoPath).String())
		if !strings.HasPrefix(basepath, string(os.PathSeparator)) {
			root, err := getRoot(trashdir)
			if err == nil {
				basepath = filepath.Join(root, basepath)
			}
		}

		filename := filepath.Base(basepath)
		trashedpath := strings.Replace(strings.Replace(path, "info", "files", 1), trashInfoExt, "", 1)
		info, err := os.Lstat(trashedpath)
		if err != nil {
			log.Errorf("error reading '%s': %s", trashedpath, err)
			continue
		}

		s := section.Key(trashInfoDate).Value()
		date, err := time.ParseInLocation(trashInfoDateFmt, s, time.Local)
		if err != nil {
			log.Errorf("error parsing date '%s' in trashinfo file '%s': %s", s, path, err)
			continue
		}

		if ogdir != "" && filepath.Dir(basepath) != ogdir {
			continue
		}

		var size int64
		if d, ok := loadedDirSizes[info.Name()]; ok {
			size = d.size
		} else if info.IsDir() {
			size = calculateDirSize(trashedpath)
		} else {
			size = info.Size()
		}

		if fltr.Match(info) {
			files = append(files, TrashInfo{
				name:      filename,
				path:      trashedpath,
				ogpath:    basepath,
				trashinfo: path,
				trashed:   date,
				isdir:     info.IsDir(),
				filesize:  size,
			})
		}
	}

	return files, nil
}

func trashFile(filename string) error {
	trashDir, err := getTrashDir(filename)
	if err != nil {
		return err
	}

	trashInfoFilename, outPath := getTrashFilenames(filepath.Base(filename), trashDir)

	if err := os.Rename(filename, outPath); err != nil {
		return err
	}

	var path string
	if trashDir == homeTrash {
		path = filename
	} else {
		root, err := getRoot(trashDir)
		if err != nil {
			path = filename
		} else {
			path = strings.Replace(filename, root+string(os.PathSeparator), "", 1)
		}
	}
	log.Debugf("fucking %s %s %s", filename, trashDir, path)

	trashInfo, err := formatter.Format(trashInfoTemplate, formatter.Named{
		"path": path,
		"date": time.Now().Format(trashInfoDateFmt),
	})
	if err != nil {
		return err
	}

	if err := os.WriteFile(trashInfoFilename, []byte(trashInfo), noExecuteUserPerm); err != nil {
		return err
	}

	return nil
}

func trashFiles(files []string) (trashed int) {
	for _, file := range files {
		if err := trashFile(file); err != nil {
			log.Errorf("cannot trash '%s': %s", file, err)
			continue
		}
		trashed++
	}
	return
}

func restore(files Files) (restored int, err error) {
	for _, maybeFile := range files {
		file, ok := maybeFile.(TrashInfo)
		if !ok {
			return restored, fmt.Errorf("bad file?? %s", maybeFile.Name())
		}

		var cancel bool
		outpath := dirs.PercentDecode(file.ogpath)
		log.Infof("restoring %s back to %s\n", file.name, outpath)
		if _, e := os.Lstat(outpath); e == nil {
			outpath, cancel = prompt.NewPath(outpath)
		}

		if cancel {
			continue
		}

		basedir := filepath.Dir(outpath)
		if _, e := os.Lstat(basedir); e != nil {
			if err = os.MkdirAll(basedir, executePerm); err != nil {
				return restored, err
			}
		}

		if err = os.Rename(file.path, outpath); err != nil {
			return restored, err
		}

		if err = os.Remove(file.trashinfo); err != nil {
			return restored, err
		}

		restored++
	}
	return restored, err
}

func remove(files Files) (removed int, err error) {
	for _, maybeFile := range files {
		file, ok := maybeFile.(TrashInfo)
		if !ok {
			return removed, fmt.Errorf("bad file?? %s", maybeFile.Name())
		}

		if err = os.Remove(file.path); err != nil {
			if i, e := os.Lstat(file.path); e == nil && i.IsDir() {
				err = os.RemoveAll(file.path)
				if err != nil {
					return removed, err
				}
			} else {
				return removed, err
			}
		}
		if err = os.Remove(file.trashinfo); err != nil {
			return removed, err
		}
		removed++
	}
	return removed, err
}

func randomString(length int) string {
	out := strings.Builder{}
	for range length {
		out.WriteByte(randomChar())
	}
	return out.String()
}

func randomChar() byte {
	const chars string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
	return chars[rand.Intn(len(chars))]
}

func getTrashFilenames(filename, trashDir string) (string, string) {
	var (
		filedir = filepath.Join(trashDir, "files")
		infodir = filepath.Join(trashDir, "info")
	)

	info := filepath.Join(infodir, filename+trashInfoExt)
	if _, err := os.Lstat(info); os.IsNotExist(err) {
		// doesn't exist, so use it
		path := filepath.Join(filedir, filename)
		return dirs.PercentEncode(info), dirs.PercentEncode(path)
	}

	// otherwise, try random suffixes until one works
	log.Debugf("%s exists in trash, generating random name", filename)
	var tries int
	for {
		tries++
		rando := randomString(randomStrLength)
		newInfo := filepath.Join(infodir, filename+rando+trashInfoExt)
		newFile := filepath.Join(filedir, filename+rando)
		_, infoErr := os.Lstat(newInfo)
		_, fileErr := os.Lstat(newFile)
		if os.IsNotExist(infoErr) && os.IsNotExist(fileErr) {
			path := filepath.Join(filedir, filename+rando)
			log.Debugf("settled on random name %s%s on the %s try", filename, rando, humanize.Ordinal(tries))
			return dirs.PercentEncode(newInfo), dirs.PercentEncode(path)
		}
	}
}

func getTrashDir(filename string) (string, error) {
	root, err := getRoot(filename)
	if err != nil {
		return "", err
	}

	var trashDir string
	if strings.Contains(filename, xdg.Home) {
		trashDir = filepath.Join(xdg.DataHome, trashName[1:])
	} else {
		trashDir = filepath.Clean(filepath.Join(root, trashName))
	}

	if _, err := os.Lstat(trashDir); err != nil {
		usr, _ := user.Current()
		trashDir += "-" + usr.Uid
		if err := os.Mkdir(trashDir, executePerm); err != nil {
			return "", fmt.Errorf("%s%s does not exist and creation of %s failed", root, trashName, trashDir)
		}
	}

	if link, err := os.Readlink(trashDir); err == nil && link != "" {
		return "", fmt.Errorf("trash dir %s is a symbolic link", trashDir)
	}

	return trashDir, nil
}

func getRoot(path string) (string, error) {
	var roots []string

	// populate a list of mountpoints on the system
	_, err := mountinfo.GetMounts(func(i *mountinfo.Info) (skip bool, stop bool) {
		roots = append(roots, i.Mountpoint)
		return false, false
	})
	if err != nil {
		log.Error(err)
	}

	var depth uint8 = 1 // 255 seems a reasonable recursion maximum
	current := path

	// recursively search upwards by using filepath.Clean and ..
	for {
		if depth == 0 {
			return path, fmt.Errorf("reached max depth getting root of %s", path)
		}

		current = filepath.Clean(current)

		if current == string(os.PathSeparator) || slices.Contains(roots, current) {
			return current, nil
		}

		current += string(os.PathSeparator) + ".."
		depth++
	}
}

func getAllTrashes() []string {
	trashes := []string{homeTrash}
	usr, err := user.Current()
	if err != nil {
		log.Error(err)
	}

	_, err = mountinfo.GetMounts(func(mount *mountinfo.Info) (skip bool, stop bool) {
		point := mount.Mountpoint
		trashDir := filepath.Clean(filepath.Join(point, trashName))
		userTrashDir := trashDir + "-" + usr.Uid

		if _, err := os.Lstat(trashDir); err == nil {
			trashes = append(trashes, trashDir)
		}

		if _, err := os.Lstat(userTrashDir); err == nil {
			trashes = append(trashes, userTrashDir)
		}

		return false, false
	})

	if err != nil {
		log.Errorf("error reading mounts: %s", err)
		return nil
	}

	return trashes
}