func rockGiphy(q string, c *hipchat.Client) {
	log.Printf("Searching for %q", q)
	url := fmt.Sprintf("http://api.giphy.com/v1/gifs/search?q=%s&api_key=dc6zaTOxFJmzC", url.QueryEscape(q))
	resp, err := http.Get(url)
	if err != nil {
		log.Println(err)
		return
	}
	defer resp.Body.Close()
	giphyResp := &struct{ Data []GiphyGif }{}
	dec := json.NewDecoder(resp.Body)
	if err := dec.Decode(giphyResp); err != nil {
		log.Println(err)
		return
	}
	msg := "NO RESULTS. I’M A MONSTER."
	if len(giphyResp.Data) > 0 {
		msg = fmt.Sprintf("%s: %s", q, giphyResp.Data[rand.Intn(len(giphyResp.Data))].Images.Original.URL)
	}

	req := hipchat.MessageRequest{
		RoomId:        *roomName,
		From:          "BUSTER",
		Message:       msg,
		Color:         hipchat.ColorRandom,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}
	if err := c.PostMessage(req); err != nil {
		log.Printf("Expected no error, but got %q", err)
	}
}

func hc(values url.Values) {
	var color, message string

	switch values.Get("Status") {
	case "Up":
		color = getColor(config.UpColor)
		message = formatMessage(values, config.MessageUp)
	case "Down":
		color = getColor(config.DownColor)
		message = formatMessage(values, config.MessageDown)
	}

	c := hipchat.Client{AuthToken: config.AuthToken}
	req := hipchat.MessageRequest{
		RoomId:        config.RoomId,
		From:          config.From,
		Message:       message,
		Color:         color,
		MessageFormat: hipchat.FormatText,
		Notify:        config.Notify,
	}

	if err := c.PostMessage(req); err != nil {
		fmt.Println("Expected no error, but got %q", err)
	}
}

// helper function to send Hipchat requests
func (h *Hipchat) send(color, format, message string) error {
	c := hipchat.Client{AuthToken: h.Token}
	req := hipchat.MessageRequest{
		RoomId:        h.Room,
		From:          "Drone",
		Message:       message,
		Color:         color,
		MessageFormat: format,
		Notify:        true,
	}

	return c.PostMessage(req)
}

func (h HipChatSender) SendMessage(room_id, message string) error {
	c := hipchat.Client{AuthToken: h.AuthToken}
	c.BaseURL = "https://api.hipchat.com/v1"
	req := hipchat.MessageRequest{
		RoomId:        room_id,
		From:          "Amazon SNS",
		Message:       message,
		Color:         hipchat.ColorYellow,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}

	return c.PostMessage(req)
}

func sendMessageToRoom(token, roomID, from, message string, color string) error {
	c := hipchat.Client{AuthToken: token}

	req := hipchat.MessageRequest{
		RoomId:        roomID,
		From:          from,
		Message:       message,
		Color:         color,
		MessageFormat: hipchat.FormatText,
		Notify:        false,
	}

	return c.PostMessage(req)
}

func main() {
	c := hipchat.Client{AuthToken: "<PUT YOUR AUTH TOKEN HERE>"}
	req := hipchat.MessageRequest{
		RoomId:        "Rat Man’s Den",
		From:          "GLaDOS",
		Message:       "Bad news: Combustible lemons failed.",
		Color:         hipchat.ColorPurple,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}
	if err := c.PostMessage(req); err != nil {
		log.Printf("Expected no error, but got %q", err)
	}
}

func notifyPullRequest(pr github.PullRequest, room string, token string) {
	message := fmt.Sprintf("PR is %d days old: %s", int(time.Since(*pr.CreatedAt).Hours()/24), *pr.HTMLURL)
	client := hipchat.Client{AuthToken: token}
	req := hipchat.MessageRequest{
		RoomId:        room,
		From:          "PR Checker",
		Message:       message,
		Color:         hipchat.ColorRed,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}
	fmt.Println("Sending HipChat notification:", message)
	if err := client.PostMessage(req); err != nil {
		fmt.Println("Failed to send HipChat notification:", err)
	}
}

// Post posts a hipchat message
// TODO: make hipchat api endpoint configurable for on-premises servers
func (hipChat *HipChat) Post(message string) bool {
	client := hipchat.Client{AuthToken: hipChat.Token}
	req := hipchat.MessageRequest{
		RoomId:        hipChat.RoomID,
		From:          hipChat.From,
		Message:       message,
		Color:         hipchat.ColorPurple,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}
	if err := client.PostMessage(req); err != nil {
		log.Errorf("Failed post message...: %s", message)
		return false
	}
	return true
}

func HepCat(msg string) (hep string, err error) {
	c := hipchat.Client{AuthToken: ""}
	req := hipchat.MessageRequest{
		RoomId:        "",
		From:          "",
		Message:       msg,
		Color:         hipchat.ColorPurple,
		MessageFormat: hipchat.FormatText,
		Notify:        true,
	}
	if err := c.PostMessage(req); err != nil {
		log.Printf("Expected no error, but got %q", err)

	}
	return "crap", err
}

func main() {
	flag.Parse()

	if len(*authToken) == 0 || len(*roomName) == 0 {
		log.Fatal("usage: buster -token=<hipchat token> -room=<room name>")
	}

	lastTime = time.Now()
	c := hipchat.Client{AuthToken: *authToken}

	roomId := ""
	l, err := c.RoomList()
	if err != nil {
		log.Fatalf("RoomList: expected no error, but got %q", err)
	}
	for _, room := range l {
		if strings.ToLower(room.Name) == strings.ToLower(*roomName) {
			roomId = strconv.Itoa(room.Id)
			break
		}
	}
	if len(roomId) == 0 {
		log.Fatalf("No room was found with the name %q", *roomName)
	}
	for {
		time.Sleep(5 * time.Second)
		hist, err := c.RoomHistory(roomId, "recent", "EST")
		if err != nil {
			log.Printf("RoomHistory: Expected no error, but got %q", err)
		}
		for _, m := range hist {
			t, err := m.Time()
			if err != nil {
				log.Println(err)
				continue
			}
			if t.After(lastTime) {
				msg := m.Message
				if strings.HasPrefix(strings.ToLower(msg), cmdPrefix) {
					rockGiphy(msg[len(cmdPrefix):], &c)
				}
				log.Printf("Updating lastTime to %v", t)
				lastTime = t
			}
		}
	}
}