internal

var Capture = func(err ...error) {
	if err == nil || len(err) == 0 || err[0] == nil {
		return
	}
	fmt.Println(err)
	os.Exit(1)
}

var CaptureInt = func(_ int, err error) {
	if err != nil {
		panic(err)
	}
	return
}

var CaptureOpenFile = func(path string, flag int, perm os.FileMode) *os.File {
	f, e := os.OpenFile(path, flag, perm)
	Capture(e)
	return f
}

var CheckRootPrivileges = func() bool {
	if runtime.GOOS == "windows" {
		return false
	} else {
		if os.Geteuid() == 0 {
			return true
		}
		if User().Uid == "0" {
			return true
		}

		return false
	}
}

var Discard = func(err ...error) {
	if err == nil || len(err) == 0 || err[0] == nil {
		return
	}
	fmt.Println(err)
}

var FindSymlinks = func(dirPath string) ([]string, error) {
	dir, err := os.Open(dirPath)
	if err != nil {
		return nil, ErrFile{dirPath, err, "os.Open"}
	}
	defer dir.Close()
	entries, err := dir.ReadDir(-1)
	if err != nil {
		return nil, ErrDirEntries{dirPath, err}
	}
	var symlinks []string
	for _, entry := range entries {
		if entry.Type()&os.ModeSymlink != 0 {
			fullPath := filepath.Join(dirPath, entry.Name())
			symlinks = append(symlinks, fullPath)
		}
	}
	return symlinks, nil
}

var IsDirectory = func(path string) bool {
	fileInfo, err := os.Lstat(path)
	if err != nil {
		return false
	}
	return fileInfo.IsDir()
}

var IsSymlink = func(path string) bool {
	fileInfo, err := os.Lstat(path)
	if err != nil {
		return false
	}
	return fileInfo.Mode()&os.ModeSymlink != 0
}

var MakeDirsWritable = func(path string) error {
	return filepath.WalkDir(path, func(p string, d os.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if !d.IsDir() {
			return nil
		}

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

		mode := info.Mode()
		if mode&0200 == 0 {
			newMode := mode | 0200
			if err := os.Chmod(p, newMode); err != nil {
				return ErrChmodFailed{p, err}
			}
		}
		return nil
	})
}

var PathExists = func(path string) bool {
	_, err := os.Lstat(path)
	return !os.IsNotExist(err) && !os.IsPermission(err)
}

var ReadSymlink = func(path string) (string, error) {
	target, err := os.Readlink(path)
	if err != nil {
		return "", ErrPathFailed{path, err, "remove"}
	}

	if !filepath.IsAbs(target) {
		symlinkDir := filepath.Dir(path)
		target = filepath.Join(symlinkDir, target)
	}

	return target, nil
}

var RemoveSetuidSetgidBits = func(path string) error {
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "linux", "darwin":
		cmd = exec.Command("sh", "-c", fmt.Sprintf("chmod -R a-s %s", path))
	default:
		return ErrOSNotSupported{runtime.GOOS}
	}
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	if err := cmd.Run(); err != nil {
		return ErrSetUIDGIDBit{path, err, "remove"}
	}
	return nil
}

var RemoveStickyBit = func(path string) error {
	if !IsDirectory(path) {
		return ErrStickyBitsOnFile{path}
	}
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "linux", "darwin":
		cmd = exec.Command("sh", "-c", fmt.Sprintf("chmod -t %s", path))
	default:
		return ErrOSNotSupported{runtime.GOOS}
	}

	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	if err := cmd.Run(); err != nil {
		return ErrStickyBitFailed{path, err, "remove"}
	}
	return nil
}

var RemoveSymlinkOrBackupPath = func(path string) error {
	if !PathExists(path) {
		return nil
	}
	if IsSymlink(path) {
		err := os.Remove(path)
		if err != nil {
			return ErrPathFailed{path, err, ""}
		}
		return nil
	}

	err := os.Rename(path, path+".bak")
	if err != nil {
		return ErrPathFailed{path, err, "non-"}
	}

	return nil
}

var SetSetuidSetgidBits = func(path string) error {
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "linux", "darwin":
		cmd = exec.Command("sh", "-c", fmt.Sprintf("chmod -R a+s %s", path))
	default:
		return ErrOSNotSupported{runtime.GOOS}
	}
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	if err := cmd.Run(); err != nil {
		return ErrBitNotSet{err}
	}
	return nil
}

var SetStickyBit = func(path string) error {
	if !IsDirectory(path) {
		return ErrStickyBitsOnFile{path}
	}
	var cmd *exec.Cmd
	switch runtime.GOOS {
	case "linux", "darwin":
		cmd = exec.Command("sh", "-c", fmt.Sprintf("chmod +t %s", path))
	default:
		return ErrOSNotSupported{runtime.GOOS}
	}
	cmd.Stderr = os.Stderr
	cmd.Stdout = os.Stdout
	if err := cmd.Run(); err != nil {
		return ErrStickyBitFailed{path, err, "set"}
	}
	return nil
}

var Touch = func(path string) error {
	_, err := os.Stat(path)
	if os.IsNotExist(err) {
		pathFile, err := os.Create(path)
		if err != nil {
			return ErrFile{path, err, "os.Create"}
		}
		if err := pathFile.Close(); err != nil {
			return ErrFile{path, err, "path.Close"}
		}
		return nil
	} else if err != nil {
		return ErrFile{path, err, "os.Stat"}
	}

	currentTime := time.Now()
	if err := os.Chtimes(path, currentTime, currentTime); err != nil {
		return ErrFile{path, err, "os.Chtimes"}
	}

	return nil
}

var User = func() *user.User {
	currentUser, err := UserCurrent()
	if err != nil {
		return &user.User{
			Uid:      "-1",
			Gid:      "-1",
			Username: "nobody",
			Name:     "nobody",
			HomeDir:  "/dev/null",
		}
	}
	return currentUser
}

var UserCurrent = user.Current

var VerifyLink = func(link, expectedTarget string) string {
	actualTarget, err := ReadSymlink(link)
	if err != nil {
		return "❌"
	}

	cleanExpected := filepath.Clean(expectedTarget)
	cleanActual := filepath.Clean(actualTarget)

	if cleanActual == cleanExpected {
		return "✅"
	}

	return "❌"
}