cli

func (*SubsystemEnterCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}
	err = subSystem.Enter()
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.enteringContainer"), err)
	}
	return nil
}

func (*SubsystemRunCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}
	_, err = subSystem.Exec(false, false, c.Args...)
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.executingCommand"), err)
	}
	return nil
}

func (*SubsystemInstallCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

	pkgManager, err := subSystem.Stack.GetPkgManager()
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.cantAccessPkgManager"), err)
	}

	finalArgs := pkgManager.GenCmd(pkgManager.CmdInstall, c.Args...)
	_, err = subSystem.Exec(false, false, finalArgs...)
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.executingCommand"), err)
	}

	if !c.NoExport {
		exportedN, err := subSystem.ExportDesktopEntries(c.Args...)
		if err == nil {
			Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.exportedApps"), exportedN)
		}
	}
	return nil
}

func (*SubsystemRemoveCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

	pkgManager, err := subSystem.Stack.GetPkgManager()
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.cantAccessPkgManager"), err)
	}

	exportedN, err := subSystem.UnexportDesktopEntries(c.Args...)
	if err == nil {
		Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.unexportedApps"), exportedN)
	}

	finalArgs := pkgManager.GenCmd(pkgManager.CmdRemove, c.Args...)
	_, err = subSystem.Exec(false, false, finalArgs...)
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.executingCommand"), err)
	}
	return nil
}

func (*SubsystemExportCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

	if c.AppName == "" && c.Bin == "" {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.noAppNameOrBin"))
	}

	if c.AppName != "" && c.Bin != "" {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.sameAppOrBin"))
	}

	if c.AppName != "" {
		err := subSystem.ExportDesktopEntry(c.AppName)
		if err != nil {
			return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.exportingApp"), err)
		}
		Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.exportedApp"), c.AppName)
	} else {
		err := subSystem.ExportBin(c.Bin, c.BinOutput)
		if err != nil {
			return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.exportingBin"), err)
		}
		Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.exportedBin"), c.Bin)
	}
	return nil
}

func (*SubsystemUnexportCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

	if c.AppName == "" && c.Bin == "" {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.noAppNameOrBin"))
	}

	if c.AppName != "" && c.Bin != "" {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.sameAppOrBin"))
	}

	if c.AppName != "" {
		err := subSystem.UnexportDesktopEntry(c.AppName)
		if err != nil {
			return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.unexportingApp"), err)
		}
		Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.unexportedApp"), c.AppName)
	} else {
		err := subSystem.UnexportBin(c.Bin, c.BinOutput)
		if err != nil {
			return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.unexportingBin"), err)
		}
		Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.unexportedBin"), c.Bin)
	}
	return nil
}

func (*SubsystemStartCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}
	Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.startingContainer"), subSystem.Name)
	err = subSystem.Start()
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.startingContainer"), err)
	}
	Apx.Log.Info(Apx.LC.Get("runtimeCommand.info.startedContainer"))
	return nil
}

func (*SubsystemStopCmd) Run() error
{
	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}
	Apx.Log.Infof(Apx.LC.Get("runtimeCommand.info.stoppingContainer"), subSystem.Name)
	err = subSystem.Stop()
	if err != nil {
		return fmt.Errorf(Apx.LC.Get("runtimeCommand.error.stoppingContainer"), err)
	}
	Apx.Log.Info(Apx.LC.Get("runtimeCommand.info.stoppedContainer"))
	return nil
}

func (*StacksListCmd) Run() error
{
	stacks := core.ListStacks()

	if !c.Json {
		stacksCount := len(stacks)
		if stacksCount == 0 {
			fmt.Println(Apx.LC.Get("stacks.list.info.noStacks"))
			return nil
		}

		Apx.Log.Infof(Apx.LC.Get("stacks.list.info.foundStacks"), stacksCount)

		headers := []string{Apx.LC.Get("stacks.labels.name"), "Base", Apx.LC.Get("stacks.labels.builtIn"), "Pkgs", "Pkg manager"}
		var data [][]string
		for _, stack := range stacks {
			builtIn := Apx.LC.Get("apx.terminal.no")
			if stack.BuiltIn {
				builtIn = Apx.LC.Get("apx.terminal.yes")
			}
			data = append(data, []string{stack.Name, stack.Base, builtIn, fmt.Sprintf("%d", len(stack.Packages)), stack.PkgManager})
		}
		Apx.CLI.Table(headers, data)
	} else {
		jsonStacks, err := json.MarshalIndent(stacks, "", "  ")
		if err != nil {
			return err
		}

		fmt.Println(string(jsonStacks))
	}

	return nil
}

func (*StacksShowCmd) Run() error
{
	args := c.Args
	if len(args) == 0 {
		return fmt.Errorf("stack name required")
	}
	stack, error := core.LoadStack(args[0])
	if error != nil {
		return error
	}

	headers := []string{"Property", "Value"}
	data := [][]string{
		{Apx.LC.Get("stacks.labels.name"), stack.Name},
		{"Base", stack.Base},
		{"Packages", strings.Join(stack.Packages, ", ")},
		{"Package manager", stack.PkgManager},
	}
	Apx.CLI.Table(headers, data)

	return nil
}

func (*StacksNewCmd) Run() error
{

	if c.Name == "" {
		if !c.NoPrompt {
			name, err := Apx.CLI.PromptText(Apx.LC.Get("stacks.new.info.askName"), "")
			if err != nil {
				return err
			}
			c.Name = name
			if c.Name == "" {
				Apx.Log.Error(Apx.LC.Get("stacks.new.error.emptyName"))
				return nil
			}
		} else {
			Apx.Log.Error(Apx.LC.Get("stacks.new.error.noName"))
			return nil
		}
	}

	ok := core.StackExists(c.Name)
	if ok {
		if ok {
			Apx.Log.Errorf(Apx.LC.Get("stacks.new.error.alreadyExists"), c.Name)
			return nil
		}
	}

	if c.BaseImage == "" {
		if !c.NoPrompt {
			base, err := Apx.CLI.PromptText(Apx.LC.Get("stacks.new.info.askBase"), "")
			if err != nil {
				return err
			}
			c.BaseImage = base
			if c.BaseImage == "" {
				Apx.Log.Error(Apx.LC.Get("stacks.new.error.emptyBase"))
				return nil
			}
		} else {
			Apx.Log.Error(Apx.LC.Get("stacks.new.error.noBase"))
			return nil
		}
	}

	if c.PkgManager == "" {
		pkgManagers := core.ListPkgManagers()
		if len(pkgManagers) == 0 {
			Apx.Log.Error(Apx.LC.Get("stacks.new.error.noPkgManagers"))
			return nil
		}

		var options []string
		for _, manager := range pkgManagers {
			options = append(options, manager.Name)
		}

		selected, err := Apx.CLI.SelectOption(Apx.LC.Get("stacks.new.info.selectPkgManager"), options)
		if err != nil {
			return err
		}
		c.PkgManager = selected
	}

	ok = core.PkgManagerExists(c.PkgManager)
	if !ok {
		Apx.Log.Error(Apx.LC.Get("stacks.new.error.pkgManagerDoesNotExist"))
		return nil
	}

	packagesArray := strings.Fields(c.Packages)
	if len(packagesArray) == 0 && !c.NoPrompt {

		confirm, _ := Apx.CLI.ConfirmAction(
			Apx.LC.Get("stacks.new.info.noPackages"),
			"y", "N",
			false,
		)
		if confirm {
			pkgs, _ := Apx.CLI.PromptText(Apx.LC.Get("stacks.new.info.askPackages"), "")
			packagesInput := strings.TrimSpace(pkgs)
			packagesArray = strings.Fields(packagesInput)
		} else {
			packagesArray = []string{}
		}
	}

	stack := core.NewStack(c.Name, c.BaseImage, packagesArray, c.PkgManager, false)

	err := stack.Save()
	if err != nil {
		return err
	}

	Apx.Log.Infof(Apx.LC.Get("stacks.new.info.success"), c.Name)

	return nil
}

func (*StacksUpdateCmd) Run() error
{
	args := c.Args
	if c.Name == "" {
		if len(args) != 1 || args[0] == "" {
			Apx.Log.Error(Apx.LC.Get("stacks.update.error.noName"))
			return nil
		}

		c.Name = args[0]
	}

	stack, error := core.LoadStack(c.Name)
	if error != nil {
		return error
	}

	if stack.BuiltIn {
		Apx.Log.Error(Apx.LC.Get("stacks.update.error.builtIn"))
		os.Exit(126)
	}

	if c.BaseImage == "" {
		if !c.NoPrompt {
			base, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("stacks.update.info.askBase"), stack.Base), stack.Base)
			if err != nil {
				return err
			}
			c.BaseImage = base
			if c.BaseImage == "" {
				c.BaseImage = stack.Base
			}
		} else {
			Apx.Log.Error(Apx.LC.Get("stacks.update.error.noBase"))
			return nil
		}
	}

	if c.PkgManager == "" {
		if !c.NoPrompt {
			manager, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("stacks.update.info.askPkgManager"), stack.PkgManager), stack.PkgManager)
			if err != nil {
				return err
			}
			c.PkgManager = manager
			if c.PkgManager == "" {
				c.PkgManager = stack.PkgManager
			}
		} else {
			Apx.Log.Error(Apx.LC.Get("stacks.update.error.noPkgManager"))
			return nil
		}
	}

	ok := core.PkgManagerExists(c.PkgManager)
	if !ok {
		Apx.Log.Error(Apx.LC.Get("stacks.update.error.pkgManagerDoesNotExist"))
		return nil
	}

	if len(c.Packages) > 0 {
		stack.Packages = strings.Fields(c.Packages)
	} else if !c.NoPrompt {
		msg := Apx.LC.Get("stacks.update.info.noPackages")
		if len(stack.Packages) > 0 {
			msg = Apx.LC.Get("stacks.update.info.confirmPackages") + "\n\t -" + strings.Join(stack.Packages, "\n\t - ")
		}

		confirm, _ := Apx.CLI.ConfirmAction(msg, "y", "N", false)

		packagesArray := []string{}

		if confirm {
			pkgs, _ := Apx.CLI.PromptText(Apx.LC.Get("stacks.update.info.askPackages"), "")
			packagesInput := strings.TrimSpace(pkgs)
			packagesArray = strings.Fields(packagesInput)
			stack.Packages = packagesArray
		}
	}

	stack.Base = c.BaseImage
	stack.PkgManager = c.PkgManager

	err := stack.Save()
	if err != nil {
		return err
	}

	Apx.Log.Infof(Apx.LC.Get("stacks.update.info.success"), c.Name)

	return nil
}

func (*PkgManagersShowCmd) Run() error
{
	args := c.Args
	if len(args) == 0 {
		return fmt.Errorf("package manager name required")
	}
	pkgManagerName := args[0]
	pkgManager, err := core.LoadPkgManager(pkgManagerName)
	if err != nil {
		Apx.Log.Error(err.Error())
		return nil
	}

	headers := []string{"Property", "Value"}
	data := [][]string{
		{Apx.LC.Get("pkgmanagers.labels.name"), pkgManager.Name},
		{"NeedSudo", fmt.Sprintf("%t", pkgManager.NeedSudo)},
		{"AutoRemove", pkgManager.CmdAutoRemove},
		{"Clean", pkgManager.CmdClean},
		{"Install", pkgManager.CmdInstall},
		{"List", pkgManager.CmdList},
		{"Purge", pkgManager.CmdPurge},
		{"Remove", pkgManager.CmdRemove},
		{"Search", pkgManager.CmdSearch},
		{"Show", pkgManager.CmdShow},
		{"Update", pkgManager.CmdUpdate},
		{"Upgrade", pkgManager.CmdUpgrade},
	}

	err = Apx.CLI.Table(headers, data)
	if err != nil {
		return err
	}

	return nil
}

func (*PkgManagersUpdateCmd) Run() error
{
	args := c.Args
	if c.Name == "" {
		if len(args) != 1 || args[0] == "" {
			Apx.Log.Error(Apx.LC.Get("pkgmanagers.update.error.noName"))
			return nil
		}

		c.Name = args[0]
	}

	pkgmanager, error := core.LoadPkgManager(c.Name)
	if error != nil {
		return error
	}

	if pkgmanager.BuiltIn {
		Apx.Log.Error(Apx.LC.Get("pkgmanagers.update.error.builtIn"))
		os.Exit(126)
	}

	if c.AutoRemove == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "autoRemove", pkgmanager.CmdAutoRemove), pkgmanager.CmdAutoRemove)
			if err != nil {
				return err
			}
			c.AutoRemove = strings.TrimSpace(answer)
			if c.AutoRemove == "" {
				c.AutoRemove = pkgmanager.CmdAutoRemove
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "autoRemove")
			return nil
		}
	}

	if c.Clean == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "clean", pkgmanager.CmdClean), pkgmanager.CmdClean)
			if err != nil {
				return err
			}
			c.Clean = strings.TrimSpace(answer)
			if c.Clean == "" {
				c.Clean = pkgmanager.CmdClean
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "clean")
			return nil
		}
	}

	if c.Install == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "install", pkgmanager.CmdInstall), pkgmanager.CmdInstall)
			if err != nil {
				return err
			}
			c.Install = strings.TrimSpace(answer)
			if c.Install == "" {
				c.Install = pkgmanager.CmdInstall
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "install")
			return nil
		}
	}

	if c.List == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "list", pkgmanager.CmdList), pkgmanager.CmdList)
			if err != nil {
				return err
			}
			c.List = strings.TrimSpace(answer)
			if c.List == "" {
				c.List = pkgmanager.CmdList
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "list")
			return nil
		}
	}

	if c.Purge == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "purge", pkgmanager.CmdPurge), pkgmanager.CmdPurge)
			if err != nil {
				return err
			}
			c.Purge = strings.TrimSpace(answer)
			if c.Purge == "" {
				c.Purge = pkgmanager.CmdPurge
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "purge")
			return nil
		}
	}

	if c.Remove == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "remove", pkgmanager.CmdRemove), pkgmanager.CmdRemove)
			if err != nil {
				return err
			}
			c.Remove = strings.TrimSpace(answer)
			if c.Remove == "" {
				c.Remove = pkgmanager.CmdRemove
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "remove")
			return nil
		}
	}

	if c.Search == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "search", pkgmanager.CmdSearch), pkgmanager.CmdSearch)
			if err != nil {
				return err
			}
			c.Search = strings.TrimSpace(answer)
			if c.Search == "" {
				c.Search = pkgmanager.CmdSearch
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "search")
			return nil
		}
	}

	if c.Show == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "show", pkgmanager.CmdShow), pkgmanager.CmdShow)
			if err != nil {
				return err
			}
			c.Show = strings.TrimSpace(answer)
			if c.Show == "" {
				c.Show = pkgmanager.CmdShow
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "show")
			return nil
		}
	}

	if c.Update == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "update", pkgmanager.CmdUpdate), pkgmanager.CmdUpdate)
			if err != nil {
				return err
			}
			c.Update = strings.TrimSpace(answer)
			if c.Update == "" {
				c.Update = pkgmanager.CmdUpdate
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "update")
			return nil
		}
	}

	if c.Upgrade == "" {
		if !c.NoPrompt {
			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.update.info.askNewCommand"), "upgrade", pkgmanager.CmdUpgrade), pkgmanager.CmdUpgrade)
			if err != nil {
				return err
			}
			c.Upgrade = strings.TrimSpace(answer)
			if c.Upgrade == "" {
				c.Upgrade = pkgmanager.CmdUpgrade
			}
		} else {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.update.error.missingCommand"), "upgrade")
			return nil
		}
	}

	pkgmanager.NeedSudo = c.NeedSudo
	pkgmanager.CmdAutoRemove = c.AutoRemove
	pkgmanager.CmdClean = c.Clean
	pkgmanager.CmdInstall = c.Install
	pkgmanager.CmdList = c.List
	pkgmanager.CmdPurge = c.Purge
	pkgmanager.CmdRemove = c.Remove
	pkgmanager.CmdSearch = c.Search
	pkgmanager.CmdShow = c.Show
	pkgmanager.CmdUpdate = c.Update
	pkgmanager.CmdUpgrade = c.Upgrade

	err := pkgmanager.Save()
	if err != nil {
		return err
	}

	Apx.Log.Term.Info().Msgf(Apx.LC.Get("pkgmanagers.new.success"), c.Name)

	return nil
}

func (*StacksRmCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("stacks.rm.error.noName"))
		return nil
	}

	subSystems, _ := core.ListSubsystemForStack(c.Name)
	if len(subSystems) > 0 {
		Apx.Log.Errorf(Apx.LC.Get("stacks.rm.error.inUse"), len(subSystems))
		headers := []string{Apx.LC.Get("subsystems.labels.name"), "Stack", Apx.LC.Get("subsystems.labels.status"), "Pkgs"}
		var data [][]string
		for _, subSystem := range subSystems {
			data = append(data, []string{
				subSystem.Name,
				subSystem.Stack.Name,
				subSystem.Status,
				fmt.Sprintf("%d", len(subSystem.Stack.Packages)),
			})
		}
		Apx.CLI.Table(headers, data)
		return nil
	}

	if !c.Force {
		confirm, err := Apx.CLI.ConfirmAction(
			fmt.Sprintf(Apx.LC.Get("stacks.rm.info.askConfirmation"), c.Name),
			"y", "N",
			false,
		)
		if err != nil {
			return err
		}
		if !confirm {
			Apx.Log.Infof(Apx.LC.Get("pkgmanagers.rm.info.aborting"), c.Name)
			return nil
		}
	}

	stack, error := core.LoadStack(c.Name)
	if error != nil {
		return error
	}

	error = stack.Remove()
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("stacks.rm.info.success"), c.Name)
	return nil
}

func (*StacksExportCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("stacks.export.error.noName"))
		return nil
	}

	stack, error := core.LoadStack(c.Name)
	if error != nil {
		return error
	}

	if c.Output == "" {
		Apx.Log.Error(Apx.LC.Get("stacks.export.error.noOutput"))
		return nil
	}

	error = stack.Export(c.Output)
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("stacks.export.info.success"), stack.Name, c.Output)
	return nil
}

func (*StacksImportCmd) Run() error
{
	if c.Input == "" {
		Apx.Log.Error(Apx.LC.Get("stacks.import.error.noInput"))
		return nil
	}

	stack, error := core.LoadStackFromPath(c.Input)
	if error != nil {
		Apx.Log.Errorf(Apx.LC.Get("stacks.import.error.cannotLoad"), c.Input)
	}

	error = stack.Save()
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("stacks.import.info.success"), stack.Name)
	return nil
}

func (*SubsystemsListCmd) Run() error
{
	subSystems, err := core.ListSubSystems(false, false)
	if err != nil {
		return err
	}

	if !c.Json {
		subSystemsCount := len(subSystems)
		if subSystemsCount == 0 {
			Apx.Log.Info(Apx.LC.Get("subsystems.list.info.noSubsystems"))
			return nil
		}

		Apx.Log.Infof(Apx.LC.Get("subsystems.list.info.foundSubsystems"), subSystemsCount)

		headers := []string{Apx.LC.Get("subsystems.labels.name"), "Stack", Apx.LC.Get("subsystems.labels.status"), "Pkgs"}
		var data [][]string
		for _, subSystem := range subSystems {
			data = append(data, []string{
				subSystem.Name,
				subSystem.Stack.Name,
				subSystem.Status,
				fmt.Sprintf("%d", len(subSystem.Stack.Packages)),
			})
		}

		err := Apx.CLI.Table(headers, data)
		if err != nil {
			return err
		}
	} else {
		jsonSubSystems, err := json.MarshalIndent(subSystems, "", "  ")
		if err != nil {
			return err
		}

		fmt.Println(string(jsonSubSystems))
	}

	return nil
}

func (*SubsystemsNewCmd) Run() error
{

	stacks := core.ListStacks()
	if len(stacks) == 0 {
		Apx.Log.Error(Apx.LC.Get("subsystems.new.error.noStacks"))
		return nil
	}

	if c.Name == "" {
		name, err := Apx.CLI.PromptText(Apx.LC.Get("subsystems.new.info.askName"), "")
		if err != nil {
			return err
		}
		c.Name = name
		if c.Name == "" {
			Apx.Log.Error(Apx.LC.Get("subsystems.new.error.emptyName"))
			return nil
		}
	}

	if c.Stack == "" {
		var options []string
		for _, stack := range stacks {
			options = append(options, stack.Name)
		}

		selected, err := Apx.CLI.SelectOption(Apx.LC.Get("subsystems.new.info.selectStack"), options)
		if err != nil {
			return err
		}
		c.Stack = selected
	}

	checkSubSystem, err := core.LoadSubSystem(c.Name, false)
	if err == nil {
		Apx.Log.Errorf(Apx.LC.Get("subsystems.new.error.alreadyExists"), checkSubSystem.Name)
		return nil
	}

	// Checking if name conflicts with existing commands.
	// In SDK declarative approach, we might need a way to check root commands.
	// Apx.CLI.GetRoot() returns the struct.
	// We can iterate simple tags or just use known conflicts.
	// For now we skip detailed conflict check as we are rebuilding.
	// Or we could check if c.Name is a valid command name if feasible.

	stack, err := core.LoadStack(c.Stack)
	if err != nil {
		return err
	}

	subSystem, err := core.NewSubSystem(c.Name, stack, c.Home, c.Init, false, false, false, true, "")
	if err != nil {
		return err
	}

	spinner := Apx.CLI.StartSpinner(fmt.Sprintf(Apx.LC.Get("subsystems.new.info.creatingSubsystem"), c.Name, c.Stack))

	err = subSystem.Create()
	if err != nil {
		spinner.Stop()
		return err
	}

	spinner.Stop()
	Apx.Log.Infof(Apx.LC.Get("subsystems.new.info.success"), c.Name)

	return nil
}

func (*SubsystemsRmCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("subsystems.rm.error.noName"))
		return nil
	}

	if !c.Force {
		confirm, _ := Apx.CLI.ConfirmAction(
			fmt.Sprintf(Apx.LC.Get("subsystems.rm.info.askConfirmation"), c.Name),
			"y", "N",
			false,
		)
		if !confirm {
			Apx.Log.Term.Info().Msg(Apx.LC.Get("apx.info.aborting"))
			return nil
		}
	}

	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

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

	Apx.Log.Infof(Apx.LC.Get("subsystems.rm.info.success"), c.Name)

	return nil
}

func (*SubsystemsResetCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("subsystems.reset.error.noName"))
		return nil
	}

	if !c.Force {
		confirm, _ := Apx.CLI.ConfirmAction(
			fmt.Sprintf(Apx.LC.Get("subsystems.reset.info.askConfirmation"), c.Name),
			"y", "N",
			false,
		)
		if !confirm {
			Apx.Log.Info(Apx.LC.Get("apx.info.aborting"))
			return nil
		}
	}

	subSystem, err := core.LoadSubSystem(c.Name, false)
	if err != nil {
		return err
	}

	err = subSystem.Reset()
	if err != nil {
		return err
	}

	Apx.Log.Infof(Apx.LC.Get("subsystems.reset.info.success"), c.Name)

	return nil
}

func (*PkgManagersListCmd) Run() error
{
	pkgManagers := core.ListPkgManagers()

	if !c.Json {
		pkgManagersCount := len(pkgManagers)
		if pkgManagersCount == 0 {
			Apx.Log.Info(Apx.LC.Get("pkgmanagers.list.info.noPkgManagers"))
			return nil
		}

		Apx.Log.Infof(Apx.LC.Get("pkgmanagers.list.info.foundPkgManagers"), pkgManagersCount)

		headers := []string{Apx.LC.Get("pkgmanagers.labels.name"), Apx.LC.Get("pkgmanagers.labels.builtIn")}
		var data [][]string
		for _, stack := range pkgManagers {
			builtIn := Apx.LC.Get("apx.terminal.no")
			if stack.BuiltIn {
				builtIn = Apx.LC.Get("apx.terminal.yes")
			}
			data = append(data, []string{stack.Name, builtIn})
		}

		err := Apx.CLI.Table(headers, data)
		if err != nil {
			return err
		}
	} else {
		jsonPkgManagers, _ := json.MarshalIndent(pkgManagers, "", "  ")
		fmt.Println(string(jsonPkgManagers))
	}

	return nil
}

func (*PkgManagersNewCmd) Run() error
{

	if c.Name == "" {
		if c.NoPrompt {
			Apx.Log.Error(Apx.LC.Get("pkgmanagers.new.error.noName"))
			return nil
		}

		name, err := Apx.CLI.PromptText(Apx.LC.Get("pkgmanagers.new.info.askName"), "")
		if err != nil {
			return err
		}
		c.Name = name
		c.Name = strings.ReplaceAll(c.Name, "\n", "")
		c.Name = strings.ReplaceAll(c.Name, " ", "")
		if c.Name == "" {
			Apx.Log.Error(Apx.LC.Get("pkgmanagers.new.error.emptyName"))
			return nil
		}
	}

	if !c.NeedSudo && !c.NoPrompt {
		choice, err := Apx.CLI.ConfirmAction(
			Apx.LC.Get("pkgmanagers.new.info.askSudo"),
			"y", "N",
			false,
		)
		if err != nil {
			return err
		}
		c.NeedSudo = choice
	}

	cmdMap := map[string]*string{
		PkgManagerCmdAutoRemove: &c.AutoRemove,
		PkgManagerCmdClean:      &c.Clean,
		PkgManagerCmdInstall:    &c.Install,
		PkgManagerCmdList:       &c.List,
		PkgManagerCmdPurge:      &c.Purge,
		PkgManagerCmdRemove:     &c.Remove,
		PkgManagerCmdSearch:     &c.Search,
		PkgManagerCmdShow:       &c.Show,
		PkgManagerCmdUpdate:     &c.Update,
		PkgManagerCmdUpgrade:    &c.Upgrade,
	}

	for _, cmdName := range PkgManagerCmdSetOrder {
		cmd := cmdMap[cmdName]
		if *cmd == "" {
			if c.NoPrompt {
				Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.new.error.noCommand"), cmdName)
				return nil
			}
			if cmdName == PkgManagerCmdPurge || cmdName == PkgManagerCmdAutoRemove {
				answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.new.info.askCommandWithDefault"), cmdName, c.Remove), c.Remove)
				if err != nil {
					return err
				}
				*cmd = strings.TrimSpace(answer)
				if *cmd == "" {
					*cmd = c.Remove
				}
				continue
			}

			answer, err := Apx.CLI.PromptText(fmt.Sprintf(Apx.LC.Get("pkgmanagers.new.info.askCommand"), cmdName), "")
			if err != nil {
				return err
			}
			*cmd = strings.TrimSpace(answer)
			if *cmd == "" {
				Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.new.error.emptyCommand"), cmdName)
				return nil
			}
		}
	}

	if core.PkgManagerExists(c.Name) {
		if c.NoPrompt {
			Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.new.error.alreadyExists"), c.Name)
			return nil
		}

		confirm, err := Apx.CLI.ConfirmAction(
			fmt.Sprintf(Apx.LC.Get("pkgmanagers.new.info.askOverwrite"), c.Name),
			"y", "N",
			false,
		)
		if err != nil {
			return err
		}

		if !confirm {
			Apx.Log.Info(Apx.LC.Get("apx.info.aborting"))
			return nil
		}
	}

	pkgManager := core.NewPkgManager(c.Name, c.NeedSudo, c.AutoRemove, c.Clean, c.Install, c.List, c.Purge, c.Remove, c.Search, c.Show, c.Update, c.Upgrade, false)
	err := pkgManager.Save()
	if err != nil {
		Apx.Log.Error(err.Error())
		return nil
	}

	Apx.Log.Infof(Apx.LC.Get("pkgmanagers.new.success"), c.Name)

	return nil
}

func (*PkgManagersRmCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("pkgmanagers.rm.error.noName"))
		return nil
	}

	pkgManager, error := core.LoadPkgManager(c.Name)
	if error != nil {
		return error
	}

	stacks := core.ListStackForPkgManager(pkgManager.Name)
	if len(stacks) > 0 {
		Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.rm.error.inUse"), len(stacks))
		headers := []string{Apx.LC.Get("pkgmanagers.labels.name"), "Base", "Packages", "PkgManager", Apx.LC.Get("pkgmanagers.labels.builtIn")}
		var data [][]string
		for _, stack := range stacks {
			builtIn := Apx.LC.Get("apx.terminal.no")
			if stack.BuiltIn {
				builtIn = Apx.LC.Get("apx.terminal.yes")
			}
			data = append(data, []string{stack.Name, stack.Base, strings.Join(stack.Packages, ", "), stack.PkgManager, builtIn})
		}
		Apx.CLI.Table(headers, data)
		return nil
	}

	if !c.Force {
		confirm, err := Apx.CLI.ConfirmAction(
			fmt.Sprintf(Apx.LC.Get("pkgmanagers.rm.info.askConfirmation"), c.Name),
			"y", "N",
			false,
		)
		if err != nil {
			return err
		}
		if !confirm {
			Apx.Log.Infof(Apx.LC.Get("pkgmanagers.rm.info.aborting"), c.Name)
			return nil
		}
	}

	error = pkgManager.Remove()
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("pkgmanagers.rm.info.success"), c.Name)
	return nil
}

func (*PkgManagersExportCmd) Run() error
{
	if c.Name == "" {
		Apx.Log.Error(Apx.LC.Get("pkgmanagers.export.error.noName"))
		return nil
	}

	pkgManager, error := core.LoadPkgManager(c.Name)
	if error != nil {
		return error
	}

	if c.Output == "" {
		Apx.Log.Error(Apx.LC.Get("pkgmanagers.export.error.noOutput"))
		return nil
	}

	error = pkgManager.Export(c.Output)
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("pkgmanagers.export.info.success"), pkgManager.Name, c.Output)
	return nil
}

func (*PkgManagersImportCmd) Run() error
{
	if c.Input == "" {
		Apx.Log.Error(Apx.LC.Get("pkgmanagers.import.error.noInput"))
		return nil
	}

	pkgmanager, error := core.LoadPkgManagerFromPath(c.Input)
	if error != nil {
		Apx.Log.Errorf(Apx.LC.Get("pkgmanagers.import.error.cannotLoad"), c.Input)
	}

	error = pkgmanager.Save()
	if error != nil {
		return error
	}

	Apx.Log.Infof(Apx.LC.Get("pkgmanagers.import.info.success"), pkgmanager.Name)
	return nil
}