// NewApp creates a new cli app
func NewApp(eh *ErrorHandler) *cli.App {
	app := cli.NewApp()
	app.Version = VERSION
	app.Name = "cfops"
	app.Usage = "Cloud Foundry Operations Tool"
	app.Commands = []cli.Command{
		cli.Command{
			Name:  "version",
			Usage: "shows the application version currently in use",
			Action: func(c *cli.Context) {
				cli.ShowVersion(c)
			},
		},
		cli.Command{
			Name:  "list-tiles",
			Usage: "shows a list of available backup/restore target tiles",
			Action: func(c *cli.Context) {
				fmt.Println("Available Tiles:")
				for n, _ := range tileregistry.GetRegistry() {
					fmt.Println(n)
				}
			},
		},
		CreateBURACliCommand("backup", "creates a backup archive of the target tile", eh),
		CreateBURACliCommand("restore", "restores from an archive to the target tile", eh),
	}
	return app
}

// NewApp creates a new cli app
func NewApp() *cli.App {
	app := cli.NewApp()
	app.Version = VERSION
	app.Name = "cfops"
	app.Usage = "Cloud Foundry Operations Tool"
	app.Flags = append(app.Flags,
		cli.StringFlag{
			Name:   "logLevel",
			Value:  "info",
			Usage:  "set the log level by setting the LOG_LEVEL environment variable",
			EnvVar: "LOG_LEVEL",
		},
	)
	app.Commands = append(app.Commands, []cli.Command{
		cli.Command{
			Name: "version",
			Action: func(c *cli.Context) {
				cli.ShowVersion(c)
			},
		},
		backupCli,
		restoreCli,
	}...)
	return app
}

func Main(args []string, journal, output io.Writer) {
	App := cli.NewApp()

	App.Name = "repeatr"
	App.Usage = "Run it. Run it again."
	App.Version = "0.0.1"

	App.Writer = journal

	App.Commands = []cli.Command{
		RunCommandPattern(output),
		ScanCommandPattern(output),
		TwerkCommandPattern(os.Stdin, output, output), // FIXME this is too much loss of precision already
	}

	// Reporting "no help topic for 'zyx'" and exiting with a *zero* is... silly.
	// A failure to hit a command should be an error.  Like, if a bash script does `repeatr somethingimportant`, there's no way it shouldn't *stop* when that's not there.
	App.CommandNotFound = func(ctx *cli.Context, command string) {
		fmt.Fprintf(ctx.App.Writer, "'%s %v' is not a repeatr subcommand\n", ctx.App.Name, command)
		os.Exit(int(EXIT_BADARGS))
	}

	// Put some more info in our version printer.
	// Global var.  Womp womp.
	// Also, version goes to stdout.
	cli.VersionPrinter = func(ctx *cli.Context) {
		fmt.Fprintf(os.Stdout, "%v v%v\n", ctx.App.Name, ctx.App.Version)
		fmt.Fprintf(os.Stdout, "git commit %v\n", GITCOMMIT)
		fmt.Fprintf(os.Stdout, "build date %v\n", BUILDDATE)
	}

	// Invoking version as a subcommand should also fly.
	App.Commands = append(App.Commands,
		cli.Command{
			Name:  "version",
			Usage: "Shows the version of repeatr",
			Action: func(ctx *cli.Context) {
				cli.ShowVersion(ctx)
			},
		},
	)

	App.Run(args)
}

func TestAppVersionPrinter(t *testing.T) {
	oldPrinter := cli.VersionPrinter
	defer func() {
		cli.VersionPrinter = oldPrinter
	}()

	var wasCalled = false
	cli.VersionPrinter = func(c *cli.Context) {
		wasCalled = true
	}

	app := cli.NewApp()
	ctx := cli.NewContext(app, nil, nil)
	cli.ShowVersion(ctx)

	if wasCalled == false {
		t.Errorf("Version printer expected to be called, but was not")
	}
}

/*NewApp - Creates a new CLI App instance*/
func NewApp() *cli.App {
	app := cli.NewApp()
	app.Version = VERSION
	app.Name = "cfdatamanager"
	app.Usage = "Cloud Foundry Data Tile Tool"
	app.Flags = append(app.Flags,
		cli.StringFlag{
			Name:  "logLevel",
			Value: "info",
			Usage: "log level: debug, info, error, fatal",
		},
	)
	app.Commands = append(app.Commands, []cli.Command{
		cli.Command{
			Name: "version",
			Action: func(c *cli.Context) {
				cli.ShowVersion(c)
			},
		},
		backupCli,
	}...)
	return app
}

func (c *contextCommandLine) ShowVersion() {
	cli.ShowVersion(c.Context)
}

	timeout     = 10 * time.Second

	commands = []cli.Command{
		// health check
		{
			Name:        "proxyHealthCheck",
			ShortName:   "phc",
			Usage:       "upproxy health check",
			Description: "upproxy health check with get_topology",
			Flags:       flags,
			Action: func(c *cli.Context) {
				if c.IsSet("default-file") {
					defaultFile = c.String("default-file")
				}
				if c.Bool("version") {
					cli.ShowVersion(c)
					return
				}

				f, err := os.Open(defaultFile)
				if err == nil {
					r := bufio.NewReader(f)
					for {
						b, _, err := r.ReadLine()
						if err != nil {
							if err == io.EOF {
								break
							}
							panic(err)
						}

func main() {
	app := cli.NewApp()
	app.Name = "httpcap"
	app.Usage = "A simple network analyzer that capture http network traffic."
	app.Version = "0.1.0"
	app.Flags = []cli.Flag{
		cli.StringFlag{
			Name:  "interface, i",
			Value: "",
			Usage: "interface to listen on (e.g. eth0, en1, or 192.168.1.1, 127.0.0.1 etc.)",
		},
		cli.StringFlag{
			Name:  "port, p",
			Value: "",
			Usage: "port to listen on (default listen on all port)",
		},
		cli.BoolFlag{
			Name:  "raw, r",
			Usage: "show raw stream. it is a shortcut for -l %request%response",
		},
		cli.StringFlag{
			Name:  "format, f",
			Value: "",
			Usage: "output format. You can specify the output string format containing reserved keyword that will be replaced with the proper value",
		},
		cli.StringFlag{
			Name:  "keyword, k",
			Value: "",
			Usage: "filte output with the keyword in request url",
		},
		cli.IntFlag{
			Name:  "body, b",
			Value: 0,
			Usage: "the length to truncate response body (0 - not show body, -1 - show all body)",
		},
		cli.StringFlag{
			Name:  "service, s",
			Value: "http",
			Usage: "limit output service (http|memcache|redis|mongodb|twemproxy|mysql)",
		},
		cli.BoolFlag{
			Name:  "verbose, vv",
			Usage: "output debug message",
		},
	}
	app.Commands = []cli.Command{
		{
			Name:  "list",
			Usage: "show all interfaces",
			Action: func(c *cli.Context) {
				common.ShowAllInterfaces()
			},
		}}
	app.Action = func(c *cli.Context) {
		config.Setting.Verbose = c.Bool("verbose")
		config.Setting.InterfaceName = c.String("interface")
		config.Setting.Port = c.String("port")
		config.Setting.Format = c.String("format")
		config.Setting.Filter = c.String("keyword")
		config.Setting.TruncateBodyLength = c.Int("body")
		config.Setting.Raw = c.Bool("raw")
		config.Setting.Service = c.String("service")

		if c.Bool("version") {
			cli.ShowVersion(c)
			return
		}

		if c.Bool("help") {
			cli.ShowAppHelp(c)
			return
		}

		startCapture()
	}

	app.Run(os.Args)
}

func main() {
	var app = cli.NewApp()
	app.Name = "cf"
	app.Version = "0.1.0"
	app.Usage = "Codeforces client"
	app.Action = func(c *cli.Context) {
		if c.Bool("version") {
			cli.ShowVersion(c)
			return
		}
		cli.ShowAppHelp(c)
	}
	app.Before = func(c *cli.Context) error {
		if c.GlobalBool("verbose") {
			log.SetLevel(log.InfoLevel)
		}
		return nil
	}
	app.Commands = []cli.Command{
		{
			Name:      "get",
			Usage:     "Retrieves test cases for a single codeforces problem",
			ArgsUsage: "<ProblemURL>",
			Action:    get,
		},
		{
			Name:      "setup",
			Usage:     "Setup environment for contest or single problem",
			ArgsUsage: "<ContestID | ProblemURL>",
			Action:    setup,
			Flags: []cli.Flag{
				cli.StringFlag{
					Name:  "lang",
					Usage: "programming language for sample solutions",
				},
			},
		},
		{
			Name:      "gen",
			Usage:     "Generates sample solution",
			ArgsUsage: "<source_file.ext>",
			Action:    gen,
		},
		{
			Name:   "test",
			Usage:  "Runs solution against test cases",
			Action: test,
		},
		{
			Name:      "config",
			Usage:     "Set or show settings",
			ArgsUsage: "[<key> <value>]",
			Action:    config,
			Flags: []cli.Flag{
				cli.BoolFlag{
					Name:  "list",
					Usage: "Display current settings",
				},
				cli.BoolFlag{
					Name:  "global",
					Usage: "Settings for ~/.cf.yml file",
				},
			},
		},
	}
	app.HideVersion = true
	app.Flags = []cli.Flag{
		cli.BoolFlag{
			Name:  "verbose, v",
			Usage: "Display detailed information of the operations",
		},
		cli.BoolFlag{
			Name:  "version, V",
			Usage: "print the version",
		},
	}

	app.Run(os.Args)
}