commands

var Add = &cobra.Command{
	Use:   "add",
	Short: "Add a file to the current profile.",
	Run: func(cmd *cobra.Command, args []string) {
		if verbose {
			fmt.Println("Adding files:", args)
		}

		profile := config.CurrentProfile()

		for _, f := range args {
			addFileToProfile(f, profile)
		}

		err := git.Sync(profile)
		if err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}
	},
}

var Clean = &cobra.Command{
	Use:   "clean",
	Short: "clean dead symlinks",
	Long:  "Clean looks for any symlinks which are broken and cleans them up. This can happen if files are removed from the profile directory manually instead of through dfm.",
	Run: func(cmd *cobra.Command, args []string) {
		homeDir := os.Getenv("HOME")
		if err := cleanDeadLinks(homeDir); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}

		xdg := os.Getenv("XDG_CONFIG_HOME")
		if xdg == "" {
			xdg = filepath.Join(os.Getenv("HOME"), ".config")
		}

		if err := cleanDeadLinks(xdg); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}
	},
}

var Clone = &cobra.Command{
	Use:   "clone",
	Short: "git clone an existing profile from `URL`",
	Run: func(cmd *cobra.Command, args []string) {
		url, user := CreateURL(strings.Split(args[0], "/"))
		userDir := filepath.Join(config.ProfileDir(), user)
		if name != "" {
			userDir = filepath.Join(config.ProfileDir(), name)
		}

		if err := CloneRepo(url, userDir); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}

		yml := config.LoadDotDFM(userDir)
		for _, module := range yml.Modules {

			module.Location()
		}

		if link {
			args := []string{"dfm", "link", user}
			if overwrite {
				args = []string{"dfm", "link", "-o", user}
			}

			c := exec.Command(args[0], args[1:]...)
			_, err := c.CombinedOutput()
			if err != nil {
				fmt.Println("ERROR:", err.Error())
				os.Exit(1)
			}
		}
	},
}

var Git = &cobra.Command{
	Use:                "git",
	Args:               cobra.ArbitraryArgs,
	Short:              "run the given git command on the current profile",
	DisableFlagParsing: true,
	Run: func(cmd *cobra.Command, args []string) {
		profile := config.CurrentProfile()

		if err := git.RunGitCMD(profile, args...); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}
	},
}

var Init = &cobra.Command{
	Use:   "init",
	Short: "create a new profile with `NAME`",
	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			fmt.Println("Please specify a profile name.")
			os.Exit(1)
		}

		profileDir := config.ProfileDir()
		profile := filepath.Join(profileDir, args[0])
		err := os.MkdirAll(profile, os.ModePerm)
		if err != nil {
			fmt.Println("ERROR: Unable create profile directory: ", profile, err)
			os.Exit(1)
		}

		err = git.Init(profile)
		if err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}
	},
}

var Link = &cobra.Command{
	Use:   "link",
	Short: "link the profile with `NAME`",
	Long:  "will generate and create the symlinks to the dotfiles in the profile",
	Run: func(cmd *cobra.Command, args []string) {
		profile := config.CurrentProfile()
		if len(args) >= 1 {
			profile = config.GetProfileByName(args[0])
		}

		fmt.Println("Linking profile", profile)

		linkProfile(profile)
	},
}

var List = &cobra.Command{
	Use:   "list",
	Short: "list available profiles",
	Run: func(cmd *cobra.Command, args []string) {
		profiles := config.AvailableProfiles()
		for _, profile := range profiles {
			fmt.Println(profile)
		}
	},
}

var Remove = &cobra.Command{
	Use:   "remove",
	Short: "remove the profile with `NAME`",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		profile := args[0]
		userDir := filepath.Join(config.ProfileDir(), profile)

		dfmyml := config.LoadDotDFM(userDir)
		mappings := append(dfmyml.Mappings, filemap.DefaultMappings()...)

		links, err := linking.GenerateSymlinks(userDir, os.Getenv("HOME"), mappings)
		if err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}

		rmerr := os.RemoveAll(userDir)
		if rmerr != nil {
			fmt.Println("ERROR:", rmerr.Error())
			os.Exit(1)
		}

		if verbose {
			fmt.Println("Removed profile directory:", userDir)
		}

		if err := RemoveSymlinks(links, args[0]); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}
	},
}

var Root = &cobra.Command{
	Use:   "dfm",
	Short: "Manage dotfiles.",
	Long: `Dotfile management written for pair programmers. Examples on getting
started with dfm are avialable at https://github.com/chasinglogic/dfm`,
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		config.Init()
	},
}

var RunHook = &cobra.Command{
	Use:   "run-hook",
	Short: "Run the hook specified by `HOOK`",
	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			fmt.Println("ERROR: Must specify at least one hook to run")
			os.Exit(128)
		}

		profile := config.CurrentProfile()
		yml := config.LoadDotDFM(profile)
		config.RunCommands(yml.Hooks[args[0]])
	},
}

var Sync = &cobra.Command{
	Use:   "sync",
	Short: "sync the current profile with the configured backend",
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		profile := config.CurrentProfile()
		if err := git.Sync(profile); err != nil {
			fmt.Println("ERROR:", err.Error())
			os.Exit(1)
		}

		yml := config.LoadDotDFM(profile)
		if !(yml.SyncModules || syncModules) {
			return
		}

		for _, module := range yml.Modules {
			location := module.Location()
			if module.PullOnly {
				err := git.Pull(location)
				if err != nil {
					fmt.Println("ERROR: Unable to update module:", err)
				}
			} else {
				err := git.Sync(location)
				if err != nil {
					fmt.Println("ERROR: Unable to sync module:", err)
				}
			}
		}
	},
}

var Where = &cobra.Command{
	Use:   "where",
	Short: "prints the first location for the current profile directory path",
	Run: func(cmd *cobra.Command, args []string) {
		profile := config.CurrentProfile()
		fmt.Println(profile)
	},
}