command

var (
	FirewallruleList = cli.Command{
		Name: "list",
		Help: "List firewallrule",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListFirewallRulesParameter{}
			resp, err := client.ListFirewallRules(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	Firewallrule = cli.Command{
		Name: "firewallrule",
		Help: "Manage firewallrule",
		Commands: []cli.Command{
			FirewallruleList,
		},
	}
)

var (
	IPList = cli.Command{
		Name: "list",
		Help: "List ipaddresses",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListPublicIpAddressesParameter{}
			resp, err := client.ListPublicIpAddresses(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	IP = cli.Command{
		Name: "ip",
		Help: "Manage ipaddresses",
		Commands: []cli.Command{
			IPList,
		},
	}
)

var (
	NetworkList = cli.Command{
		Name: "list",
		Help: "List network",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListNetworksParameter{}
			resp, err := client.ListNetworks(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	Network = cli.Command{
		Name: "network",
		Help: "Manage network",
		Commands: []cli.Command{
			NetworkList,
		},
	}
)

var (
	NicList = cli.Command{
		Name: "list",
		Help: "List nics",
		Args: []cli.Argument{
			cli.Argument{
				Name: "virtualmachineid",
				Help: "VM id",
				Type: cli.Strings,
			},
		},
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListNicsParameter{}

			vmids := lockgate.GetArgumentsFromStdin()
			vmids = append(vmids, c.Command.Arg("virtualmachineid").Strings()...)

			nics := []cloudstack.Nic{}
			for _, vmid := range vmids {
				params.SetVirtualmachineid(vmid)
				resp, err := client.ListNics(params)
				if err != nil {
					fmt.Println(err)
					log.Fatal(err)
				}
				nics = append(nics, resp...)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(nics)
		},
	}

	Nic = cli.Command{
		Name: "nic",
		Help: "Manage nics",
		Commands: []cli.Command{
			NicList,
		},
	}
)

var (
	PortforwardingruleList = cli.Command{
		Name: "list",
		Help: "List Portforwardingrule",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListPortForwardingRulesParameter{}
			resp, err := client.ListPortForwardingRules(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	Portforwardingrule = cli.Command{
		Name: "portforwardingrule",
		Help: "Manage portforwardingrule",
		Commands: []cli.Command{
			PortforwardingruleList,
		},
	}
)

var (
	ServiceOfferingList = cli.Command{
		Name: "list",
		Help: "List serviceofferings",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListServiceOfferingsParameter{}
			resp, err := client.ListServiceOfferings(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	ServiceOffering = cli.Command{
		Name: "serviceoffering",
		Help: "Manage serviceoffering",
		Commands: []cli.Command{
			ServiceOfferingList,
		},
	}
)

var (
	SshkeypairList = cli.Command{
		Name: "list",
		Help: "List ssh keypairs",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListSSHKeyPairsParameter{}
			resp, err := client.ListSSHKeyPairs(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	Sshkeypair = cli.Command{
		Name: "sshkeypair",
		Help: "Manage sshkeypair",
		Commands: []cli.Command{
			SshkeypairList,
		},
	}
)

var (
	TemplateList = cli.Command{
		Name: "list",
		Help: "List templates",
		Args: []cli.Argument{
			cli.Argument{
				Name: "ids",
				Help: "VM ids",
				Type: cli.Strings,
			},
		},
		Flags: []cli.Flag{
			cli.Flag{
				Name:    "templatefilter",
				Help:    "templatefilter",
				Default: "executable",
				Type:    cli.String,
			},
			cli.Flag{
				Name: "name",
				Help: "The name of the template",
				Type: cli.String,
			},
			cli.Flag{
				Name: "zone",
				Help: "The zoneid or zonename of the template",
				Type: cli.String,
			},
		},
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListTemplatesParameter{}

			ids := lockgate.GetArgumentsFromStdin()
			ids = append(ids, c.Command.Arg("ids").Strings()...)

			templatefilter := c.Command.Flag("templatefilter").String()
			if templatefilter != "" {
				params.SetTemplatefilter(templatefilter)
			}
			name := c.Command.Flag("name").String()
			if name != "" {
				params.SetName(name)
			}
			zone := c.Command.Flag("zone").String()
			if zone != "" {
				params.SetZoneid(zone)
			}

			var templates []cloudstack.Template
			if len(ids) > 0 {
				for _, id := range ids {
					params.SetId(id)
					resp, err := client.ListTemplates(params)
					if err != nil {
						fmt.Println(err)
						log.Fatal(err)
					}
					templates = append(templates, resp...)
				}
			} else {
				templates, err = client.ListTemplates(params)
				if err != nil {
					fmt.Println(err)
					log.Fatal(err)
				}
			}

			w := lockgate.GetTabWriter(c)
			w.Print(templates)
		},
	}

	Template = cli.Command{
		Name: "template",
		Help: "Manage template",
		Commands: []cli.Command{
			TemplateList,
		},
	}
)

var (
	VMList = cli.Command{
		Name: "list",
		Help: "List virtualmachines",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListVirtualMachinesParameter{}
			resp, err := client.ListVirtualMachines(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	VMStart = cli.Command{
		Name: "start",
		Help: "Start virtualmachine",
		Args: []cli.Argument{
			cli.Argument{
				Name: "ids",
				Help: "VM ids",
				Type: cli.Strings,
			},
		},
		Action: func(c *cli.Context) {
			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.StartVirtualMachineParameter{}

			ids := lockgate.GetArgumentsFromStdin()
			ids = append(ids, c.Command.Arg("ids").Strings()...)

			log.Println("ids:", ids)
			vms := []cloudstack.Virtualmachine{}
			for _, id := range ids {
				params.SetId(id)
				vm, err := client.StartVirtualMachine(params)
				if err != nil {
					fmt.Println(err)
					log.Fatal(err)
				}
				vms = append(vms, vm)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(vms)
		},
	}

	VMStop = cli.Command{
		Name: "stop",
		Help: "Stop virtualmachine",
		Args: []cli.Argument{
			cli.Argument{
				Name: "ids",
				Help: "VM ids",
				Type: cli.Strings,
			},
		},
		Action: func(c *cli.Context) {
			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.StopVirtualMachineParameter{}

			ids := lockgate.GetArgumentsFromStdin()
			ids = append(ids, c.Command.Arg("ids").Strings()...)

			log.Println("ids:", ids)
			vms := []cloudstack.Virtualmachine{}
			for _, id := range ids {
				params.SetId(id)
				vm, err := client.StopVirtualMachine(params)
				if err != nil {
					fmt.Println(err)
					log.Fatal(err)
				}
				vms = append(vms, vm)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(vms)
		},
	}

	VMDeploy = cli.Command{
		Name: "deploy",
		Help: "Deploy virtualmachine",
		Flags: []cli.Flag{
			cli.Flag{
				Name:     "zone",
				Short:    'z',
				Help:     "The zoneid or zonename of the virtualmachine",
				Type:     cli.String,
				Required: true,
			},
			cli.Flag{
				Name:     "serviceoffering",
				Short:    's',
				Help:     "The serviceofferingid or serviceofferingname of the virtualmachine",
				Type:     cli.String,
				Required: true,
			},
			cli.Flag{
				Name:     "template",
				Short:    't',
				Help:     "The templateid or templatename of the virtualmachine",
				Type:     cli.String,
				Required: true,
			},
			cli.Flag{
				Name: "name",
				Help: "The name of the virtualmachine",
				Type: cli.String,
			},
			cli.Flag{
				Name: "displayname",
				Help: "The displayname of the virtualmachine",
				Type: cli.String,
			},
			cli.Flag{
				Name: "keypair",
				Help: "The keypair of the virtualmachine",
				Type: cli.String,
			},
		},
		Action: func(c *cli.Context) {
			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.DeployVirtualMachineParameter{}

			zone := c.Command.Flag("zone").String()
			if zone != "" {
				params.SetZoneid(zone)
			}
			serviceoffering := c.Command.Flag("serviceoffering").String()
			if serviceoffering != "" {
				params.SetServiceofferingid(serviceoffering)
			}
			template := c.Command.Flag("template").String()
			if template != "" {
				params.SetTemplateid(template)
			}
			name := c.Command.Flag("name").String()
			if name != "" {
				params.SetName(name)
			}
			displayname := c.Command.Flag("displayname").String()
			if displayname != "" {
				params.SetDisplayname(displayname)
			}
			keypair := c.Command.Flag("keypair").String()
			if keypair != "" {
				params.SetKeypair(keypair)
			}

			vm, err := client.DeployVirtualMachine(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print([]cloudstack.Virtualmachine{vm})
		},
	}

	VMDestroy = cli.Command{
		Name: "destroy",
		Help: "Destroy virtualmachine",
		Args: []cli.Argument{
			cli.Argument{
				Name: "ids",
				Help: "VM ids",
				Type: cli.Strings,
			},
		},
		Action: func(c *cli.Context) {
			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.DestroyVirtualMachineParameter{}

			ids := lockgate.GetArgumentsFromStdin()
			ids = append(ids, c.Command.Arg("ids").Strings()...)

			log.Println("ids:", ids)
			vms := []cloudstack.Virtualmachine{}
			for _, id := range ids {
				params.SetId(id)
				vm, err := client.DestroyVirtualMachine(params)
				if err != nil {
					fmt.Println(err)
					log.Fatal(err)
				}
				vms = append(vms, vm)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(vms)
		},
	}

	VM = cli.Command{
		Name: "vm",
		Help: "Manage virtualmachine",
		Commands: []cli.Command{
			VMList,
			VMStart,
			VMStop,
			VMDeploy,
			VMDestroy,
		},
	}
)

var (
	ZoneList = cli.Command{
		Name: "list",
		Help: "List zones",
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			client, err := lockgate.GetClient(c)
			if err != nil {
				log.Fatal(err)
			}
			params := cloudstack.ListZonesParameter{}
			resp, err := client.ListZones(params)
			if err != nil {
				fmt.Println(err)
				log.Fatal(err)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(resp)
		},
	}

	Zone = cli.Command{
		Name: "zone",
		Help: "Manage zone",
		Commands: []cli.Command{
			ZoneList,
		},
	}
)

var (
	API = cli.Command{
		Name: "api",
		Help: "Execute CloudStack API",
		Args: []cli.Argument{
			cli.Argument{
				Name:     "command",
				Help:     "CloudStack API command",
				Required: true,
				Type:     cli.String,
			},
			cli.Argument{
				Name: "params",
				Help: "API parameters. key1=val1 key2=val2 ...",
				Type: cli.StringMap,
			},
		},
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			command := c.Command.Arg("command").String()
			params := c.Command.Arg("params").StringMap()

			client, err := lockgate.GetClient(c)
			if err != nil {
				fmt.Fprintln(os.Stderr, err)
				log.Fatal(err)
			}

			result, err := client.Request(command, params)
			if err != nil {
				fmt.Fprintln(os.Stderr, err)
				log.Fatal(err)
			}

			items := []interface{}{}
			var key string
			var value json.RawMessage

			temp := map[string]json.RawMessage{}
			err = json.Unmarshal(result, &temp)
			if err != nil {
				fmt.Fprintln(os.Stderr, err)
				log.Fatal(err)
			}
			for key, value = range temp {
				if key != "count" {
					break
				}
			}

			if key == "success" {
				if string(value) == "true" {
					items = append(items, map[string]bool{"success": true})
				} else {
					items = append(items, map[string]bool{"success": false})
				}
			} else if strings.HasPrefix(command, "list") {
				err = json.Unmarshal(value, &items)
				if err != nil {
					fmt.Fprintln(os.Stderr, err)
					log.Fatal(err)
				}
			} else {
				var item interface{}
				err := json.Unmarshal(value, &item)
				if err != nil {
					if err != nil {
						fmt.Fprintln(os.Stderr, err)
						log.Fatal(err)
					}
				}
				items = append(items, item)
			}

			w := lockgate.GetTabWriter(c)
			w.Print(items)
		},
	}
)

var (
	Init = cli.Command{
		Name: "init",
		Help: "Create profile configuration file",
		Args: []cli.Argument{
			cli.Argument{
				Name: "profile",
				Help: "Profile name",
				Type: cli.String,
			},
		},
		Action: func(c *cli.Context) {

			lockgate.SetLogLevel(c)

			newProfile := "default"
			if c.Command.Arg("profile") != nil {
				newProfile = c.Command.Arg("profile").String()
			}

			if _, err := os.Stat(lockgate.ConfigDir); os.IsNotExist(err) {
				msg := fmt.Sprintf("Createing %s ...", lockgate.ConfigDir)
				fmt.Fprintln(os.Stderr, msg)
				log.Println(msg)
				err := os.Mkdir(lockgate.ConfigDir, 0755)
				if err != nil {
					msg := "Failed to create " + lockgate.ConfigDir
					fmt.Fprintln(os.Stderr, msg)
					fmt.Fprintln(os.Stderr, err)
					log.Println(msg)
					log.Fatal(err)
				}
			}

			configDirPath := path.Join(lockgate.ConfigDir, newProfile)
			configFilePath := path.Join(configDirPath, lockgate.ConfigFile)

			if _, err := os.Stat(configDirPath); os.IsNotExist(err) {
				msg := fmt.Sprintf("Createing %s ...", configDirPath)
				fmt.Fprintln(os.Stderr, msg)
				log.Println(msg)
				err := os.Mkdir(configDirPath, 0755)
				if err != nil {
					msg := "Failed to create " + configDirPath
					fmt.Fprintln(os.Stderr, msg)
					fmt.Fprintln(os.Stderr, err)
					log.Println(msg)
					log.Fatal(err)
				}
			}

			if _, err := os.Stat(configFilePath); os.IsNotExist(err) {
				msg := fmt.Sprintf("Writing %s ...", configFilePath)
				fmt.Fprintln(os.Stderr, msg)
				log.Println(msg)

				b, err := yaml.Marshal(lockgate.DefaultConfig)
				if err != nil {
					msg := "Failed to marshal default config"
					fmt.Fprintln(os.Stderr, msg)
					fmt.Fprintln(os.Stderr, err)
					log.Println(msg)
					log.Fatal(err)
				}

				err = ioutil.WriteFile(configFilePath, b, 0644)
				if err != nil {
					msg := "Failed to write config: " + configFilePath
					fmt.Fprintln(os.Stderr, msg)
					fmt.Fprintln(os.Stderr, err)
					log.Println(msg)
					log.Fatal(err)
				}
			} else {
				msg := fmt.Sprintf("profile %s already exists.", newProfile)
				fmt.Fprintln(os.Stderr, msg)
				log.Println(msg)
			}
		},
	}
)