// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The scaleway command creates ARM servers on Scaleway.com.
package main

import (
	"bytes"
	"crypto/hmac"
	"crypto/md5"
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

	"go4.org/types"
	revtype "golang.org/x/build/types"
)

var (
	token       = flag.String("token", "", "API token. If empty, the file is read from $HOME/keys/go-scaleway.token. Googlers on the Go team can get the value from http://go/golang-scaleway-token")
	org         = flag.String("org", "1f34701d-668b-441b-bf08-0b13544e99de", "Organization ID (default is bradfitz@golang.org's account)")
	image       = flag.String("image", "e488d5e3-d278-47a7-8f7d-1154e1f61dc9", "Disk image ID; default is the snapshot we made last")
	num         = flag.Int("n", 0, "Number of servers to create; if zero, defaults to a value as a function of --staging")
	tags        = flag.String("tags", "", "Comma-separated list of tags. The build key tags should be of the form 'buildkey_linux-arm_HEXHEXHEXHEXHEX'. If empty, it's automatic.")
	staging     = flag.Bool("staging", false, "If true, deploy staging instances (with staging names and tags) instead of prod.")
	listAll     = flag.Bool("list-all", false, "If true, list all (prod, staging, other) current Scaleway servers and stop without making changes.")
	list        = flag.Bool("list", false, "If true, list all prod (or staging, if -staging) servers, including missing ones.")
	fixInterval = flag.Duration("fix-interval", 10*time.Minute, "Interval to wait before running again (only applies to daemon mode)")
	daemonMode  = flag.Bool("daemon", false, "Run in daemon mode in a loop")
)

const (
	// ctype is the Commercial Type of server we use for the builders.
	ctype = "C1"

	scalewayAPIBase = "https://api.scaleway.com"
)

func main() {
	flag.Parse()
	if *tags == "" {
		if *staging {
			*tags = defaultBuilderTags("gobuilder-staging.key")
		} else {
			*tags = defaultBuilderTags("gobuilder-master.key")
		}
	}
	if *num == 0 {
		if *staging {
			*num = 5
		} else {
			*num = 50
		}
	}
	if *token == "" {
		file := filepath.Join(os.Getenv("HOME"), "keys/go-scaleway.token")
		slurp, err := ioutil.ReadFile(file)
		if err != nil {
			if os.IsNotExist(err) {
				log.Fatalf("No --token flag specified and token file %s does not exist. Googlers on the Go team can get it via http://go/golang-scaleway-token", file)
			}
			log.Fatalf("No --token specified and error reading backup token file: %v", err)
		}
		*token = strings.TrimSpace(string(slurp))
	}

	// Loop over checkServers() in daemon mode.
	for {
		checkServers()
		if !*daemonMode {
			return
		}
		time.Sleep(*fixInterval)
	}
}

func checkServers() {
	cl := &Client{Token: *token}
	serverList, err := cl.Servers()
	if err != nil {
		log.Fatal(err)
	}
	var names []string
	servers := map[string]*Server{}
	for _, s := range serverList {
		servers[s.Name] = s
		names = append(names, s.Name)
	}
	sort.Strings(names)
	if *listAll {
		for _, name := range names {
			s := servers[name]
			fmt.Printf("%s: %v, id=%v, state=%s, created=%v, modified=%v, image=%v\n",
				name, s.PublicIP, s.ID, s.State, s.CreationDate, s.ModificationDate, s.Image)
		}
		return
	}
	for i := 1; i <= *num; i++ {
		name := serverName(i)
		if _, ok := servers[name]; !ok {
			servers[name] = &Server{Name: name}
			names = append(names, name)
		}
	}
	sort.Strings(names)

	for name, revBuilder := range getConnectedMachines() {
		if _, ok := servers[name]; !ok {
			log.Printf("Machine connected to farmer.golang.org is unknown to scaleway: %v; ignoring", name)
			continue
		}
		servers[name].Connected = revBuilder
	}

	if *list {
		for _, name := range names {
			s := servers[name]
			status := "NOT_CONNECTED"
			if s.Connected != nil {
				status = "ok"
			}
			fmt.Printf("%s: %s, %v, id=%v, state=%s, created=%v, modified=%v, image=%v\n",
				name, status, s.PublicIP, s.ID, s.State, s.CreationDate, s.ModificationDate, s.Image)
		}
	}

	for i := 1; i <= *num; i++ {
		name := serverName(i)
		server := servers[name]
		if server.Connected != nil {
			continue
		}
		if server.State == "running" {
			if time.Time(server.ModificationDate).Before(time.Now().Add(15 * time.Minute)) {
				log.Printf("rebooting old running-but-disconnected %q server...", name)
				err := cl.serverAction(server.ID, "reboot")
				log.Printf("reboot(%q): %v", name, err)
				continue
			}
			// Started recently. Maybe still booting.
			continue
		}
		if server.State != "" {
			log.Printf("server %q in state %q; not creating", name, server.State)
			continue
		}
		tags := strings.Split(*tags, ",")
		if *staging {
			tags = append(tags, "staging")
		}
		body, err := json.Marshal(createServerRequest{
			Org:            *org,
			Name:           name,
			Image:          *image,
			CommercialType: ctype,
			Tags:           tags,
		})
		if err != nil {
			log.Fatal(err)
		}
		log.Printf("Doing req %q", body)
		req, err := http.NewRequest("POST", scalewayAPIBase+"/servers", bytes.NewReader(body))
		if err != nil {
			log.Fatal(err)
		}
		req.Header.Set("Content-Type", "application/json")
		req.Header.Set("X-Auth-Token", *token)
		res, err := http.DefaultClient.Do(req)
		if err != nil {
			log.Fatal(err)
		}
		log.Printf("Create of %v: %v", i, res.Status)
		res.Body.Close()
	}

	serverList, err = cl.Servers()
	if err != nil {
		log.Fatal(err)
	}
	for _, s := range serverList {
		if strings.HasSuffix(s.Name, "-prep") || strings.HasSuffix(s.Name, "-hand") {
			continue
		}
		if s.State == "stopped" {
			log.Printf("Powering on %s (%s) = %v", s.Name, s.ID, cl.PowerOn(s.ID))
		}
	}
}

type createServerRequest struct {
	Org            string   `json:"organization"`
	Name           string   `json:"name"`
	Image          string   `json:"image"`
	CommercialType string   `json:"commercial_type"`
	Tags           []string `json:"tags"`
}

type Client struct {
	Token string
}

// Delete deletes a server. It needs to be powered off in "stopped" state first.
//
// This is currently unused. An earlier version of this tool used it briefly before
// changing to use the reboot action. We might want this later.
func (c *Client) Delete(serverID string) error {
	req, _ := http.NewRequest("DELETE", scalewayAPIBase+"/servers/"+serverID, nil)
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Auth-Token", c.Token)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusNoContent {
		return fmt.Errorf("error deleting %s: %v", serverID, res.Status)
	}
	return nil
}

func (c *Client) PowerOn(serverID string) error {
	return c.serverAction(serverID, "poweron")
}

func (c *Client) serverAction(serverID, action string) error {
	req, _ := http.NewRequest("POST", scalewayAPIBase+"/servers/"+serverID+"/action", strings.NewReader(fmt.Sprintf(`{"action":"%s"}`, action)))
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-Auth-Token", c.Token)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	if res.StatusCode/100 != 2 {
		return fmt.Errorf("error doing %q on %s: %v", action, serverID, res.Status)
	}
	return nil
}

func (c *Client) Servers() ([]*Server, error) {
	req, _ := http.NewRequest("GET", scalewayAPIBase+"/servers", nil)
	req.Header.Set("X-Auth-Token", c.Token)
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("failed to get Server list: %v", res.Status)
	}
	var jres struct {
		Servers []*Server `json:"servers"`
	}
	err = json.NewDecoder(res.Body).Decode(&jres)
	return jres.Servers, err
}

type Server struct {
	ID               string         `json:"id"`
	Name             string         `json:"name"`
	PublicIP         *IP            `json:"public_ip"`
	PrivateIP        string         `json:"private_ip"`
	Tags             []string       `json:"tags"`
	State            string         `json:"state"`
	Image            *Image         `json:"image"`
	CreationDate     types.Time3339 `json:"creation_date"`
	ModificationDate types.Time3339 `json:"modification_date"`

	// Connected is non-nil if the server is connected to farmer.golang.org.
	// This does not come from the Scaleway API.
	Connected *revtype.ReverseBuilder `json:"-"`
}

type Image struct {
	ID   string `json:"id"`
	Name string `json:"name"`
}

func (im *Image) String() string {
	if im == nil {
		return "<no Image>"
	}
	return im.ID
}

type IP struct {
	ID      string `json:"id"`
	Address string `json:"address"`
}

func (ip *IP) String() string {
	if ip == nil {
		return "<no IP>"
	}
	return ip.Address
}

// defaultBuilderTags returns the default value of the "tags" flag.
// It returns a comma-separated list of builder tags (each of the form buildkey_$(BUILDER)_$(SECRETHEX)).
func defaultBuilderTags(baseKeyFile string) string {
	keyFile := filepath.Join(os.Getenv("HOME"), "keys", baseKeyFile)
	slurp, err := ioutil.ReadFile(keyFile)
	if err != nil {
		log.Fatal(err)
	}
	var tags []string
	for _, builder := range []string{"linux-arm", "linux-arm-arm5"} {
		h := hmac.New(md5.New, bytes.TrimSpace(slurp))
		h.Write([]byte(builder))
		tags = append(tags, fmt.Sprintf("buildkey_%s_%x", builder, h.Sum(nil)))
	}
	return strings.Join(tags, ",")
}

func serverName(i int) string {
	if *staging {
		return fmt.Sprintf("scaleway-staging-%02d", i)
	}
	return fmt.Sprintf("scaleway-prod-%02d", i)
}

func getConnectedMachines() map[string]*revtype.ReverseBuilder {
	const reverseURL = "https://farmer.golang.org/status/reverse.json"
	res, err := http.Get(reverseURL)
	if err != nil {
		log.Fatal(err)
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		log.Fatalf("getting %s: %s", reverseURL, res.Status)
	}
	var jres revtype.ReverseBuilderStatus
	if err := json.NewDecoder(res.Body).Decode(&jres); err != nil {
		log.Fatalf("reading %s: %v", reverseURL, err)
	}
	st := jres.HostTypes["host-linux-arm-scaleway"]
	if st == nil {
		return nil
	}
	return st.Machines
}