cmd

var CheckCmd = &cobra.Command{
	Use:     "check <path>...",
	Example: `pixlet check examples/clock`,
	Short:   "Check if an app is ready to publish",
	Long: `Check if an app is ready to publish.

The path argument should be the path to the Pixlet app to check. The
app can be a single file with the .star extension, or a directory
containing multiple Starlark files and resources.

The check command runs a series of checks to ensure your app is ready
to publish in the community repo. Every failed check will have a solution
provided. If your app fails a check, try the provided solution and reach out on
Discord if you get stuck.`,
	Args: cobra.MinimumNArgs(1),
	RunE: checkCmd,
}

var CreateCmd = &cobra.Command{
	Use:   "create",
	Short: "Creates a new app",
	Long:  `This command will prompt for all of the information we need to generate a new Tidbyt app.`,
	RunE: func(cmd *cobra.Command, args []string) error {

		cwd, err := os.Getwd()
		if err != nil {
			return fmt.Errorf("app creation failed, something went wrong with your local filesystem: %w", err)
		}

		// Determine what type of app this is an what the root should be.
		var root string
		var appType generator.AppType
		if repo.IsInRepo(cwd, "community") {
			appType = generator.Community
			root, err = repo.RepoRoot(cwd)
			if err != nil {
				return fmt.Errorf("app creation failed, something went wrong with your community repo: %w", err)
			}
		} else if repo.IsInRepo(cwd, "tidbyt") {
			appType = generator.Internal
			root, err = repo.RepoRoot(cwd)
			if err != nil {
				return fmt.Errorf("app creation failed, something went wrong with your tidbyt repo: %w", err)
			}
		} else {
			appType = generator.Local
			root = cwd
		}

		app, err := community.ManifestPrompt()
		if err != nil {
			return fmt.Errorf("app creation, couldn't get user input: %w", err)
		}

		g, err := generator.NewGenerator(appType, root)
		if err != nil {
			return fmt.Errorf("app creation failed %w", err)
		}
		absolutePath, err := g.GenerateApp(app)
		if err != nil {
			return fmt.Errorf("app creation failed: %w", err)
		}

		relativePath, err := filepath.Rel(cwd, absolutePath)
		if err != nil {
			return fmt.Errorf("app was created, but we don't know where: %w", err)
		}

		fmt.Println("")
		fmt.Println("App created at:")
		fmt.Printf("\t%s\n", absolutePath)
		fmt.Println("")
		fmt.Println("To start the app, run:")
		fmt.Printf("\tpixlet serve %s\n", relativePath)
		fmt.Println("")
		fmt.Println("For docs, head to:")
		fmt.Printf("\thttps://tidbyt.dev\n")
		return nil
	},
}

var DeleteCmd = &cobra.Command{
	Use:   "delete [device ID] [installation ID]",
	Short: "Delete a pixlet script from a Tidbyt",
	Args:  cobra.MinimumNArgs(2),
	RunE:  delete,
}

var DevicesCmd = &cobra.Command{
	Use:   "devices",
	Short: "List devices in your Tidbyt account",
	Run:   devices,
}

var EncryptCmd = &cobra.Command{
	Use:     "encrypt [app ID] [secret value]...",
	Short:   "Encrypt a secret for use in the Tidbyt community repo",
	Example: "encrypt weather my-top-secretweather-api-key-123456",
	Args:    cobra.MinimumNArgs(2),
	Run:     encrypt,
}

var FormatCmd = &cobra.Command{
	Use:   "format <pathspec>...",
	Short: "Formats Tidbyt apps",
	Example: `  pixlet format app.star
  pixlet format app.star --dry-run
  pixlet format --recursive ./`,
	Long: `The format command provides a code formatter for Tidbyt apps. By default, it
will format your starlark source code in line. If you wish you see the output
before applying, add the --dry-run flag.`,
	Args: cobra.MinimumNArgs(1),
	RunE: formatCmd,
}

var LintCmd = &cobra.Command{
	Use: "lint <pathspec>...",
	Example: `  pixlet lint app.star
  pixlet lint --recursive --fix ./`,
	Short: "Lints Tidbyt apps",
	Long: `The lint command provides a linter for Tidbyt apps. It's capable of linting a
file, a list of files, or directory with the recursive option. Additionally, it
provides an option to automatically fix resolvable linter issues.`,
	Args: cobra.MinimumNArgs(1),
	RunE: lintCmd,
}

var ListCmd = &cobra.Command{
	Use:   "list [device ID]",
	Short: "Lists all apps installed on a Tidbyt",
	Args:  cobra.MinimumNArgs(1),
	RunE:  listInstallations,
}

var LoginCmd = &cobra.Command{
	Use:     "login",
	Short:   "Login to your Tidbyt account",
	Example: "login",
	Run:     login,
}

var ProfileCmd = &cobra.Command{
	Use:   "profile <path> [<key>=value>]...",
	Short: "Run a Pixlet app and print its execution-time profile",
	Args:  cobra.MinimumNArgs(1),
	RunE:  profile,
}

var PushCmd = &cobra.Command{
	Use:   "push [device ID] [webp image]",
	Short: "Render a Pixlet script and push the WebP output to a Tidbyt",
	Args:  cobra.MinimumNArgs(2),
	RunE:  push,
}

var RenderCmd = &cobra.Command{
	Use:   "render [path] [<key>=value>]...",
	Short: "Run a Pixlet app with provided config parameters",
	Args:  cobra.MinimumNArgs(1),
	RunE:  render,
	Long: `Render a Pixlet app with provided config parameters.

The path argument should be the path to the Pixlet app to run. The
app can be a single file with the .star extension, or a directory
containing multiple Starlark files and resources.
	`,
}

var ServeCmd = &cobra.Command{
	Use:   "serve [path]",
	Short: "Serve a Pixlet app in a web server",
	Args:  cobra.ExactArgs(1),
	RunE:  serve,
	Long: `Serve a Pixlet app in a web server.

The path argument should be the path to the Pixlet program to run. The
program can be a single file with the .star extension, or a directory
containing multiple Starlark files and resources.`,
}

var SetAuthCmd = &cobra.Command{
	Use:     "set-auth",
	Short:   "Sets a custom access token in the private pixlet config.",
	Example: `  pixlet set-auth <token_json>`,
	Long: `This command sets a custom access token for use in subsequent runs. Normal users
should not need this - use 'pixlet login' instead.`,
	Args: cobra.ExactArgs(1),
	RunE: SetAuth,
}

var Version string

var VersionCmd = &cobra.Command{
	Use:   "version",
	Short: "Show the version of Pixlet",
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Printf("Pixlet version: %s\n", Version)
	},
}