core

func CopyToUserTemp(path string) (string, error)

{
	userCacheDir, err := os.UserCacheDir()
	if err != nil {
		return "", err
	}

	cacheDir := filepath.Join(userCacheDir, "apx")
	if _, err := os.Stat(cacheDir); os.IsNotExist(err) {
		if err := os.MkdirAll(cacheDir, 0755); err != nil {
			return "", err
		}
	}

	fileName := filepath.Base(path)
	newPath := filepath.Join(cacheDir, fileName)

	pathContents, err := os.Open(path)
	if err != nil {
		return "", err
	}
	defer pathContents.Close()

	newPathContents, err := os.Create(newPath)
	if err != nil {
		return "", err
	}
	defer newPathContents.Close()

	_, err = newPathContents.ReadFrom(pathContents)
	if err != nil {
		return "", err
	}

	return newPath, nil
}

func getPrettifiedDate(date string) string

{
	t, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", date)
	if err != nil {
		return date
	}

	// If the date is less than 24h ago, return the time since
	if t.After(time.Now().Add(-24 * time.Hour)) {
		duration := time.Since(t).Round(time.Hour)
		hours := int(duration.Hours())
		return fmt.Sprintf("%dh ago", hours)
	}

	return t.Format("02 Jan 2006 15:04:05")
}

func CreateApxTable(writer io.Writer) *tablewriter.Table

{
	table := tablewriter.NewWriter(writer)
	table.SetColumnSeparator("┊")
	table.SetCenterSeparator("┼")
	table.SetRowSeparator("┄")
	table.SetHeaderLine(true)
	table.SetAlignment(tablewriter.ALIGN_LEFT)
	table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
	table.SetRowLine(true)

	return table
}

func CopyFile(src, dst string) error

{
	source, err := os.Open(src)
	if err != nil {
		return err
	}
	defer source.Close()

	destination, err := os.Create(dst)
	if err != nil {
		return err
	}
	defer destination.Close()

	_, err = io.Copy(destination, source)
	if err != nil {
		return err
	}

	return nil
}

func SelectYamlFile(basePath string, name string) string

{
	const (
		YML  string = ".yml"
		YAML string = ".yaml"
	)

	yamlFile := filepath.Join(basePath, fmt.Sprintf("%s%s", name, YAML))
	ymlFile := filepath.Join(basePath, fmt.Sprintf("%s%s", name, YML))

	if _, err := os.Stat(yamlFile); errors.Is(err, os.ErrNotExist) {
		return ymlFile
	}

	return yamlFile
}

func NewApx(cnf *settings.Config) *Apx

{
	apx = &Apx{
		Cnf: cnf,
	}

	err := apx.EssentialChecks()
	if err != nil {
		// localisation features aren't available at this stage, so this error can't be translated
		fmt.Println("ERROR: Unable to find apx configuration files")
		return nil
	}

	return apx
}

func NewStandardApx() *Apx

{
	cnf, err := settings.GetApxDefaultConfig()
	if err != nil {
		panic(err)
	}

	apx = &Apx{
		Cnf: cnf,
	}

	err = apx.EssentialChecks()
	if err != nil {
		// localisation features aren't available at this stage, so this error can't be translated
		fmt.Println("ERROR: Unable to find apx configuration files")
		return nil
	}
	return apx
}

func NewDbox() (*dbox, error)

{
	engineBinary, engine := getEngine()

	version, err := dboxGetVersion()
	if err != nil {
		return nil, err
	}

	return &dbox{
		Engine:       engine,
		EngineBinary: engineBinary,
		Version:      version,
	}, nil
}

func getEngine() (string, string)

{
	podmanBinary, err := settings.LookPath("podman")
	if err == nil {
		return podmanBinary, "podman"
	}

	dockerBinary, err := settings.LookPath("docker")
	if err == nil {
		return dockerBinary, "docker"
	}

	log.Fatal("no container engine found. Please install Podman or Docker.")
	return "", ""
}

func dboxGetVersion() (version string, err error)

{
	entrypoint := apx.Cnf.DistroboxPath
	finalArgs := []string{"version"}
	if settings.IsFlatpak() {
		finalArgs = append([]string{"--host", entrypoint}, finalArgs...)
		entrypoint = "flatpak-spawn"
	}
	output, err := exec.Command(entrypoint, finalArgs...).Output()
	if err != nil {
		return "", err
	}

	splitted := strings.Split(string(output), "distrobox: ")
	if len(splitted) != 2 {
		return "", errors.New("can't retrieve distrobox version")
	}

	return splitted[1], nil
}

func NewPkgManager(name string, needSudo bool, autoRemove, clean, install, list, purge, remove, search, show, update, upgrade string, builtIn bool) *PkgManager

{
	return &PkgManager{
		Name:          name,
		NeedSudo:      needSudo,
		CmdAutoRemove: autoRemove,
		CmdClean:      clean,
		CmdInstall:    install,
		CmdList:       list,
		CmdPurge:      purge,
		CmdRemove:     remove,
		CmdSearch:     search,
		CmdShow:       show,
		CmdUpdate:     update,
		CmdUpgrade:    upgrade,
		BuiltIn:       builtIn,
		Model:         2,
	}
}

func loadPkgManagerFromPath(path string) (*PkgManager, error)

{
	pkgManager := &PkgManager{}

	f, err := os.Open(path)
	if err != nil {
		return nil, errors.New("package manager not found")
	}

	data, err := io.ReadAll(f)
	if err != nil {
		return nil, err
	}

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

	return pkgManager, nil
}

func ListPkgManagers() []*PkgManager

{
	pkgManagers := make([]*PkgManager, 0)

	pkgManagersFromEtc := listPkgManagersFromPath(apx.Cnf.UserPkgManagersPath)
	pkgManagers = append(pkgManagers, pkgManagersFromEtc...)

	if apx.Cnf.PkgManagersPath == apx.Cnf.UserPkgManagersPath {
		// user install
		return pkgManagers
	}

	pkgManagersFromShare := listPkgManagersFromPath(apx.Cnf.PkgManagersPath)
	pkgManagers = append(pkgManagers, pkgManagersFromShare...)

	return pkgManagers
}

func listPkgManagersFromPath(path string) []*PkgManager

{
	pkgManagers := make([]*PkgManager, 0)

	files, err := os.ReadDir(path)
	if err != nil {
		return pkgManagers
	}

	for _, file := range files {
		extension := filepath.Ext(file.Name())

		if !file.IsDir() && (extension == ".yaml" || extension == ".yml") {
			// Remove the ".yaml" or ".yml" extension
			pkgManagerName := file.Name()[:(len(file.Name()) - len(extension))]
			pkgManager, err := LoadPkgManager(pkgManagerName)
			if err == nil {
				pkgManagers = append(pkgManagers, pkgManager)
			}
		}
	}

	return pkgManagers
}

func LoadPkgManagerFromPath(path string) (*PkgManager, error)

{
	pkgManager := &PkgManager{}

	f, err := os.Open(path)
	if err != nil {
		return nil, errors.New("package manager not found")
	}

	data, err := io.ReadAll(f)
	if err != nil {
		return nil, err
	}

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

	if pkgManager.Model == 0 {
		pkgManager.Model = 1 // assuming old model if not specified
	}

	return pkgManager, nil
}

func LoadStackFromPath(path string) (*Stack, error)

{
	stack := &Stack{}

	f, err := os.Open(path)
	if err != nil {
		return nil, errors.New("stack not found")
	}

	data, err := io.ReadAll(f)
	if err != nil {
		return nil, err
	}

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

	if stack.Name == "" || stack.Base == "" || stack.PkgManager == "" {
		return nil, errors.New("invalid stack file")
	}

	return stack, nil
}

func ListStacks() []*Stack

{
	stacks := make([]*Stack, 0)

	stacksFromEtc := listStacksFromPath(apx.Cnf.UserStacksPath)
	stacks = append(stacks, stacksFromEtc...)

	if apx.Cnf.UserStacksPath == apx.Cnf.StacksPath {
		// user install
		return stacks
	}

	stacksFromShare := listStacksFromPath(apx.Cnf.StacksPath)
	stacks = append(stacks, stacksFromShare...)

	return stacks
}

func ListStackForPkgManager(pkgManager string) []*Stack

{
	stacks := make([]*Stack, 0)

	stacksFromEtc := listStacksFromPath(apx.Cnf.UserStacksPath)
	for _, stack := range stacksFromEtc {
		if stack.PkgManager == pkgManager {
			stacks = append(stacks, stack)
		}
	}

	stacksFromShare := listStacksFromPath(apx.Cnf.StacksPath)
	for _, stack := range stacksFromShare {
		if stack.PkgManager == pkgManager {
			stacks = append(stacks, stack)
		}
	}

	return stacks
}

func listStacksFromPath(path string) []*Stack

{
	stacks := make([]*Stack, 0)

	files, err := os.ReadDir(path)
	if err != nil {
		return stacks
	}

	for _, file := range files {
		extension := filepath.Ext(file.Name())

		if !file.IsDir() && (extension == ".yaml" || extension == ".yml") {
			// Remove the ".yaml" or ".yml" extension
			stackName := file.Name()[:(len(file.Name()) - len(extension))]
			stack, err := LoadStack(stackName)
			if err == nil {
				stacks = append(stacks, stack)
			}
		}
	}

	return stacks
}

func NewSubSystem(name string, stack *Stack, home string, hasInit bool, isManaged bool, isRootfull bool, isUnshared bool, hasNvidiaIntegration bool, hostname string) (*SubSystem, error)

{
	internalName := genInternalName(name)
	return &SubSystem{
		InternalName:         internalName,
		Name:                 name,
		Stack:                stack,
		Home:                 home,
		HasInit:              hasInit,
		IsManaged:            isManaged,
		IsRootfull:           isRootfull,
		IsUnshared:           isUnshared,
		HasNvidiaIntegration: hasNvidiaIntegration,
		Hostname:             hostname,
	}, nil
}

func findExportedBinaries(internalName string) map[string]map[string]string

{
	home, err := os.UserHomeDir()
	if err != nil {
		return map[string]map[string]string{}
	}
	binPath := filepath.Join(home, ".local", "bin")
	if _, err := os.Stat(binPath); os.IsNotExist(err) {
		return map[string]map[string]string{}
	}
	binDir := os.DirFS(binPath)

	binaries := map[string]map[string]string{}
	err = fs.WalkDir(binDir, ".", func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if d.IsDir() {
			return nil
		}

		file, err := os.Open(filepath.Join(binPath, path))
		if err != nil {
			return err
		}
		defer file.Close()

		var header = "#!/bin/sh\n# distrobox_binary\n# name: " + internalName
		var maxTokenSize = len(header)
		var buffer = make([]byte, maxTokenSize)

		n, err := file.Read(buffer)
		if err != nil && err != io.EOF {
			return err
		}

		buffer = buffer[:n]

		if string(buffer) == header {
			name := filepath.Base(path)
			binaries[name] = map[string]string{
				"Exec": path,
				"Name": name,
			}
		}

		return nil
	})
	if err != nil {
		fmt.Printf("error reading binaries: %s\n", err)
		return map[string]map[string]string{}
	}

	return binaries
}

func findExportedPrograms(internalName string, name string) map[string]map[string]string

{
	home, err := os.UserHomeDir()
	if err != nil {
		return map[string]map[string]string{}
	}

	files, err := filepath.Glob(fmt.Sprintf("%s/.local/share/applications/%s-*.desktop", home, internalName))
	if err != nil {
		return map[string]map[string]string{}
	}

	programs := map[string]map[string]string{}
	for _, file := range files {
		f, err := os.Open(file)
		if err != nil {
			return map[string]map[string]string{}
		}
		defer f.Close()

		data, err := io.ReadAll(f)
		if err != nil {
			continue
		}

		pName := ""
		pExec := ""
		pIcon := ""
		pGenericName := ""
		for _, line := range strings.Split(string(data), "\n") {
			if strings.HasPrefix(line, "Name=") {
				pName = strings.TrimPrefix(line, "Name=")
				pName = strings.ReplaceAll(pName, fmt.Sprintf(" on %s", name), "")
			}

			if strings.HasPrefix(line, "Exec=") {
				pExec = strings.TrimPrefix(line, "Exec=")
			}

			if strings.HasPrefix(line, "Icon=") {
				pIcon = strings.TrimPrefix(line, "Icon=")
			}

			if strings.HasPrefix(line, "GenericName=") {
				pGenericName = strings.TrimPrefix(line, "GenericName=")
			}
		}

		if pName != "" && pExec != "" {
			programs[pName] = map[string]string{
				"Exec":        pExec,
				"Icon":        pIcon,
				"Name":        pName,
				"GenericName": pGenericName,
			}
		}
	}

	return programs
}

func findExported(internalName string, name string) map[string]map[string]string

{
	bins := findExportedBinaries(internalName)
	progs := findExportedPrograms(internalName, name)

	// If duplicate is found, give priority to application
	for k, v := range progs {
		bins[k] = v
	}

	return bins
}

func LoadSubSystem(name string, isRootFull bool) (*SubSystem, error)

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

	internalName := genInternalName(name)
	container, err := dbox.GetContainer(internalName, isRootFull)
	if err != nil {
		return nil, err
	}

	stack, err := LoadStack(container.Labels["stack"])
	if err != nil {
		return nil, err
	}
	return &SubSystem{
		InternalName: internalName,
		Name:         container.Labels["name"],
		Stack:        stack,
		Status:       container.Status,
		HasInit:      container.Labels["hasInit"] == "true",
		IsManaged:    container.Labels["managed"] == "true",
		IsRootfull:   isRootFull,
		IsUnshared:   container.Labels["unshared"] == "true",
	}, nil
}

func ListSubSystems(includeManaged bool, includeRootFull bool) ([]*SubSystem, error)

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

	containers, err := dbox.ListContainers(includeRootFull)
	if err != nil {
		return nil, err
	}

	subsystems := []*SubSystem{}
	for _, container := range containers {
		if _, ok := container.Labels["name"]; !ok {
			// log.Printf("Container %s has no name label, skipping", container.Name)
			continue
		}

		if !includeManaged {
			if _, ok := container.Labels["managed"]; ok {
				continue
			}
		}

		stack, err := LoadStack(container.Labels["stack"])
		if err != nil {
			log.Printf("Error loading stack %s: %s", container.Labels["stack"], err)
			continue
		}

		internalName := genInternalName(container.Labels["name"])
		subsystem := &SubSystem{
			InternalName:     internalName,
			Name:             container.Labels["name"],
			Stack:            stack,
			Status:           container.Status,
			ExportedPrograms: findExported(internalName, container.Labels["name"]),
		}

		subsystems = append(subsystems, subsystem)
	}

	return subsystems, nil
}

func ListSubsystemForStack(stackName string) ([]*SubSystem, error)

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

	containers, err := dbox.ListContainers(false)
	if err != nil {
		return nil, err
	}

	subsystems := []*SubSystem{}
	for _, container := range containers {
		containerManager, ok := container.Labels["manager"]
		if !ok || containerManager != "apx" {
			continue
		}

		containerName, ok := container.Labels["name"]
		if !ok {
			continue
		}

		containerStack, ok := container.Labels["stack"]
		if !ok || containerStack != stackName {
			continue
		}

		stack, err := LoadStack(containerStack)
		if err != nil {
			log.Printf("Error loading stack %s: %s", containerStack, err)
			continue
		}

		internalName := genInternalName(containerName)
		subsystem := &SubSystem{
			InternalName:     internalName,
			Name:             containerName,
			Stack:            stack,
			Status:           container.Status,
			ExportedPrograms: findExported(internalName, containerName),
		}

		subsystems = append(subsystems, subsystem)
	}

	return subsystems, nil
}