core

{
	err := a.CheckContainerTools()
	if err != nil {
		fmt.Println(`One or more core components are not available. 
Please refer to our documentation at https://documentation.vanillaos.org/`)
		return err
	}

	err = a.CheckAndCreateUserStacksDirectory()
	if err != nil {
		fmt.Println(`Failed to create stacks directory.`)
		return err
	}

	err = a.CheckAndCreateApxStorageDirectory()
	if err != nil {
		fmt.Println(`Failed to create apx storage directory.`)
		return err
	}

	err = a.CheckAndCreateApxUserPkgManagersDirectory()
	if err != nil {
		fmt.Println(`Failed to create apx user pkg managers directory.`)
		return err
	}

	return nil
}

{
	_, err := os.Stat(a.Cnf.DistroboxPath)
	if err != nil {
		if os.IsNotExist(err) {
			return errors.New("distrobox is not installed")
		}
		return err
	}

	if _, err := exec.LookPath("docker"); err != nil {
		if _, err := exec.LookPath("podman"); err != nil {
			return errors.New("container engine (docker or podman) not found")
		}
	}

	return nil
}

{
	_, err := os.Stat(a.Cnf.UserStacksPath)
	if err != nil {
		if os.IsNotExist(err) {
			err = os.MkdirAll(a.Cnf.UserStacksPath, 0755)
			if err != nil {
				return fmt.Errorf("failed to create stacks directory: %w", err)
			}
		} else {
			return fmt.Errorf("failed to check stacks directory: %w", err)
		}
	}

	return nil
}

{
	_, err := os.Stat(a.Cnf.ApxStoragePath)
	if err != nil {
		if os.IsNotExist(err) {
			err = os.MkdirAll(a.Cnf.ApxStoragePath, 0755)
			if err != nil {
				return fmt.Errorf("failed to create apx storage directory: %w", err)
			}
		} else {
			return fmt.Errorf("failed to check apx storage directory: %w", err)
		}
	}

	return nil
}

{
	_, err := os.Stat(a.Cnf.UserPkgManagersPath)
	if err != nil {
		if os.IsNotExist(err) {
			err = os.MkdirAll(a.Cnf.UserPkgManagersPath, 0755)
			if err != nil {
				return fmt.Errorf("failed to create apx user pkg managers directory: %w", err)
			}
		} else {
			return fmt.Errorf("failed to check apx user pkg managers directory: %w", err)
		}
	}

	return nil
}

{
	entrypoint := apx.Cnf.DistroboxPath
	if useEngine {
		entrypoint = d.EngineBinary
	}

	// we need to append engineFlags after command, otherwise they will be
	// ignored in commands like "enter"
	finalArgs := []string{command}

	// NOTE: for engine-specific commands, we need to use pkexec for rootfull
	//		 containers, since podman does not offer a dedicated flag for this.
	if rootFull && useEngine {
		entrypoint = "pkexec"
		finalArgs = []string{d.EngineBinary, command}
	}

	cmd := exec.Command(entrypoint, finalArgs...)

	if detachedMode {
		cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
	}

	if !captureOutput && !muteOutput {
		cmd.Stdout = os.Stdout
	}
	if !muteOutput {
		cmd.Stderr = os.Stderr
	}
	cmd.Stdin = os.Stdin

	cmd.Env = os.Environ()
	cmd.Env = append(cmd.Env, "DBX_SUDO_PROGRAM=pkexec")

	// NOTE: the custom storage is not being used since it prevent other
	//		 utilities, like VSCode, to access the container.
	if d.Engine == "podman" {
		cmd.Env = append(cmd.Env, "CONTAINER_STORAGE_DRIVER="+apx.Cnf.StorageDriver)
		// cmd.Env = append(cmd.Env, "XDG_DATA_HOME="+apx.Cnf.ApxStoragePath)
	} else if d.Engine == "docker" {
		cmd.Env = append(cmd.Env, "DOCKER_STORAGE_DRIVER="+apx.Cnf.StorageDriver)
		// cmd.Env = append(cmd.Env, "DOCKER_DATA_ROOT="+apx.Cnf.ApxStoragePath)
	}

	if len(engineFlags) > 0 {
		cmd.Args = append(cmd.Args, "--additional-flags")
		cmd.Args = append(cmd.Args, strings.Join(engineFlags, " "))
	}

	// NOTE: the root flag is not being used by the Apx CLI, but it's useful
	//		 for those using Apx as a library, e.g. VSO.
	if rootFull && !useEngine {
		cmd.Args = append(cmd.Args, "--root")
	}

	cmd.Args = append(cmd.Args, args...)

	if os.Getenv("APX_VERBOSE") == "1" {
		fmt.Println("Runing a command:")
		fmt.Println("\tCommand:", cmd.String())
		fmt.Println("\tcaptureOutput:", captureOutput)
		fmt.Println("\tmuteOutput:", muteOutput)
		fmt.Println("\trootFull:", rootFull)
		fmt.Println("\tdetachedMode:", detachedMode)
	}

	if detachedMode {
		err := cmd.Start()
		if err != nil {
			return nil, err
		}
		return nil, nil
	}

	if captureOutput {
		output, err := cmd.Output()
		if err != nil {
			if exitErr, ok := err.(*exec.ExitError); ok {
				return output, errors.New(string(exitErr.Stderr))
			}
		}
		return output, err
	}

	cmd.Stdout = ioutil.Discard

	err := cmd.Run()
	return nil, err
}

{
	output, err := d.RunCommand("ps", []string{
		"-a",
		"--format", "{{.ID}}|{{.CreatedAt}}|{{.Status}}|{{.Labels}}|{{.Names}}",
	}, []string{}, true, true, false, rootFull, false)
	if err != nil {
		return nil, err
	}

	rows := strings.Split(string(output), "\n")
	containers := []dboxContainer{}

	for _, row := range rows {
		if row == "" {
			continue
		}

		rowItems := strings.Split(row, "|")
		if len(rowItems) != 5 {
			continue
		}

		container := dboxContainer{
			ID:        strings.Trim(rowItems[0], "\""),
			CreatedAt: strings.Trim(rowItems[1], "\""),
			Status:    strings.Trim(rowItems[2], "\""),
			Name:      strings.Trim(rowItems[4], "\""),
			Labels:    map[string]string{},
		}

		// example labels: map[manager:apx name:alpine stack:alpine]
		labels := strings.ReplaceAll(rowItems[3], "map[", "")
		labels = strings.ReplaceAll(labels, "]", "")
		labelsItems := strings.Split(labels, " ")
		for _, label := range labelsItems {
			labelItems := strings.Split(label, ":")
			if len(labelItems) != 2 {
				continue
			}

			container.Labels[labelItems[0]] = labelItems[1]
		}

		containers = append(containers, container)
	}

	return containers, nil
}

{
	containers, err := d.ListContainers(rootFull)
	if err != nil {
		return nil, err
	}

	for _, container := range containers {
		// fmt.Println("found container", container.Name, "requested", name)
		if container.Name == name {
			return &container, nil
		}
	}

	return nil, errors.New("container not found")
}

{
	_, err := d.RunCommand("rm", []string{
		"--force",
		name,
	}, []string{}, false, false, true, rootFull, false)
	return err
}

{
	args := []string{
		"--image", image,
		"--name", name,
		"--no-entry",
		"--yes",
		"--pull",
	}

	if home != "" {
		args = append(args, "--home", home)
	}

	if hasNvidiaGPU() && withNvidiaIntegration {
		args = append(args, "--nvidia")
	}

	if withInit {
		args = append(args, "--init")
	}

	if unshared {
		args = append(args, "--unshare-all")
	}

	if hostname != "" {
		args = append(args, "--hostname", hostname)
	}

	if len(additionalPackages) > 0 {
		args = append(args, "--additional-packages")
		args = append(args, strings.Join(additionalPackages, " "))
	}

	engineFlags := []string{}
	for key, value := range labels {
		engineFlags = append(engineFlags, fmt.Sprintf("--label=%s=%s", key, value))
	}
	engineFlags = append(engineFlags, "--label=manager=apx")

	_, err := d.RunCommand("create", args, engineFlags, false, false, false, rootFull, false)
	// fmt.Println(string(out))
	return err
}

{
	args := []string{
		"--name", name,
		"--",
	}

	args = append(args, command...)

	_, err := d.RunCommand("run", args, []string{}, false, false, false, rootFull, detachedMode)
	return err
}

{
	finalArgs := []string{
		// "--verbose",
		name,
		"--",
	}

	finalArgs = append(finalArgs, args...)
	engineFlags := []string{}

	out, err := d.RunCommand("enter", finalArgs, engineFlags, false, captureOutput, muteOutput, rootFull, detachedMode)
	// if error 130, it means that the user pressed CTRL+D, so ignore
	if err != nil && err.Error() == "exit status 130" {
		return string(out), nil
	}

	return string(out), err
}

{
	finalArgs := []string{
		name,
	}

	engineFlags := []string{}

	_, err := d.RunCommand("enter", finalArgs, engineFlags, false, false, false, rootFull, false)
	// if error 130, it means that the user pressed CTRL+D, so ignore
	if err != nil && err.Error() == "exit status 130" {
		return nil
	}

	return err
}

{
	_, err := d.RunCommand("start", []string{
		name,
	}, []string{}, true, false, false, rootFull, false)
	return err
}

{
	finalArgs := []string{
		name,
		"--yes",
	}

	engineFlags := []string{}

	_, err := d.RunCommand("stop", finalArgs, engineFlags, false, false, false, rootFull, false)
	return err
}

{
	finalArgs := []string{"distrobox-export"}

	if delete {
		finalArgs = append(finalArgs, "--delete")
	}

	finalArgs = append(finalArgs, args...)

	_, err := d.ContainerExec(name, true, true, rootFull, false, finalArgs...)
	return err
}

{
	args := []string{"--app", appName, "--export-label", label}
	return d.ContainerExport(containerName, false, rootFull, args...)
}

{
	args := []string{"--app", appName}
	return d.ContainerExport(containerName, true, rootFull, args...)
}

{
	args := []string{"--bin", binary, "--export-path", exportPath}
	return d.ContainerExport(containerName, false, rootFull, args...)
}

{
	args := []string{"--bin", binary}
	return d.ContainerExport(containerName, true, rootFull, args...)
}

{
	data, err := yaml.Marshal(pkgManager)
	if err != nil {
		return err
	}

	filePath := SelectYamlFile(apx.Cnf.UserPkgManagersPath, pkgManager.Name)
	err = os.WriteFile(filePath, data, 0644)
	return err
}

{
	if pkgManager.BuiltIn {
		return errors.New("cannot remove built-in package manager")
	}

	filePath := SelectYamlFile(apx.Cnf.UserPkgManagersPath, pkgManager.Name)
	err := os.Remove(filePath)
	return err
}

{
	finalArgs := make([]string, 0)

	if pkgManager.NeedSudo {
		finalArgs = append(finalArgs, "sudo")
	}

	if pkgManager.Model == 0 || pkgManager.Model == 1 {
		// no-translate (DEPRECATION WARNING)
		fmt.Println("!!! DEPRECATION WARNING: Model 1 will be removed in the future, please update your Apx package manager to use model 2.")
		finalArgs = append(finalArgs, pkgManager.Name)
		finalArgs = append(finalArgs, cmd)
		finalArgs = append(finalArgs, args...)
	} else {
		cmdItems := strings.Fields(cmd)
		finalArgs = append(finalArgs, cmdItems...)
		finalArgs = append(finalArgs, args...)
	}

	return finalArgs
}

{
	if _, err := os.Stat(path); os.IsNotExist(err) {
		err = os.MkdirAll(path, 0755)
		if err != nil {
			return err
		}
	}

	filePath := SelectYamlFile(path, pkgManager.Name)
	data, err := yaml.Marshal(pkgManager)
	if err != nil {
		return err
	}

	err = os.WriteFile(filePath, data, 0644)
	if err != nil {
		return err
	}

	return nil
}

{
	data, err := yaml.Marshal(stack)
	if err != nil {
		return err
	}

	filePath := SelectYamlFile(apx.Cnf.UserStacksPath, stack.Name)
	err = os.WriteFile(filePath, data, 0644)
	return err
}

{
	pkgManager, err := LoadPkgManager(stack.PkgManager)
	if err != nil {
		return nil, err
	}

	return pkgManager, nil
}

{
	if stack.BuiltIn {
		return errors.New("cannot remove built-in stack")
	}

	filePath := SelectYamlFile(apx.Cnf.UserStacksPath, stack.Name)
	err := os.Remove(filePath)
	return err
}

{
	if _, err := os.Stat(path); os.IsNotExist(err) {
		err = os.MkdirAll(path, 0755)
		if err != nil {
			return err
		}
	}

	filePath := SelectYamlFile(path, stack.Name)
	data, err := yaml.Marshal(stack)
	if err != nil {
		return err
	}

	err = os.WriteFile(filePath, data, 0644)
	if err != nil {
		return err
	}

	return nil
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	labels := map[string]string{
		"stack": strings.ReplaceAll(s.Stack.Name, " ", "\\ "),
		"name":  strings.ReplaceAll(s.Name, " ", "\\ "),
	}

	if s.IsManaged {
		labels["managed"] = "true"
	}

	if s.HasInit {
		labels["hasInit"] = "true"
	}

	if s.IsUnshared {
		labels["unshared"] = "true"
	}

	if s.HasNvidiaIntegration {
		labels["nvidia"] = "true"
	}

	err = dbox.CreateContainer(
		s.InternalName,
		s.Stack.Base,
		s.Stack.Packages,
		s.Home,
		labels,
		s.HasInit,
		s.IsRootfull,
		s.IsUnshared,
		s.HasNvidiaIntegration,
		s.Hostname,
	)
	if err != nil {
		return err
	}

	return nil
}

{
	dbox, err := NewDbox()
	if err != nil {
		return "", err
	}

	out, err := dbox.ContainerExec(s.InternalName, captureOutput, false, s.IsRootfull, detachedMode, args...)
	if err != nil {
		return "", err
	}

	if captureOutput {
		return out, nil
	}

	return "", nil
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}
	return dbox.ContainerEnter(s.InternalName, s.IsRootfull)
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}
	return dbox.ContainerStart(s.InternalName, s.IsRootfull)
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}
	return dbox.ContainerStop(s.InternalName, s.IsRootfull)
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	return dbox.ContainerDelete(s.InternalName, s.IsRootfull)
}

{
	err := s.Remove()
	if err != nil {
		return err
	}

	return s.Create()
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	return dbox.ContainerExportDesktopEntry(s.InternalName, appName, fmt.Sprintf("on %s", s.Name), s.IsRootfull)
}

{
	exportedN := 0

	for _, appName := range args {
		err := s.ExportDesktopEntry(appName)
		if err != nil {
			return exportedN, err
		}

		exportedN++
	}

	return exportedN, nil
}

{
	exportedN := 0

	for _, appName := range args {
		err := s.UnexportDesktopEntry(appName)
		if err != nil {
			return exportedN, err
		}

		exportedN++
	}

	return exportedN, nil
}

{
	if !strings.HasPrefix(binary, "/") {
		binaryPath, err := s.Exec(true, false, "which", binary)
		if err != nil {
			return err
		}

		binary = strings.TrimSpace(binaryPath)
	}

	binaryName := filepath.Base(binary)

	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	homeDir, err := os.UserHomeDir()
	if err != nil {
		return err
	}

	if exportPath == "" {
		exportPath = filepath.Join(homeDir, ".local", "bin")
	}

	joinedPath := filepath.Join(exportPath, binaryName)
	if _, err := os.Stat(joinedPath); err == nil {
		tmpExportPath := fmt.Sprintf("/tmp/%s", uuid.New().String())
		err = os.MkdirAll(tmpExportPath, 0o755)
		if err != nil {
			return err
		}

		err = dbox.ContainerExportBin(s.InternalName, binary, tmpExportPath, s.IsRootfull)
		if err != nil {
			return err
		}

		err = CopyFile(filepath.Join(tmpExportPath, binaryName), filepath.Join(exportPath, fmt.Sprintf("%s-%s", binaryName, s.InternalName)))
		if err != nil {
			return err
		}

		err = os.RemoveAll(tmpExportPath)
		if err != nil {
			return err
		}

		err = os.Chmod(filepath.Join(exportPath, fmt.Sprintf("%s-%s", binaryName, s.InternalName)), 0o755)
		if err != nil {
			return err
		}

		return nil
	}

	err = os.MkdirAll(exportPath, 0o755)
	if err != nil {
		return err
	}

	err = dbox.ContainerExportBin(s.InternalName, binary, exportPath, s.IsRootfull)
	if err != nil {
		return err
	}

	return nil
}

{
	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	return dbox.ContainerUnexportDesktopEntry(s.InternalName, appName, s.IsRootfull)
}

{
	if !strings.HasPrefix(binary, "/") {
		binaryPath, err := s.Exec(true, false, "which", binary)
		if err != nil {
			return err
		}

		binary = strings.TrimSpace(binaryPath)
	}

	dbox, err := NewDbox()
	if err != nil {
		return err
	}

	return dbox.ContainerUnexportBin(s.InternalName, binary, s.IsRootfull)
}