core

func (*DiskManager) GetPartitionByLabel(label string) (Partition, error)
{
	PrintVerboseInfo("DiskManager.GetPartitionByLabel", "retrieving partitions")

	partitions, err := d.GetPartitions("")
	if err != nil {
		PrintVerboseErr("DiskManager.GetPartitionByLabel", 0, err)
		return Partition{}, err
	}

	for _, part := range partitions {
		if part.Label == label {
			PrintVerboseInfo("DiskManager.GetPartitionByLabel", "Partition with UUID", part.Uuid, "has label", label)
			return part, nil
		}
	}

	errMsg := fmt.Errorf("could not find partition with label %s", label)
	PrintVerboseErr("DiskManager.GetPartitionByLabel", 1, errMsg)
	return Partition{}, errMsg
}

func (*DiskManager) GetPartitions(device string) ([]Partition, error)
{
	PrintVerboseInfo("DiskManager.getPartitions", "running...")

	output, err := exec.Command("lsblk", "-J", "-o", "NAME,FSTYPE,LABEL,MOUNTPOINT,UUID").Output()
	if err != nil {
		PrintVerboseErr("DiskManager.getPartitions", 0, err)
		return nil, err
	}

	var partitions struct {
		BlockDevices []struct {
			Name     string     `json:"name"`
			Type     string     `json:"type"`
			Children []Children `json:"children"`
		} `json:"blockdevices"`
	}

	if err := json.Unmarshal(output, &partitions); err != nil {
		PrintVerboseErr("DiskManager.getPartitions", 1, err)
		return nil, err
	}

	var result []Partition
	for _, blockDevice := range partitions.BlockDevices {
		if device != "" && blockDevice.Name != device {
			continue
		}

		iterChildren(&blockDevice.Children, &result)
	}

	PrintVerboseInfo("DiskManager.getPartitions", "successfully got partitions for disk", device)

	return result, nil
}

func (*Partition) Mount(destination string) error
{
	PrintVerboseInfo("Partition.Mount", "running...")

	if _, err := os.Stat(destination); os.IsNotExist(err) {
		if err := os.MkdirAll(destination, 0755); err != nil {
			PrintVerboseErr("Partition.Mount", 0, err)
			return err
		}
	}

	devicePath := "/dev/"
	if p.IsDevMapper() {
		devicePath += "mapper/"
	}
	devicePath += p.Device

	err := syscall.Mount(devicePath, destination, p.FsType, 0, "")
	if err != nil {
		PrintVerboseErr("Partition.Mount", 1, err)
		return err
	}

	p.MountPoint = destination
	PrintVerboseInfo("Partition.Mount", "successfully mounted", devicePath, "to", destination)
	return nil
}

func (*Partition) Unmount() error
{
	PrintVerboseInfo("Partition.Unmount", "running...")

	if p.MountPoint == "" {
		PrintVerboseErr("Partition.Unmount", 0, errors.New("no mount point"))
		return errors.New("no mount point")
	}

	err := syscall.Unmount(p.MountPoint, 0)
	if err != nil {
		PrintVerboseErr("Partition.Unmount", 1, err)
		return err
	}

	PrintVerboseInfo("Partition.Unmount", "successfully unmounted", p.MountPoint)
	p.MountPoint = ""

	return nil
}

func (*ABImage) WriteTo(dest string) error
{
	PrintVerboseInfo("ABImage.WriteTo", "running...")

	if _, err := os.Stat(dest); os.IsNotExist(err) {
		err = os.MkdirAll(dest, 0755)
		if err != nil {
			PrintVerboseErr("ABImage.WriteTo", 0, err)
			return err
		}
	}

	imagePath := filepath.Join(dest, "abimage.abr")

	abimage, err := json.Marshal(a)
	if err != nil {
		PrintVerboseErr("ABImage.WriteTo", 1, err)
		return err
	}

	err = os.WriteFile(imagePath, abimage, 0644)
	if err != nil {
		PrintVerboseErr("ABImage.WriteTo", 2, err)
		return err
	}

	PrintVerboseInfo("ABImage.WriteTo", "successfully wrote abimage.abr to "+imagePath)

	return nil
}

func (*Chroot) Close() error
{
	PrintVerboseInfo("Chroot.Close", "running...")

	err := syscall.Unmount(filepath.Join(c.root, "/dev/pts"), 0)
	if err != nil {
		PrintVerboseErr("Chroot.Close", 0, err)
		return err
	}

	mountList := ReservedMounts
	if c.etcMounted {
		mountList = append(mountList, "/etc")
	}
	mountList = append(mountList, "")

	for _, mount := range mountList {
		if mount == "/dev/pts" {
			continue
		}

		mountDir := filepath.Join(c.root, mount)
		PrintVerboseInfo("Chroot.Close", "unmounting", mountDir)
		err := syscall.Unmount(mountDir, 0)
		if err != nil {
			PrintVerboseErr("Chroot.Close", 1, err)
			return err
		}
	}

	PrintVerboseInfo("Chroot.Close", "successfully closed.")
	return nil
}

func (*Chroot) Execute(cmd string) error
{
	PrintVerboseInfo("Chroot.Execute", "running...")

	PrintVerboseInfo("Chroot.Execute", "running command:", cmd)
	e := exec.Command("chroot", c.root, "/bin/sh", "-c", cmd)
	e.Stdout = os.Stdout
	e.Stderr = os.Stderr
	e.Stdin = os.Stdin
	err := e.Run()
	if err != nil {
		PrintVerboseErr("Chroot.Execute", 0, err)
		return err
	}

	PrintVerboseInfo("Chroot.Execute", "successfully ran.")
	return nil
}

func (*Chroot) ExecuteCmds(cmds []string) error
{
	PrintVerboseInfo("Chroot.ExecuteCmds", "running...")

	for _, cmd := range cmds {
		err := c.Execute(cmd)
		if err != nil {
			PrintVerboseErr("Chroot.ExecuteCmds", 0, err)
			return err
		}
	}

	PrintVerboseInfo("Chroot.ExecuteCmds", "successfully ran.")
	return nil
}

func (*ABRootManager) GetPartitions() error
{
	PrintVerboseInfo("ABRootManager.GetRootPartitions", "running...")

	diskM := NewDiskManager()
	rootLabels := []string{settings.Cnf.PartLabelA, settings.Cnf.PartLabelB}
	for _, label := range rootLabels {
		partition, err := diskM.GetPartitionByLabel(label)
		if err != nil {
			PrintVerboseErr("ABRootManager.GetRootPartitions", 0, err)
			return err
		}

		identifier, err := a.IdentifyPartition(partition)
		if err != nil {
			PrintVerboseErr("ABRootManager.GetRootPartitions", 1, err)
			return err
		}

		isCurrent := a.IsCurrent(partition)
		a.Partitions = append(a.Partitions, ABRootPartition{
			Label:        partition.Label,
			IdentifiedAs: identifier,
			Partition:    partition,
			MountPoint:   partition.MountPoint,
			MountOptions: partition.MountOptions,
			Uuid:         partition.Uuid,
			FsType:       partition.FsType,
			Current:      isCurrent,
		})
	}

	partition, err := diskM.GetPartitionByLabel(settings.Cnf.PartLabelVar)
	if err != nil {
		PrintVerboseErr("ABRootManager.GetRootPartitions", 2, err)
		return err
	}
	a.VarPartition = partition

	PrintVerboseInfo("ABRootManager.GetRootPartitions", "successfully got root partitions")

	return nil
}

func (*ABRootManager) IsCurrent(partition Partition) bool
{
	PrintVerboseInfo("ABRootManager.IsCurrent", "running...")

	if partition.MountPoint == "/" {
		PrintVerboseInfo("ABRootManager.IsCurrent", "partition is current")
		return true
	}

	PrintVerboseInfo("ABRootManager.IsCurrent", "partition is not current")
	return false
}

func (*ABRootManager) IdentifyPartition(partition Partition) (identifiedAs string, err error)
{
	PrintVerboseInfo("ABRootManager.IdentifyPartition", "running...")

	if partition.Label == settings.Cnf.PartLabelA || partition.Label == settings.Cnf.PartLabelB {
		if partition.MountPoint == "/" {
			PrintVerboseInfo("ABRootManager.IdentifyPartition", "partition is present")
			return "present", nil
		}

		PrintVerboseInfo("ABRootManager.IdentifyPartition", "partition is future")
		return "future", nil
	}

	err = errors.New("partition is not managed by ABRoot")
	PrintVerboseErr("ABRootManager.IdentifyPartition", 0, err)
	return "", err
}

func (*ABRootManager) GetPresent() (partition ABRootPartition, err error)
{
	PrintVerboseInfo("ABRootManager.GetPresent", "running...")

	for _, partition := range a.Partitions {
		if partition.IdentifiedAs == "present" {
			PrintVerboseInfo("ABRootManager.GetPresent", "successfully got present partition")
			return partition, nil
		}
	}

	err = errors.New("present partition not found")
	PrintVerboseErr("ABRootManager.GetPresent", 0, err)
	return ABRootPartition{}, err
}

func (*ABRootManager) GetFuture() (partition ABRootPartition, err error)
{
	PrintVerboseInfo("ABRootManager.GetFuture", "running...")

	for _, partition := range a.Partitions {
		if partition.IdentifiedAs == "future" {
			PrintVerboseInfo("ABRootManager.GetFuture", "successfully got future partition")
			return partition, nil
		}
	}

	err = errors.New("future partition not found")
	PrintVerboseErr("ABRootManager.GetFuture", 0, err)
	return ABRootPartition{}, err
}

func (*ABRootManager) GetOther() (partition ABRootPartition, err error)
{
	PrintVerboseInfo("ABRootManager.GetOther", "running...")

	present, err := a.GetPresent()
	if err != nil {
		PrintVerboseErr("ABRootManager.GetOther", 0, err)
		return ABRootPartition{}, err
	}

	if present.Label == settings.Cnf.PartLabelA {
		PrintVerboseInfo("ABRootManager.GetOther", "successfully got other partition")
		return a.GetPartition(settings.Cnf.PartLabelB)
	}

	PrintVerboseInfo("ABRootManager.GetOther", "successfully got other partition")
	return a.GetPartition(settings.Cnf.PartLabelA)
}

func (*ABRootManager) GetPartition(label string) (partition ABRootPartition, err error)
{
	PrintVerboseInfo("ABRootManager.GetPartition", "running...")

	for _, partition := range a.Partitions {
		if partition.Label == label {
			PrintVerboseInfo("ABRootManager.GetPartition", "successfully got partition")
			return partition, nil
		}
	}

	err = errors.New("partition not found")
	PrintVerboseErr("ABRootManager.GetPartition", 0, err)
	return ABRootPartition{}, err
}

func (*ABRootManager) GetBoot() (partition Partition, err error)
{
	PrintVerboseInfo("ABRootManager.GetBoot", "running...")

	diskM := NewDiskManager()
	part, err := diskM.GetPartitionByLabel(settings.Cnf.PartLabelBoot)
	if err != nil {
		err = errors.New("boot partition not found")
		PrintVerboseErr("ABRootManager.GetBoot", 0, err)

		return Partition{}, err
	}

	PrintVerboseInfo("ABRootManager.GetBoot", "successfully got boot partition")
	return part, nil
}

func (*ABRootManager) GetInit() (partition Partition, err error)
{
	PrintVerboseInfo("ABRootManager.GetInit", "running...")

	// Make sure Thin-Provisioning is properly configured
	if !settings.Cnf.ThinProvisioning || settings.Cnf.ThinInitVolume == "" {
		return Partition{}, errors.New("ABRootManager.GetInit: error: system is not configured for thin-provisioning")
	}

	diskM := NewDiskManager()
	part, err := diskM.GetPartitionByLabel(settings.Cnf.ThinInitVolume)
	if err != nil {
		err = errors.New("init volume not found")
		PrintVerboseErr("ABRootManager.GetInit", 0, err)

		return Partition{}, err
	}

	PrintVerboseInfo("ABRootManager.GetInit", "successfully got init volume")
	return part, nil
}

func (*PackageManager) Add(pkg string) error
{
	PrintVerboseInfo("PackageManager.Add", "running...")

	// Check for package manager status and user agreement
	err := p.CheckStatus()
	if err != nil {
		PrintVerboseErr("PackageManager.Add", 0, err)
		return err
	}

	// Check if package was removed before
	packageWasRemoved := false
	removedIndex := -1
	pkgsRemove, err := p.GetRemovePackages()
	if err != nil {
		PrintVerboseErr("PackageManager.Add", 2.1, err)
		return err
	}
	for i, rp := range pkgsRemove {
		if rp == pkg {
			packageWasRemoved = true
			removedIndex = i
			break
		}
	}

	// packages that have been removed by the user aren't always in the repo
	if !packageWasRemoved {
		// Check if package exists in repo
		for _, _pkg := range strings.Split(pkg, " ") {
			err := p.ExistsInRepo(_pkg)
			if err != nil {
				PrintVerboseErr("PackageManager.Add", 0, err)
				return err
			}
		}
	}

	// If package was removed by the user, simply remove it from packages.remove
	if packageWasRemoved {
		pkgsRemove = append(pkgsRemove[:removedIndex], pkgsRemove[removedIndex+1:]...)
		PrintVerboseInfo("PackageManager.Add", "unsetting manually removed package")
		return p.writeRemovePackages(pkgsRemove)
	}

	// Abort if package is already added
	pkgsAdd, err := p.GetAddPackages()
	if err != nil {
		PrintVerboseErr("PackageManager.Add", 3, err)
		return err
	}
	for _, p := range pkgsAdd {
		if p == pkg {
			PrintVerboseInfo("PackageManager.Add", "package already added")
			return nil
		}
	}

	pkgsAdd = append(pkgsAdd, pkg)

	PrintVerboseInfo("PackageManager.Add", "writing packages.add")
	return p.writeAddPackages(pkgsAdd)
}

func (*PackageManager) Remove(pkg string) error
{
	PrintVerboseInfo("PackageManager.Remove", "running...")

	// Check for package manager status and user agreement
	err := p.CheckStatus()
	if err != nil {
		PrintVerboseErr("PackageManager.Remove", 0, err)
		return err
	}

	// Check if package exists in packages.add
	pkgsAddList, err := p.GetAddPackagesString(" ")
	if err != nil {
		PrintVerboseErr("PackageManager.Remove", 1, err)
		return err
	}
	if !strings.Contains(pkgsAddList, pkg) {

		// Check if package exists in repo
		// FIXME: this should also check if the package is installed in
		// different systems, not just debian-based ditros.. Since this is a
		// distro specific feature, I'm leaving it as is for now.
		err = p.ExistsOnSystem(pkg)
		if err != nil {
			PrintVerboseErr("PackageManager.Remove", 1, err)
			return err
		}
	}

	// If package was added by the user, simply remove it from packages.add
	pkgsAdd, err := p.GetAddPackages()
	if err != nil {
		PrintVerboseErr("PackageManager.Remove", 4, err)
		return err
	}
	for i, ap := range pkgsAdd {
		if ap == pkg {
			pkgsAdd = append(pkgsAdd[:i], pkgsAdd[i+1:]...)
			PrintVerboseInfo("PackageManager.Remove", "removing manually added package")
			return p.writeAddPackages(pkgsAdd)
		}
	}

	// Abort if package is already removed
	pkgsRemove, err := p.GetRemovePackages()
	if err != nil {
		PrintVerboseErr("PackageManager.Remove", 5, err)
		return err
	}
	for _, p := range pkgsRemove {
		if p == pkg {
			PrintVerboseInfo("PackageManager.Remove", "package already removed")
			return nil
		}
	}

	pkgsRemove = append(pkgsRemove, pkg)

	// Otherwise, add package to packages.remove
	PrintVerboseInfo("PackageManager.Remove", "writing packages.remove")
	return p.writeRemovePackages(pkgsRemove)
}

func (*PackageManager) GetUnstagedPackages(rootPath string) (toBeAdded, toBeRemoved []string, err error)
{
	PrintVerboseInfo("PackageManager.GetUnstagedPackages", "running...")
	alreadyAdded, alreadyRemoved, err := p.GetCurrentlyInstalledPackages(rootPath)
	if err != nil {
		PrintVerboseErr("PackageManager.GetUnstagedPackages", 1, err)
		return toBeAdded, toBeRemoved, err
	}

	shouldBeAdded, err := p.GetAddPackages()
	if err != nil {
		PrintVerboseErr("PackageManager.GetUnstagedPackages", 2, err)
		return toBeAdded, toBeRemoved, err
	}

	shouldBeRemoved, err := p.GetRemovePackages()
	if err != nil {
		PrintVerboseErr("PackageManager.GetUnstagedPackages", 2, err)
		return toBeAdded, toBeRemoved, err
	}

	addNew, removeAdded := sliceDifference(shouldBeAdded, alreadyAdded)
	removeNew, addRemoved := sliceDifference(shouldBeRemoved, alreadyRemoved)

	toBeAdded = append(addNew, addRemoved...)
	toBeRemoved = append(removeNew, removeAdded...)

	return toBeAdded, toBeRemoved, nil
}

func (*PackageManager) GetAddPackagesString(sep string) (string, error)
{
	PrintVerboseInfo("PackageManager.GetAddPackagesString", "running...")
	pkgs, err := p.GetAddPackages()
	if err != nil {
		PrintVerboseErr("PackageManager.GetAddPackagesString", 0, err)
		return "", err
	}

	PrintVerboseInfo("PackageManager.GetAddPackagesString", "done")
	return strings.Join(pkgs, sep), nil
}

func (*PackageManager) GetRemovePackagesString(sep string) (string, error)
{
	PrintVerboseInfo("PackageManager.GetRemovePackagesString", "running...")
	pkgs, err := p.GetRemovePackages()
	if err != nil {
		PrintVerboseErr("PackageManager.GetRemovePackagesString", 0, err)
		return "", err
	}

	PrintVerboseInfo("PackageManager.GetRemovePackagesString", "done")
	return strings.Join(pkgs, sep), nil
}

func (*PackageManager) getPackages(file string) ([]string, error)
{
	PrintVerboseInfo("PackageManager.getPackages", "running...")

	pkgs := []string{}
	f, err := os.Open(filepath.Join(p.baseDir, file))
	if err != nil {
		PrintVerboseErr("PackageManager.getPackages", 0, err)
		return pkgs, err
	}
	defer f.Close()

	b, err := io.ReadAll(f)
	if err != nil {
		PrintVerboseErr("PackageManager.getPackages", 1, err)
		return pkgs, err
	}

	for _, pkg := range strings.Split(string(b), "\n") {
		pkgTrimmed := strings.TrimSpace(pkg)
		if pkgTrimmed != "" {
			pkgs = append(pkgs, pkgTrimmed)
		}
	}

	PrintVerboseInfo("PackageManager.getPackages", "returning packages")
	return pkgs, nil
}

func (*PackageManager) writePackages(file string, pkgs []string) error
{
	PrintVerboseInfo("PackageManager.writePackages", "running...")

	f, err := os.Create(filepath.Join(p.baseDir, file))
	if err != nil {
		PrintVerboseErr("PackageManager.writePackages", 0, err)
		return err
	}
	defer f.Close()

	for _, pkg := range pkgs {
		if pkg == "" {
			continue
		}

		_, err = fmt.Fprintf(f, "%s\n", pkg)
		if err != nil {
			PrintVerboseErr("PackageManager.writePackages", 1, err)
			return err
		}
	}

	PrintVerboseInfo("PackageManager.writePackages", "packages written")
	return nil
}

func (*PackageManager) createPackageCommands() (commands []string, err error)
{
	addPkgs, err := p.GetAddPackagesString(" ")
	if err != nil {
		PrintVerboseErr("PackageManager.processUpgradePackages", 0, err)
		return
	}

	removePkgs, err := p.GetRemovePackagesString(" ")
	if err != nil {
		PrintVerboseErr("PackageManager.processUpgradePackages", 1, err)
		return
	}

	if len(addPkgs) == 0 && len(removePkgs) == 0 {
		PrintVerboseInfo("PackageManager.processUpgradePackages", "no packages to install or remove")
		return []string{}, nil
	}

	if removePkgs != "" {
		finalRemovePkgs := fmt.Sprintf("%s %s", settings.Cnf.IPkgMngRm, removePkgs)
		commands = append(commands, finalRemovePkgs)
	}

	if addPkgs != "" {
		finalAddPkgs := fmt.Sprintf("%s %s", settings.Cnf.IPkgMngAdd, addPkgs)
		commands = append(commands, finalAddPkgs)
	}

	return commands, nil
}

func (*PackageManager) GetFinalCmd() (string, error)
{
	PrintVerboseInfo("PackageManager.GetFinalCmd", "running...")

	commands, err := p.createPackageCommands()
	if err != nil {
		return "", err
	}

	if len(commands) == 0 {
		return "", nil
	}

	preExec := settings.Cnf.IPkgMngPre
	postExec := settings.Cnf.IPkgMngPost
	if preExec != "" {
		commands = append([]string{preExec}, commands...)
	}
	if postExec != "" {
		commands = append(commands, postExec)
	}

	cmd := strings.Join(commands, " && ")

	PrintVerboseInfo("PackageManager.GetFinalCmd", "returning cmd: "+cmd)
	return cmd, nil
}

func (*PackageManager) getSummary() (string, error)
{
	if p.CheckStatus() != nil {
		return "", nil
	}

	addPkgs, err := p.GetAddPackages()
	if err != nil {
		if errors.Is(err, &os.PathError{}) {
			addPkgs = []string{}
		} else {
			return "", err
		}
	}
	removePkgs, err := p.GetRemovePackages()
	if err != nil {
		if errors.Is(err, &os.PathError{}) {
			removePkgs = []string{}
		} else {
			return "", err
		}
	}

	// GetPackages returns slices with one empty element if there are no packages
	if len(addPkgs) == 1 && addPkgs[0] == "" {
		addPkgs = []string{}
	}
	if len(removePkgs) == 1 && removePkgs[0] == "" {
		removePkgs = []string{}
	}

	summary := ""

	for _, pkg := range addPkgs {
		summary += "+ " + pkg + "\n"
	}
	for _, pkg := range removePkgs {
		summary += "- " + pkg + "\n"
	}

	return summary, nil
}

func (*PackageManager) WriteSummaryToRoot(rootPath string) error
{
	summaryFilePath := filepath.Join(rootPath, summaryFileLocation)

	summary, err := p.getSummary()
	if err != nil {
		return err
	}
	if summary == "" {
		return nil
	}
	summaryFile, err := os.Create(summaryFilePath)
	if err != nil {
		return err
	}
	defer summaryFile.Close()
	err = summaryFile.Chmod(0o644)
	if err != nil {
		return err
	}
	_, err = summaryFile.WriteString(summary)
	if err != nil {
		return err
	}

	return nil
}

func (*PackageManager) GetCurrentlyInstalledPackages(rootPath string) (added []string, removed []string, err error)
{
	summaryFilePath := filepath.Join(rootPath, summaryFileLocation)

	if _, err := os.Stat(summaryFilePath); errors.Is(err, os.ErrNotExist) {
		return added, removed, nil
	}

	content, err := os.ReadFile(summaryFilePath)
	if err != nil {
		PrintVerboseErr("PackageManager.GetCurrentlyInstalledPackages", 1, err)
		return added, removed, err
	}

	for _, line := range strings.Split(string(content), "\n") {
		addedPkg, isAdded := strings.CutPrefix(line, "+ ")
		if isAdded {
			added = append(added, addedPkg)
			continue
		}
		removedPkg, isRemoved := strings.CutPrefix(line, "- ")
		if isRemoved {
			removed = append(removed, removedPkg)
			continue
		}
		PrintVerboseWarn("PackageManager.GetCurrentlyInstalledPackages", 1, "line "+line+" is not a valid package string")
	}

	return added, removed, nil
}

func (*PackageManager) ExistsInRepo(pkg string) error
{
	PrintVerboseInfo("PackageManager.ExistsInRepo", "running...")

	ok, err := assertPkgMngApiSetUp()
	if err != nil {
		return err
	}
	if !ok {
		return nil
	}

	url := strings.Replace(settings.Cnf.IPkgMngApi, "{packageName}", pkg, 1)
	PrintVerboseInfo("PackageManager.ExistsInRepo", "checking if package exists in repo: "+url)

	resp, err := http.Get(url)
	if err != nil {
		PrintVerboseErr("PackageManager.ExistsInRepo", 0, err)
		return err
	}

	if resp.StatusCode != 200 {
		PrintVerboseInfo("PackageManager.ExistsInRepo", "package does not exist in repo")
		return fmt.Errorf("package does not exist in repo: %s", pkg)
	}

	PrintVerboseInfo("PackageManager.ExistsInRepo", "package exists in repo")
	return nil
}

func (*PackageManager) ExistsOnSystem(pkg string) error
{
	PrintVerboseInfo("PackageManager.ExistsOnSystem", "running...")

	PrintVerboseInfo("PackageManager.ExistsInRepo", "checking if package "+pkg+" exists on system: ")

	packageListFile, err := os.ReadFile("/var/lib/dpkg/status")
	if err != nil {
		PrintVerboseErr("PackageManager.ExistsOnSystem", 0, err)
		return p.ExistsInRepo(pkg)
	}

	if !strings.Contains(string(packageListFile), "Package: "+pkg) {
		PrintVerboseInfo("PackageManager.ExistsInRepo", "package does not exist on system")
		return fmt.Errorf("package does not exist on system: %s", pkg)
	}

	PrintVerboseInfo("PackageManager.ExistsInRepo", "package exists on system")
	return nil
}

func (*PackageManager) AcceptUserAgreement() error
{
	PrintVerboseInfo("PackageManager.AcceptUserAgreement", "running...")

	if p.Status != PKG_MNG_REQ_AGREEMENT {
		PrintVerboseInfo("PackageManager.AcceptUserAgreement", "package manager is not in agreement mode")
		return nil
	}

	err := os.WriteFile(
		PkgManagerUserAgreementFile,
		[]byte(time.Now().String()),
		0o644,
	)
	if err != nil {
		PrintVerboseErr("PackageManager.AcceptUserAgreement", 0, err)
		return err
	}

	return nil
}

func (*PackageManager) GetUserAgreementStatus() bool
{
	PrintVerboseInfo("PackageManager.GetUserAgreementStatus", "running...")

	if p.Status != PKG_MNG_REQ_AGREEMENT {
		PrintVerboseInfo("PackageManager.GetUserAgreementStatus", "package manager is not in agreement mode")
		return true
	}

	_, err := os.Stat(PkgManagerUserAgreementFile)
	if err != nil {
		PrintVerboseInfo("PackageManager.GetUserAgreementStatus", "user has not accepted the agreement")
		return false
	}

	PrintVerboseInfo("PackageManager.GetUserAgreementStatus", "user has accepted the agreement")
	return true
}

func (*PackageManager) CheckStatus() error
{
	PrintVerboseInfo("PackageManager.CheckStatus", "running...")

	// Check if package manager is enabled
	if p.Status == PKG_MNG_DISABLED {
		PrintVerboseInfo("PackageManager.CheckStatus", "package manager is disabled")
		return nil
	}

	// Check if user has accepted the package manager agreement
	if p.Status == PKG_MNG_REQ_AGREEMENT {
		if !p.GetUserAgreementStatus() {
			PrintVerboseInfo("PackageManager.CheckStatus", "package manager agreement not accepted")
			err := errors.New("package manager agreement not accepted")
			return err
		}
	}

	PrintVerboseInfo("PackageManager.CheckStatus", "package manager is enabled")
	return nil
}

func (*Grub) IsBootedIntoPresentRoot() (bool, error)
{
	PrintVerboseInfo("Grub.IsBootedIntoPresentRoot", "running...")

	a := NewABRootManager()
	future, err := a.GetFuture()
	if err != nil {
		return false, err
	}

	if g.FutureRoot == "a" {
		PrintVerboseInfo("Grub.IsBootedIntoPresentRoot", "done")
		return future.Label == settings.Cnf.PartLabelA, nil
	} else {
		PrintVerboseInfo("Grub.IsBootedIntoPresentRoot", "done")
		return future.Label == settings.Cnf.PartLabelB, nil
	}
}

func (*ImageRecipe) Write(path string) error
{
	PrintVerboseInfo("ImageRecipe.Write", "running...")

	// create file
	file, err := os.Create(path)
	if err != nil {
		PrintVerboseErr("ImageRecipe.Write", 0, err)
		return err
	}
	defer file.Close()

	// write from
	_, err = file.WriteString(fmt.Sprintf("FROM %s\n", c.From))
	if err != nil {
		PrintVerboseErr("ImageRecipe.Write", 1, err)
		return err
	}

	// write labels
	for key, value := range c.Labels {
		_, err = file.WriteString(fmt.Sprintf("LABEL %s=%s\n", key, value))
		if err != nil {
			PrintVerboseErr("ImageRecipe.Write", 2, err)
			return err
		}
	}

	// write args
	for key, value := range c.Args {
		_, err = file.WriteString(fmt.Sprintf("ARG %s=%s\n", key, value))
		if err != nil {
			PrintVerboseErr("ImageRecipe.Write", 3, err)
			return err
		}
	}

	// write content
	_, err = file.WriteString(c.Content)
	if err != nil {
		PrintVerboseErr("ImageRecipe.Write", 4, err)
		return err
	}

	PrintVerboseInfo("ImageRecipe.Write", "done")
	return nil
}

func (*ABSystem) CheckAll() error
{
	PrintVerboseInfo("ABSystem.CheckAll", "running...")

	err := s.Checks.PerformAllChecks()
	if err != nil {
		PrintVerboseErr("ABSystem.CheckAll", 0, err)
		return err
	}

	PrintVerboseInfo("ABSystem.CheckAll", "all checks passed")
	return nil
}

func (*ABSystem) Rebase(name string, dryRun bool) error
{

	if name == "" {
		return fmt.Errorf("no image provided")
	}

	if strings.Contains(name, ".") {
		registrySplit := strings.SplitN(name, "/", 2)
		settings.Cnf.Registry = registrySplit[0]
		name = registrySplit[1]
	}
	nameTagSplit := strings.Split(name, ":")
	name = nameTagSplit[0]
	if len(nameTagSplit) < 1 {
		fmt.Errorf("No tag provided")
	}
	settings.Cnf.Tag = nameTagSplit[1]
	if name != "" {
		settings.Cnf.Name = name
	}

	_, _, err := s.CheckUpdate()
	if err != nil {
		return err
	}

	if !dryRun {
		err := settings.WriteConfigToFile(settings.CnfPathAdmin)
		if err != nil {
			return err
		}
	}

	return nil

}

func (*ABSystem) RunOperation(operation ABSystemOperation, deleteBeforeCopy bool, dryRun bool) error
{
	PrintVerboseInfo("ABSystem.RunOperation", "starting", operation)

	cq := goodies.NewCleanupQueue()
	defer cq.Run()

	// Stage 0: Check if upgrade is possible
	// -------------------------------------
	PrintVerboseSimple("[Stage 0] -------- ABSystemRunOperation")

	if s.finishedFileExists() {
		PrintVerboseWarn("ABSystem.RunOperation", 0, "reboot required")
		return errors.New("another operation finished successfully, a reboot is required")
	}

	err := s.LockOperation()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 0.1, "could not create lock file:", err)
		return fmt.Errorf("could not create lock file: %w", err)
	}

	cq.Add(func(args ...interface{}) error {
		return s.UnlockOperation()
	}, nil, 100, &goodies.NoErrorHandler{}, false)

	// removes the finalizing file if it exists
	err = s.removeFinalizingFile()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 0.2, err)
		return err
	}

	// Stage 1: Check if there is an update available
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 1] -------- ABSystemRunOperation")

	if UserStopRequested() {
		err = ErrUserStopped
		PrintVerboseErr("ABSystem.RunOperation", 2, err)
		return err
	}

	var imageDigest digest.Digest
	if operation != INITRAMFS {
		var res bool
		imageDigest, res, err = s.CheckUpdate()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 1, err)
			return err
		}
		if !res {
			if operation != FORCE_UPGRADE && operation != APPLY {
				PrintVerboseErr("ABSystem.RunOperation", 1.1, err)
				return ErrNoUpdate
			}
			imageDigest = s.CurImage.Digest
			if operation == FORCE_UPGRADE {
				PrintVerboseWarn("ABSystem.RunOperation", 1.2, "No update available but --force is set. Proceeding...")
			}
		}
	} else {
		imageDigest = s.CurImage.Digest
	}

	// Stage 2: Get the present root, future root and boot partitions,
	// 			mount future to /part-future and clean up
	// 			old /part-future/new directory (it is
	// 			possible that last transaction was interrupted
	// 			before the clean up was done).
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 2] -------- ABSystemRunOperation")

	if UserStopRequested() {
		err = ErrUserStopped
		PrintVerboseErr("ABSystem.RunOperation", 2, err)
		return err
	}

	partPresent, err := s.RootM.GetPresent()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 2.05, err)
		return err
	}

	partFuture, err := s.RootM.GetFuture()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 2.1, err)
		return err
	}

	partBoot, err := s.RootM.GetBoot()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 2.2, err)
		return err
	}

	partFuture.Partition.Unmount() // just in case
	partBoot.Unmount()

	futureRoot := "/part-future"
	err = partFuture.Partition.Mount(futureRoot)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 2.3, err)
		return err
	}

	cq.Add(func(args ...interface{}) error {
		return partFuture.Partition.Unmount()
	}, nil, 90, &goodies.NoErrorHandler{}, false)

	// Stage 3: Make a imageRecipe with user packages
	//         	then download the image
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 3] -------- ABSystemRunOperation")

	if UserStopRequested() {
		err = ErrUserStopped
		PrintVerboseErr("ABSystem.RunOperation", 2, err)
		return err
	}

	// Stage 3.1: Delete old images
	if !dryRun {
		err = DeleteAllButLatestImage()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 3.1, err)
			return err
		}
	}

	labels := map[string]string{
		"maintainer":  "'Generated by ABRoot'",
		"ABRoot.root": partFuture.Label,
	}
	args := map[string]string{}
	pkgM, err := NewPackageManager(false)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 3.2, err)
		return err
	}

	pkgsFinal, err := pkgM.GetFinalCmd()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 3.3, err)
	}
	if pkgsFinal == "" {
		pkgsFinal = "true"
	}
	content := `RUN ` + pkgsFinal

	var imageName string
	switch operation {
	case INITRAMFS:
		imageName, err = RetrieveImageForRoot(partPresent.Label)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 3.4, err)
			return err
		}
		// Handle case where an image for the current root may not exist
		// in storage
		if imageName == "" {
			imageName = settings.GetFullImageNameWithTag()
		}
	default:
		imageName = settings.GetFullImageName()
		imageName += "@" + imageDigest.String()
		labels["ABRoot.BaseImageDigest"] = imageDigest.String()
	}

	imageRecipe := NewImageRecipe(
		imageName,
		labels,
		args,
		content,
	)

	// Stage 3.2: Download image
	if !dryRun {
		err = OciPullImage(imageName)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 3.5, err)
			return err
		}
	}

	// Stage 4: Extract the rootfs
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 4] -------- ABSystemRunOperation")

	if UserStopRequested() {
		err = ErrUserStopped
		PrintVerboseErr("ABSystem.RunOperation", 2, err)
		return err
	}

	err = s.createFinalizingFile()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 5.3, err)
		return err
	}

	if deleteBeforeCopy || os.Getenv("ABROOT_DELETE_BEFORE_COPY") != "" {
		PrintVerboseInfo("ABSystemRunOperation", "Deleting future system, this will render the future root temporarily unavailable")
		if !dryRun {
			err := ClearDirectory(partFuture.Partition.MountPoint, nil)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 4, err)
				return err
			}
		}
	}

	abrootTrans := filepath.Join(futureRoot, "abroot-trans")
	if !dryRun {
		err = OciExportRootFs(
			"abroot-"+uuid.New().String(),
			imageRecipe,
			abrootTrans,
			futureRoot,
		)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 4.2, err)
			return err
		}
	}

	// Stage 4.1: Delete old images
	if !dryRun {
		err = DeleteAllButLatestImage()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 3.1, err)
			return err
		}
	}

	// Stage 4.2: Repair root integrity
	if !dryRun {
		err = RepairRootIntegrity(futureRoot)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 2.4, err)
			return err
		}
	}

	// Stage 5: Write new abimage.abr and config to future/
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 5] -------- ABSystemRunOperation")

	abimage, err := NewABImage(imageDigest, settings.GetFullImageNameWithTag())
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 5.1, err)
		return err
	}

	if !dryRun {
		err = abimage.WriteTo(futureRoot)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 5.2, err)
			return err
		}
	}

	varParent := s.RootM.VarPartition.Parent
	if varParent != nil && varParent.IsEncrypted() {
		device := varParent.Device
		if varParent.IsDevMapper() {
			device = "/dev/mapper/" + device
		} else {
			device = "/dev/" + device
		}

		settings.Cnf.PartCryptVar = device
	}

	if !dryRun {
		err = settings.WriteConfigToFile(filepath.Join(futureRoot, "/usr/share/abroot/abroot.json"))
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 5.25, err)
			return err
		}
	}

	if !dryRun {
		err = pkgM.WriteSummaryToRoot(futureRoot)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 5.26, err)
			return err
		}
	}

	// Stage 6: Update the bootloader
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 6] -------- ABSystemRunOperation")

	generatedGrubConfigPath := "/boot/grub/grub.cfg"

	if !dryRun {

		chroot, err := NewChroot(
			futureRoot,
			partFuture.Partition.Uuid,
			partFuture.Partition.Device,
			true,
			filepath.Join("/var/lib/abroot/etc", partPresent.Label),
		)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.02, err)
			return err
		}

		grubCommand := fmt.Sprintf(settings.Cnf.UpdateGrubCmd, generatedGrubConfigPath)
		err = chroot.Execute(grubCommand)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.1, err)
			return err
		}

		err = chroot.Execute(settings.Cnf.UpdateInitramfsCmd) // ensure initramfs is updated
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.2, err)
			return err
		}

		err = chroot.Close()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.25, err)
			return err
		}

	}

	var newKernelVer string

	if !dryRun {
		newKernelVer = getKernelVersion(filepath.Join(futureRoot, "boot"))
		if newKernelVer == "" {
			err := errors.New("could not get kernel version")
			PrintVerboseErr("ABSystem.RunOperation", 7.26, err)
			return err
		}
	}

	var rootUuid string
	// If Thin-Provisioning set, mount init partition and move linux and initrd
	// images to it.
	var initMountpoint string
	if settings.Cnf.ThinProvisioning {
		initPartition, err := s.RootM.GetInit()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.3, err)
			return err
		}

		initMountpoint = filepath.Join(futureRoot, "boot", "init")
		err = initPartition.Mount(initMountpoint)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.4, err)
			return err
		}

		cq.Add(func(args ...interface{}) error {
			return initPartition.Unmount()
		}, nil, 80, &goodies.NoErrorHandler{}, false)

		futureInitDir := filepath.Join(initMountpoint, partFuture.Label)

		if !dryRun {
			err = os.RemoveAll(futureInitDir)
			if err != nil {
				PrintVerboseWarn("ABSystem.RunOperation", 7.44)
			}
			err = os.MkdirAll(futureInitDir, 0o755)
			if err != nil {
				PrintVerboseWarn("ABSystem.RunOperation", 7.47, err)
			}

			err = MoveFile(
				filepath.Join(futureRoot, "boot", "vmlinuz-"+newKernelVer),
				filepath.Join(futureInitDir, "vmlinuz-"+newKernelVer),
			)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 7.5, err)
				return err
			}
			err = MoveFile(
				filepath.Join(futureRoot, "boot", "initrd.img-"+newKernelVer),
				filepath.Join(futureInitDir, "initrd.img-"+newKernelVer),
			)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 7.6, err)
				return err
			}
			err = MoveFile(
				filepath.Join(futureRoot, "boot", "config-"+newKernelVer),
				filepath.Join(futureInitDir, "config-"+newKernelVer),
			)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 7.7, err)
				return err
			}
			err = MoveFile(
				filepath.Join(futureRoot, "boot", "System.map-"+newKernelVer),
				filepath.Join(futureInitDir, "System.map-"+newKernelVer),
			)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 7.8, err)
				return err
			}

		}

		rootUuid = initPartition.Uuid
	} else {
		rootUuid = partFuture.Partition.Uuid
	}

	if !dryRun {
		err = generateABGrubConf(
			newKernelVer,
			futureRoot,
			rootUuid,
			partFuture.Label,
			generatedGrubConfigPath,
		)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 7.9, err)
			return err
		}
	}

	// Stage 7: Sync /etc
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 7] -------- ABSystemRunOperation")

	oldEtc := "/sysconf" // The current etc WITHOUT anything overlayed
	oldUpperEtc := fmt.Sprintf("/var/lib/abroot/etc/%s", partPresent.Label)
	newUpperEtc := fmt.Sprintf("/var/lib/abroot/etc/%s", partFuture.Label)

	// make sure the future etc directories exist, ignoring errors
	newWorkEtc := fmt.Sprintf("/var/lib/abroot/etc/%s-work", partFuture.Label)
	if !dryRun {
		os.MkdirAll(newUpperEtc, 0o755)
		os.MkdirAll(newWorkEtc, 0o755)

		err = EtcBuilder.ExtBuildCommand(oldEtc, futureRoot+"/sysconf", oldUpperEtc, newUpperEtc)
		if err != nil {
			PrintVerboseErr("AbSystem.RunOperation", 8, err)
			return err
		}
	}

	// Stage 8: Mount boot partition
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 8] -------- ABSystemRunOperation")

	tmpBootMount := "/run/abroot/tmp-boot-mount-1/"
	err = os.MkdirAll(tmpBootMount, 0o755)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 9, err)
		return err
	}

	err = partBoot.Mount(tmpBootMount)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 9.1, err)
		return err
	}

	cq.Add(func(args ...interface{}) error {
		return partBoot.Unmount()
	}, nil, 100, &goodies.NoErrorHandler{}, false)

	// Stage 9: Atomic swap the bootloader
	// ------------------------------------------------
	PrintVerboseSimple("[Stage 9] -------- ABSystemRunOperation")

	grub, err := NewGrub(partBoot)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 11, err)
		return err
	}

	// Only swap grub entries if we're booted into the present partition
	isPresent, err := grub.IsBootedIntoPresentRoot()
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 11.1, err)
		return err
	}
	if !dryRun && isPresent {
		grubCfgCurrent := filepath.Join(tmpBootMount, "grub/grub.cfg")
		grubCfgFuture := filepath.Join(tmpBootMount, "grub/grub.cfg.future")

		// Just like in Stage 9, tmpBootMount/grub/grub.cfg.future may not exist.
		if _, err = os.Stat(grubCfgFuture); os.IsNotExist(err) {
			PrintVerboseInfo("ABSystem.RunOperation", "Creating grub.cfg.future")

			grubCfgContents, err := os.ReadFile(grubCfgCurrent)
			if err != nil {
				PrintVerboseErr("ABSystem.RunOperation", 11.2, err)
			}

			var replacerPairs []string
			if grub.FutureRoot == "a" {
				replacerPairs = []string{
					"default=1", "default=0",
					"Previous State (A)", "Current State (A)",
					"Current State (B)", "Previous State (B)",
				}
			} else {
				replacerPairs = []string{
					"default=0", "default=1",
					"Current State (A)", "Previous State (A)",
					"Previous State (B)", "Current State (B)",
				}
			}

			replacer := strings.NewReplacer(replacerPairs...)
			os.WriteFile(grubCfgFuture, []byte(replacer.Replace(string(grubCfgContents))), 0o644)
		}

		err = AtomicSwap(grubCfgCurrent, grubCfgFuture)
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 11.3, err)
			return err
		}
	}

	if !dryRun {
		err = s.createFinishedFile()
		if err != nil {
			PrintVerboseErr("ABSystem.RunOperation", 11.4, err)
			return fmt.Errorf("could not write finished file: %w", err)
		}
	}

	PrintVerboseInfo("ABSystem.RunOperation", "upgrade completed")
	return nil
}

func (*ABSystem) Rollback(checkOnly bool) (response ABRollbackResponse, err error)
{
	PrintVerboseInfo("ABSystem.Rollback", "starting")

	cq := goodies.NewCleanupQueue()
	defer cq.Run()

	if s.finishedFileExists() {
		if checkOnly {
			return ROLLBACK_RES_NO, nil
		}
		return ROLLBACK_FAILED, errors.New("an operation finished successfully, can't roll back until reboot")
	}

	// we won't allow upgrades while rolling back
	if !checkOnly {
		err = s.LockOperation()
		if err != nil {
			PrintVerboseErr("ABSystem.Rollback", 0, err)
			return ROLLBACK_FAILED, fmt.Errorf("can't lock operation: %w", err)
		}
	}

	partBoot, err := s.RootM.GetBoot()
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 1, err)
		return ROLLBACK_FAILED, err
	}

	tmpBootMount := "/run/abroot/tmp-boot-mount-2/"
	err = os.MkdirAll(tmpBootMount, 0o755)
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 2, err)
		return ROLLBACK_FAILED, err
	}

	err = partBoot.Mount(tmpBootMount)
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 3, err)
		return ROLLBACK_FAILED, err
	}

	cq.Add(func(args ...interface{}) error {
		return partBoot.Unmount()
	}, nil, 100, &goodies.NoErrorHandler{}, false)

	grub, err := NewGrub(partBoot)
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 4, err)
		return ROLLBACK_FAILED, err
	}

	// Only swap grub entries if we're booted into the present partition
	isPresent, err := grub.IsBootedIntoPresentRoot()
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 5, err)
		return ROLLBACK_FAILED, err
	}

	// If checkOnly is true, we stop here and return the appropriate response
	if checkOnly {
		response = ROLLBACK_RES_YES
		if isPresent {
			response = ROLLBACK_RES_NO
		}
		return response, nil
	}

	if isPresent {
		PrintVerboseInfo("ABSystem.Rollback", "current root is the default, nothing to do")
		return ROLLBACK_UNNECESSARY, nil
	}

	grubCfgCurrent := filepath.Join(tmpBootMount, "grub/grub.cfg")
	grubCfgFuture := filepath.Join(tmpBootMount, "grub/grub.cfg.future")

	// Just like in Stage 9, tmpBootMount/grub/grub.cfg.future may not exist.
	if _, err = os.Stat(grubCfgFuture); os.IsNotExist(err) {
		PrintVerboseInfo("ABSystem.Rollback", "Creating grub.cfg.future")

		grubCfgContents, err := os.ReadFile(grubCfgCurrent)
		if err != nil {
			PrintVerboseErr("ABSystem.Rollback", 6, err)
		}

		var replacerPairs []string
		if grub.FutureRoot == "a" {
			replacerPairs = []string{
				"default=1", "default=0",
				"A (previous)", "A (current)",
				"B (current)", "B (previous)",
			}
		} else {
			replacerPairs = []string{
				"default=0", "default=1",
				"A (current)", "A (previous)",
				"B (previous)", "B (current)",
			}
		}

		replacer := strings.NewReplacer(replacerPairs...)
		os.WriteFile(grubCfgFuture, []byte(replacer.Replace(string(grubCfgContents))), 0o644)
	}

	err = AtomicSwap(grubCfgCurrent, grubCfgFuture)
	if err != nil {
		PrintVerboseErr("ABSystem.RunOperation", 7, err)
		return ROLLBACK_FAILED, err
	}

	// allow upgrades after rolling back
	err = s.UnlockOperation()
	if err != nil {
		PrintVerboseErr("ABSystem.Rollback", 9, err)
		PrintVerboseInfo("ABSystem.Rollback", "rollback completed with unlock failure")
	}

	PrintVerboseInfo("ABSystem.Rollback", "rollback completed")
	return ROLLBACK_SUCCESS, nil
}

func (*ABSystem) LockOperation() error
{
	pid := os.Getpid()
	pidData := []byte(strconv.Itoa(pid))

	err := os.MkdirAll(filepath.Dir(operationLockFile), 0o755)
	if err != nil {
		PrintVerboseWarn("ABSystem.LockOperation", 1, err)
	}

	if _, err = os.Stat(operationLockFile); err == nil {
		if s.isLockfilePidActive() {
			return ErrOperationLocked
		}
	}

	err = os.WriteFile(operationLockFile, pidData, 0o644)
	if err != nil {
		os.Remove(operationLockFile)
		return fmt.Errorf("can't write lockfile: %w", err)
	}

	PrintVerboseInfo("ABSystem.LockOperation", "lock file created")
	return nil
}

func (*ABSystem) isLockfilePidActive() bool
{
	runningPid, err := os.ReadFile(operationLockFile)

	if errors.Is(err, os.ErrNotExist) {
		return false
	}

	if err != nil {
		PrintVerboseErr("ABSystem.RemoveStageFile", 0, err)
		return true
	}

	if string(runningPid) == "" {
		PrintVerboseWarn("ABSystem.isLockfilePidActive", 1, "lock file does not contain PID")
		return true
	}

	if _, err := os.Stat(filepath.Join("/proc", string(runningPid))); errors.Is(err, os.ErrNotExist) {
		return false
	}

	return true
}

func (*Checks) PerformAllChecks() error
{
	err := c.CheckCompatibilityFS()
	if err != nil {
		return err
	}

	err = c.CheckConnectivity()
	if err != nil {
		return err
	}

	err = c.CheckRoot()
	if err != nil {
		return err
	}

	return nil
}

func (*Checks) CheckCompatibilityFS() error
{
	PrintVerboseInfo("Checks.CheckCompatibilityFS", "running...")

	var fs []string
	if runtime.GOOS == "linux" {
		fs = []string{"ext4", "btrfs", "xfs"}
	} else {
		err := fmt.Errorf("your OS (%s) is not supported", runtime.GOOS)
		PrintVerboseErr("Checks.CheckCompatibilityFS", 0, err)
		return err
	}

	cmd, err := exec.Command("findmnt", "-n", "-o", "source", "/").Output()
	if err != nil {
		PrintVerboseErr("Checks.CheckCompatibilityFS", 1, err)
		return err
	}
	device := string([]byte(cmd[:len(cmd)-1]))

	cmd, err = exec.Command("lsblk", "-o", "fstype", "-n", device).Output()
	if err != nil {
		PrintVerboseErr("Checks.CheckCompatibilityFS", 2, err)
		return err
	}
	fsType := string([]byte(cmd[:len(cmd)-1]))

	for _, f := range fs {
		if f == string(fsType) {
			PrintVerboseInfo("CheckCompatibilityFS", fsType, "is supported")
			return nil
		}
	}

	err = fmt.Errorf("the filesystem (%s) is not supported", fsType)
	PrintVerboseErr("Checks.CheckCompatibilityFS", 3, err)
	return err
}

func (*Checks) CheckConnectivity() error
{
	PrintVerboseInfo("Checks.CheckConnectivity", "running...")

	timeout := 5 * time.Second
	_, err := net.DialTimeout("tcp", "vanillaos.org:80", timeout)
	if err != nil {
		PrintVerboseErr("Checks.CheckConnectivity", 1, err)
		return err
	}

	return nil
}

func (*Checks) CheckRoot() error
{
	PrintVerboseInfo("Checks.CheckRoot", "running...")

	if os.Geteuid() == 0 {
		PrintVerboseInfo("Checks.CheckRoot", "you are root")
		return nil
	}

	err := errors.New("not root")
	PrintVerboseErr("Checks.CheckRoot", 1, err)
	return err
}