utility.go

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"regexp"
	"strings"

	"github.com/goccy/go-json"
	"golang.org/x/term"

	"github.com/pkg/xattr"
	"github.com/zeebo/blake3"
)

// removeDuplicates removes duplicate binaries from the list (used in ./install.go)
func removeDuplicates(binaries []string) []string {
	seen := make(map[string]struct{})
	result := []string{}
	for _, binary := range binaries {
		if _, ok := seen[binary]; !ok {
			seen[binary] = struct{}{}
			result = append(result, binary)
		}
	}
	return result
}

// contanins will return true if the provided slice of []strings contains the word str
func contains(slice []string, str string) bool {
	for _, v := range slice {
		if v == str {
			return true
		}
	}
	return false
}

// fileExists checks if a file exists.
func fileExists(filePath string) bool {
	_, err := os.Stat(filePath)
	return !os.IsNotExist(err)
}

// isDirectory checks if the given path is a directory.
func isDirectory(path string) (bool, error) {
	info, err := os.Stat(path)
	if err != nil {
		if os.IsNotExist(err) {
			return false, nil // Path does not exist
		}
		return false, err
	}
	return info.IsDir(), nil
}

// isExecutable checks if the file at the specified path is executable.
func isExecutable(filePath string) bool {
	info, err := os.Stat(filePath)
	if err != nil {
		return false
	}
	return info.Mode().IsRegular() && (info.Mode().Perm()&0o111) != 0
}

// validateProgramsFrom checks the validity of programs against a remote source
func validateProgramsFrom(config *Config, programsToValidate []string, metadata map[string]interface{}) ([]string, error) {
	installDir := config.InstallDir
	remotePrograms, err := listBinaries(metadata)
	if err != nil {
		return nil, fmt.Errorf("failed to list remote binaries: %w", err)
	}

	files, err := listFilesInDir(installDir)
	if err != nil {
		return nil, fmt.Errorf("failed to list files in %s: %w", installDir, err)
	}

	programsToValidate = removeDuplicates(programsToValidate)
	validPrograms := make([]string, 0, len(programsToValidate))

	// Inline function to validate a file against the remote program list
	validate := func(file string) (string, bool) {
		fullBinaryName := listInstalled(file) // Get the full binary name of the file
		if config.RetakeOwnership == true {
			fullBinaryName = filepath.Base(file)
			if fullBinaryName == "" {
				return "", false // If we couldn't get a valid name, return invalid
			}
		}
		// Check if the full name exists in the remote programs
		if contains(remotePrograms, fullBinaryName) {
			return fullBinaryName, true
		}
		return "", false
	}

	if len(programsToValidate) == 0 {
		// Validate all files in the directory
		for _, file := range files {
			if fullName, valid := validate(file); valid {
				validPrograms = append(validPrograms, fullName)
			}
		}
	} else {
		// Validate only the specified programs
		for _, program := range programsToValidate {
			file := filepath.Join(installDir, program)
			if fullName, valid := validate(file); valid {
				validPrograms = append(validPrograms, fullName)
			}
		}
	}

	return validPrograms, nil
}

func listInstalled(binaryPath string) string {
	if isSymlink(binaryPath) {
		return ""
	}
	// Retrieve the fullName of the binary
	fullBinaryName, err := getFullName(binaryPath)
	if err != nil || fullBinaryName == "" {
		return "" // If we can't get the full name, consider it invalid
	}
	return fullBinaryName
}

// errorEncoder generates a unique error code based on the sum of ASCII values of the error message.
func errorEncoder(format string, args ...interface{}) int {
	formattedErrorMessage := fmt.Sprintf(format, args...)

	var sum int
	for _, char := range formattedErrorMessage {
		sum += int(char)
	}
	errorCode := sum % 256
	fmt.Fprint(os.Stderr, formattedErrorMessage)
	return errorCode
}

// errorOut prints the error message to stderr and exits the program with the error code generated by errorEncoder.
func errorOut(format string, args ...interface{}) {
	os.Exit(errorEncoder(format, args...))
}

// GetTerminalWidth attempts to determine the width of the terminal.
// if failed, it will falls back to  80 columns.
func getTerminalWidth() int {
	w, _, _ := term.GetSize(int(os.Stdout.Fd()))
	if w != 0 {
		return w
	}

	// Fallback to  80 columns
	return 80
}

// truncateSprintf formats text and truncates to fit the screen's size, preserving escape sequences
func truncateSprintf(indicator, format string, a ...interface{}) string {
	text := fmt.Sprintf(format, a...)
	if !term.IsTerminal(int(os.Stdout.Fd())) {
		return text
	}

	width := getTerminalWidth() - len(indicator)
	if width <= 0 {
		return text
	}

	var out bytes.Buffer
	var visibleCount int
	var inEscape bool
	var escBuf bytes.Buffer

	for i := 0; i < len(text); i++ {
		c := text[i]

		switch {
		case c == '\x1b':
			inEscape = true
			escBuf.Reset()
			escBuf.WriteByte(c)
		case inEscape:
			escBuf.WriteByte(c)
			if (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
				inEscape = false
				out.Write(escBuf.Bytes())
			}
		default:
			if visibleCount >= width {
				continue
			}
			out.WriteByte(c)
			visibleCount++
		}
	}

	result := out.String()
	if strings.HasSuffix(text, "\n") {
		if visibleCount >= width {
			return result + indicator + "\n"
		}
		return result
	}
	if visibleCount >= width {
		return result + indicator
	}
	return result
}

// truncatePrintf formats and prints text, and offers optional truncation
func truncatePrintf(disableTruncation bool, format string, a ...interface{}) (n int, err error) {
    if disableTruncation {
        return fmt.Printf(format, a...)
    }
    text := truncateSprintf(indicator, format, a...)
    return fmt.Print(text)
}

// listFilesInDir lists all files in a directory
func listFilesInDir(dir string) ([]string, error) {
	entries, err := os.ReadDir(dir)
	if err != nil {
		return nil, err
	}
	files := make([]string, 0, len(entries))
	for _, entry := range entries {
		if !entry.IsDir() {
			files = append(files, filepath.Join(dir, entry.Name()))
		}
	}
	return files, nil
}

// getFullName retrieves the full binary name from the extended attributes of the binary file.
// If the binary does not exist, it returns the basename. If the full name attribute cannot be retrieved, it returns an error.
func getFullName(binaryPath string) (string, error) {

	if !fileExists(binaryPath) {
		return filepath.Base(binaryPath), nil
	}

	// Retrieve the "user.FullName" attribute
	fullName, err := xattr.Get(binaryPath, "user.FullName")
	if err != nil {
		// Return an error if the full name cannot be retrieved but the binary exists
		return "", fmt.Errorf("full name attribute not found for binary: %s", binaryPath)
	}

	return string(fullName), nil
}

// addFullName writes the full binary name to the extended attributes of the binary file.
func addFullName(binaryPath string, fullName string) error {
	// Set the "user.FullName" attribute
	if err := xattr.Set(binaryPath, "user.FullName", []byte(fullName)); err != nil {
		return fmt.Errorf("failed to set xattr for %s: %w", binaryPath, err)
	}
	return nil
}

// removeNixGarbageFoundInTheRepos corrects any /nix/store/ or /bin/ binary path in the file.
func removeNixGarbageFoundInTheRepos(filePath string) error {
	// Read the entire file content
	content, err := os.ReadFile(filePath)
	if err != nil {
		return fmt.Errorf("failed to read file %s: %v", filePath, err)
	}
	// Regex to match and remove the /nix/store/.../ prefix in the shebang line, preserving the rest of the path
	nixShebangRegex := regexp.MustCompile(`^#!\s*/nix/store/[^/]+/`)
	// Regex to match and remove the /nix/store/*/bin/ prefix in other lines
	nixBinPathRegex := regexp.MustCompile(`/nix/store/[^/]+/bin/`)
	// Split content by lines
	lines := strings.Split(string(content), "\n")
	// Flag to track if any corrections were made
	correctionsMade := false
	// Handle the shebang line separately if it exists and matches the nix pattern
	if len(lines) > 0 && nixShebangRegex.MatchString(lines[0]) {
		lines[0] = nixShebangRegex.ReplaceAllString(lines[0], "#!/")
		// Iterate through the rest of the lines and correct any /nix/store/*/bin/ path
		for i := 1; i < len(lines); i++ {
			if nixBinPathRegex.MatchString(lines[i]) {
				lines[i] = nixBinPathRegex.ReplaceAllString(lines[i], "")
			}
		}
		correctionsMade = true
	}
	// If any corrections were made, write the modified content back to the file
	if correctionsMade {
		if err := os.WriteFile(filePath, []byte(strings.Join(lines, "\n")), 0644); err != nil {
			return fmt.Errorf("failed to correct nix object [%s]: %v", filepath.Base(filePath), err)
		}
		fmt.Printf("[%s] is a nix object. Corrections have been made.\n", filepath.Base(filePath))
	}
	return nil
}

func fetchJSON(url string, v interface{}) error {
	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return fmt.Errorf("error creating request for %s: %v", url, err)
	}

	req.Header.Set("Cache-Control", "no-cache, no-store, must-revalidate")
	req.Header.Set("Pragma", "no-cache")
	req.Header.Set("Expires", "0")

	client := &http.Client{}
	response, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("error fetching from %s: %v", url, err)
	}
	defer response.Body.Close()

	body := &bytes.Buffer{}
	if _, err := io.Copy(body, response.Body); err != nil {
		return fmt.Errorf("error reading from %s: %v", url, err)
	}

	if err := json.Unmarshal(body.Bytes(), v); err != nil {
		return fmt.Errorf("error decoding from %s: %v", url, err)
	}

	return nil
}

// calculateChecksum calculates the checksum of a file
func calculateChecksum(filePath string) (string, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return "", err
	}
	defer file.Close()

	hasher := blake3.New()
	if _, err := io.Copy(hasher, file); err != nil {
		return "", err
	}

	return fmt.Sprintf("%x", hasher.Sum(nil)), nil
}

func isSymlink(filePath string) bool {
	fileInfo, err := os.Lstat(filePath)
	return err == nil && fileInfo.Mode()&os.ModeSymlink != 0
}

func sanitizeString(input string) string {
	var sanitized strings.Builder
	for _, ch := range input {
		if ch >= 32 && ch <= 126 { // Printable ASCII characters
			sanitized.WriteRune(ch)
		}
	}
	return sanitized.String()
}

// ternary
func ternary[T any](cond bool, vtrue, vfalse T) T {
	if cond {
		return vtrue
	}
	return vfalse
}