cmd

var (
	UpdateCheckFlag   bool
	UpdateVersionFlag string

	UpdateStarted   bool
	UpdateErrored   bool
	UpdateChecked   bool
	UpdateAvailable *ProgramVersion
	UpdateData      []interface{}
)

var BashCompletionCmd = &cobra.Command{
	Use:   "bash",
	Short: "Generate Bash completions",
	Long:  BashCompletionLong,
	Run: func(cmd *cobra.Command, args []string) {
		RootCmd.GenBashCompletion(os.Stdout)
	},
}

var BashCompletionLong = `` /* 222-byte string literal not displayed */

var CompletionCmd = &cobra.Command{
	Use:     "completion",
	Aliases: []string{"completions"},
	Short:   "Generate completion helpers for popular terminals",
	Long:    "Generate completion helpers for popular terminals",
}

var (
	CompletionVanillaFlag bool
)

var CountCmd = &cobra.Command{

	Use: "count [files...]",

	Short: "count nodes in file(s)",

	Long: countLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		var globs []string

		if 0 < len(args) {

			globs = args[0:]

		}

		err = CountRun(globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var DepthCmd = &cobra.Command{

	Use: "depth [files...]",

	Short: "calculate the depth of file(s)",

	Long: depthLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		var globs []string

		if 0 < len(args) {

			globs = args[0:]

		}

		err = DepthRun(globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var DiffCmd = &cobra.Command{

	Use: "diff <orig> <next>",

	Aliases: []string{
		"D",
	},

	Short: "calculate the diff from orig to next file(s)",

	Long: diffLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'orig'")
			cmd.Usage()
			os.Exit(1)
		}

		var orig string

		if 0 < len(args) {

			orig = args[0]

		}

		if 1 >= len(args) {
			fmt.Println("missing required argument: 'next'")
			cmd.Usage()
			os.Exit(1)
		}

		var next string

		if 1 < len(args) {

			next = args[1]

		}

		err = DiffRun(orig, next)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var FishCompletionCmd = &cobra.Command{
	Use:   "fish",
	Short: "Generate Fish completions",
	Long:  "Generate Fish completions",

	Run: func(cmd *cobra.Command, args []string) {
		RootCmd.GenFishCompletion(os.Stdout, true)
	},
}

var FlowCmd = &cobra.Command{

	Use: "flow [cue files...]",

	Aliases: []string{
		"f",
	},

	Short: "run file(s) through the hof/flow DAG engine",

	Long: flowLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		var globs []string

		if 0 < len(args) {

			globs = args[0:]

		}

		err = FlowRun(globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var InsertCmd = &cobra.Command{

	Use: "insert <code> [files...]",

	Aliases: []string{
		"i",
	},

	Short: "insert into file(s) with code (only if not present)",

	Long: insertLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = InsertRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var MaskCmd = &cobra.Command{

	Use: "mask <code> [files...]",

	Aliases: []string{
		"m",
	},

	Short: "mask from file(s) with code",

	Long: maskLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = MaskRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var PatchCmd = &cobra.Command{

	Use: "patch <patch> <orig>",

	Aliases: []string{
		"P",
	},

	Short: "apply pacth to orig file(s)",

	Long: patchLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'patch'")
			cmd.Usage()
			os.Exit(1)
		}

		var patch string

		if 0 < len(args) {

			patch = args[0]

		}

		if 1 >= len(args) {
			fmt.Println("missing required argument: 'orig'")
			cmd.Usage()
			os.Exit(1)
		}

		var orig string

		if 1 < len(args) {

			orig = args[1]

		}

		err = PatchRun(patch, orig)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var PickCmd = &cobra.Command{

	Use: "pick <code> [files...]",

	Aliases: []string{
		"p",
	},

	Short: "pick from file(s) with code",

	Long: pickLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = PickRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var PowerShellCompletionCmd = &cobra.Command{
	Use:     "power-shell",
	Aliases: []string{"windows", "win", "power", "ps"},
	Short:   "Generate PowerShell completions",
	Long:    "Generate PowerShell completions",

	Run: func(cmd *cobra.Command, args []string) {
		RootCmd.GenPowerShellCompletion(os.Stdout)
	},
}

var ReplaceCmd = &cobra.Command{

	Use: "replace <code> [files...]",

	Aliases: []string{
		"r",
	},

	Short: "replace in file(s) with code (only if present)",

	Long: replaceLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = ReplaceRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var RootCmd = &cobra.Command{

	Use: "cuetils",

	Short: "CUE Utilites for bulk ETL, diff, query, and other operations on data and config",

	Long: cuetilsLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	PersistentPostRun: func(cmd *cobra.Command, args []string) {
		var err error

		err = RootPersistentPostRun(args)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var TransformCmd = &cobra.Command{

	Use: "transform <code> [files...]",

	Aliases: []string{
		"t",
	},

	Short: "transform file(s) with code",

	Long: transformLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = TransformRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var UpdateCmd = &cobra.Command{

	Use: "update",

	Short: "update the cuetils tool",

	Long: UpdateLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {

		latest, err := CheckUpdate(true)
		if err != nil {
			fmt.Println(err)
			os.Exit(-1)
		}

		cur := ProgramVersion{Version: "v" + verinfo.Version}
		if latest.Version == cur.Version || (UpdateVersionFlag == "" && cur.Version == "vLocal") {
			return
		} else {
			if UpdateCheckFlag {
				PrintUpdateAvailable()
				return
			}
		}

		err = InstallUpdate()
		if err != nil {
			fmt.Println(err)
			os.Exit(-1)
		}
	},
}

var UpdateLong = `Print the build version for cuetils`

var UpsertCmd = &cobra.Command{

	Use: "upsert <code> [files...]",

	Aliases: []string{
		"u",
	},

	Short: "upsert file(s) with code (extend and replace)",

	Long: upsertLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'code'")
			cmd.Usage()
			os.Exit(1)
		}

		var code string

		if 0 < len(args) {

			code = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = UpsertRun(code, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var ValidateCmd = &cobra.Command{

	Use: "validate <schema> [files...]",

	Aliases: []string{
		"v",
	},

	Short: "validate file(s) with schema",

	Long: validateLong,

	PreRun: func(cmd *cobra.Command, args []string) {

	},

	Run: func(cmd *cobra.Command, args []string) {
		var err error

		if 0 >= len(args) {
			fmt.Println("missing required argument: 'schema'")
			cmd.Usage()
			os.Exit(1)
		}

		var schema string

		if 0 < len(args) {

			schema = args[0]

		}

		var globs []string

		if 1 < len(args) {

			globs = args[1:]

		}

		err = ValidateRun(schema, globs)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
	},
}

var VersionCmd = &cobra.Command{

	Use: "version",

	Aliases: []string{
		"ver",
	},

	Short: "print the version",

	Long: VersionLong,

	Run: func(cmd *cobra.Command, args []string) {

		s, e := os.UserConfigDir()
		fmt.Printf("cuetils ConfigDir %q %v\n", filepath.Join(s, "cuetils"), e)

		fmt.Printf(
			versionMessage,
			verinfo.Version,
			verinfo.Commit,
			verinfo.BuildDate,
			verinfo.GoVersion,
			verinfo.BuildOS,
			verinfo.BuildArch,
		)
	},
}

var VersionLong = `Print the build version for cuetils`

var ZshCompletionCmd = &cobra.Command{
	Use:   "zsh",
	Short: "Generate Zsh completions",
	Long:  "Generate Zsh completions",
	Run: func(cmd *cobra.Command, args []string) {
		RootCmd.GenZshCompletion(os.Stdout)
	},
}