func SendAlerts(ctx context.Context, stocksForAlert []PortfolioStock) {
	if len(stocksForAlert) == 0 {
		log.Debugf(ctx, "SendAlerts: Alert stocks are empty")
		return
	}
	//group by user emails to send a consolidated email
	groupedStockAlerts := make(map[string][]PortfolioStock)
	for _, alert := range stocksForAlert {
		userPortfolioStocks := groupedStockAlerts[alert.Email]
		userPortfolioStocks = append(userPortfolioStocks, alert)
		groupedStockAlerts[alert.Email] = userPortfolioStocks
	}
	log.Debugf(ctx, "Will send alerts for ", Jsonify(groupedStockAlerts))
	for email, alerts := range groupedStockAlerts {
		msg := &mail.Message{
			Sender:  "NewTechFellas Stock Alerts <[email protected]>",
			To:      []string{email},
			Subject: "Newtechfellas stock alerts for your stocks - " + DateString(),
			Body:    getStocksAlertMailBody(alerts),
		}
		if err := mail.Send(ctx, msg); err != nil {
			log.Debugf(ctx, "Couldn't send email: %v", err)
		}
	}

	for _, portfolioStock := range stocksForAlert {
		portfolioStock.AlertSentTime = time.Now()
		//Save stocksForAlert to update last alert sent time
		CreateOrUpdate(ctx, &portfolioStock, portfolioStock.kind(), portfolioStock.stringId(), 0)
	}
}

func emailMentions(ctx context.Context, tweet *Tweet) {
	u := user.Current(ctx)
	var words []string
	words = strings.Fields(tweet.Message)
	for _, value := range words {
		if strings.HasPrefix(value, "@") {
			username := value[1:]
			profile, err := getProfileByUsername(ctx, username)
			if err != nil {
				// they don't have a profile, so skip it
				continue
			}
			msg := &mail.Message{
				Sender:  u.Email,
				To:      []string{profile.Username + " <" + profile.Email + ">"},
				Subject: "You were mentioned in a tweet",
				Body:    tweet.Message + " from " + tweet.Username + " - " + humanize.Time(tweet.Time),
			}
			if err := mail.Send(ctx, msg); err != nil {
				log.Errorf(ctx, "Alas, my user, the email failed to sendeth: %v", err)
				continue
			}

		}
	}
}

func emailSend(w http.ResponseWriter, r *http.Request, m map[string]string) {

	c := appengine.NewContext(r)
	//addr := r.FormValue("email")

	if _, ok := m["subject"]; !ok {
		m["subject"] = "empty subject line"
	}

	email_thread_id := []string{"3223"}

	msg := &ae_mail.Message{
		//Sender:  "Peter Buchmann <[email protected]",
		//		Sender: "[email protected]",
		Sender: "[email protected]",
		//To:	   []string{addr},
		To: []string{"[email protected]"},

		Subject: m["subject"],
		Body:    "some_body some_body2",
		Headers: go_mail.Header{"References": email_thread_id},
	}
	err := ae_mail.Send(c, msg)
	loghttp.E(w, r, err, false, "could not send the email")

}

func handleOOBAction(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	resp, err := gitkitClient.GenerateOOBCode(c, r)
	if err != nil {
		aelog.Errorf(c, "Failed to get an OOB code: %s", err)
		w.Write([]byte(gitkit.ErrorResponse(err)))
		return
	}
	msg := &mail.Message{
		Sender: "FavWeekday Support <[email protected]>",
	}
	switch resp.Action {
	case gitkit.OOBActionResetPassword:
		msg.Subject = "Reset your FavWeekday account password"
		msg.HTMLBody = fmt.Sprintf(emailTemplateResetPassword, resp.Email, resp.OOBCodeURL.String())
		msg.To = []string{resp.Email}
	case gitkit.OOBActionChangeEmail:
		msg.Subject = "FavWeekday account email address change confirmation"
		msg.HTMLBody = fmt.Sprintf(emailTemplateChangeEmail, resp.Email, resp.NewEmail, resp.OOBCodeURL.String())
		msg.To = []string{resp.NewEmail}
	case gitkit.OOBActionVerifyEmail:
		msg.Subject = "FavWeekday account registration confirmation"
		msg.HTMLBody = fmt.Sprintf(emailTemplateVerifyEmail, resp.OOBCodeURL.String())
		msg.To = []string{resp.Email}
	}
	if err := mail.Send(c, msg); err != nil {
		aelog.Errorf(c, "Failed to send %s message to user %s: %s", resp.Action, resp.Email, err)
		w.Write([]byte(gitkit.ErrorResponse(err)))
		return
	}
	w.Write([]byte(gitkit.SuccessResponse()))
}

func SendEmailToAllUsers(r *http.Request, subject string) int {
	ctx := req2ctx(r)
	cdb := complaintdb.NewDB(ctx)

	if cps, err := cdb.GetAllProfiles(); err != nil {
		cdb.Errorf("SendEmailToAllUsers/GetAllProfiles: %v", err)
		return 0

	} else {
		buf := new(bytes.Buffer)
		params := map[string]interface{}{}
		if err := templates.ExecuteTemplate(buf, "email-update", params); err != nil {
			return 0
		}

		n := 0
		for _, cp := range cps {
			msg := &mail.Message{
				Sender:   kSenderEmail,
				ReplyTo:  kSenderEmail,
				To:       []string{cp.EmailAddress},
				Subject:  subject,
				HTMLBody: buf.String(),
			}
			if err := mail.Send(cdb.Ctx(), msg); err != nil {
				cdb.Errorf("Could not send useremail to <%s>: %v", cp.EmailAddress, err)
			}
			n++
		}
		return n
	}
}

func sendMail(ctx context.Context, mentionProfile *Profile) error {
	msg := &mail.Message{
		Sender:  "<[email protected]>",
		To:      []string{mentionProfile.Email},
		Subject: "Someone mentioned you!",
		Body:    fmt.Sprintf("Someone mentioned you!"),
	}
	return mail.Send(ctx, msg)
}

func sendVerificationCodeEmail(ctx context.Context, user User) {
	msg := &mail.Message{
		Sender:  "NewTechFellas Stock Alerts Admin <[email protected]>",
		To:      []string{user.Email},
		Subject: "Newtechfellas stock alerts verify user",
		Body:    fmt.Sprintf("Your confirmation code is %v", user.VerificationCode),
	}
	if err := mail.Send(ctx, msg); err != nil {
		log.Debugf(ctx, "Couldn't send email: %v", err)
	}
}

func SendEmailToAdmin(c context.Context, subject, htmlbody string) {
	msg := &mail.Message{
		Sender:   kSenderEmail, // cap.Profile.EmailAddress,
		To:       []string{kAdminEmail},
		Subject:  subject,
		HTMLBody: htmlbody,
	}

	if err := mail.Send(c, msg); err != nil {
		log.Errorf(c, "Could not send adminemail to <%s>: %v", kAdminEmail, err)
	}
}

func (sub Subscription) RequestConfirmation(ctx context.Context) error {
	buf := new(bytes.Buffer)
	if err := subscription.Execute(buf, sub); err != nil {
		return err
	}
	return appmail.Send(ctx, &appmail.Message{
		Sender:  "Lorenz Leutgeb <[email protected]>",
		To:      []string{sub.Address.String()},
		Subject: "Hello from Coduno",
		Body:    buf.String(),
	})
}

func followedEmail(w http.ResponseWriter, r *http.Request, email string) {
	ctx := appengine.NewContext(r)
	msg := &mail.Message{
		Sender:  "TwitClone Support <[email protected]>",
		To:      []string{email},
		Subject: "You are being followed",
		Body:    fmt.Sprintf(confirmMessage),
	}
	if err := mail.Send(ctx, msg); err != nil {
		log.Errorf(ctx, "Couldn't send email: %v", err)
	}
}

func sendEmail(email string, c context.Context) {
	msg := &mail.Message{
		Sender:  "[email protected]",
		To:      []string{email},
		Subject: "Agradecimento",
		Body:    "Muito obrigada, farás muitos rostinhos sorrirem!",
	}
	if err := mail.Send(c, msg); err != nil {
		log.Errorf(c, "Couldn't send email to %s: %v", email, err)
	} else {
		log.Infof(c, "Sent email to: %s", email, err)
	}
}

func sendReminderEmail(ctx context.Context,
	email string,
	description string,
	dueDate time.Time) bool {
	msg := &mail.Message{
		Sender:  "Tada <[email protected]>",
		To:      []string{email},
		Subject: fmt.Sprintf("[Tada reminder] %s", description),
		Body: fmt.Sprintf(`This is a friendly reminder about your task: \n
                       %s \n
                       (due %s)\n`, description, dueDate),
	}
	return (mail.Send(ctx, msg) == nil)
}

func confirm(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	addr := r.FormValue("email")
	url := createConfirmationURL(r)
	msg := &mail.Message{
		Sender:  "Example.com Support <[email protected]>",
		To:      []string{addr},
		Subject: "Confirm your registration",
		Body:    fmt.Sprintf(confirmMessage, url),
	}
	if err := mail.Send(ctx, msg); err != nil {
		log.Errorf(ctx, "Couldn't send email: %v", err)
	}
}

// sendEmail with the AppEngine API.
func sendEmail(r *http.Request, from, to, subject, body string) {
	// Use AppEngine to send our thank you cards
	c := appengine.NewContext(r)
	msg := &mail.Message{
		Sender:  from,
		To:      []string{to},
		Subject: subject,
		Body:    body,
	}

	if err := mail.Send(c, msg); err != nil {
		log.Printf("[ERROR] Could not send email: %v\n", err)
	}
}

func handleIndex(res http.ResponseWriter, req *http.Request) {
	ctx := appengine.NewContext(req)
	u := user.Current(ctx)

	msg := &mail.Message{
		Sender:  u.Email,
		To:      []string{"Caleb Doxsey <[email protected]>"},
		Subject: "See you tonight",
		Body:    "Don't forget our plans. Hark, 'til later.",
	}
	if err := mail.Send(ctx, msg); err != nil {
		log.Errorf(ctx, "Alas, my user, the email failed to sendeth: %v", err)
	}
}

func sendEmail(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {

	if r.Method == "POST" {
		c := appengine.NewContext(r)

		addr := r.FormValue("email")
		firstName := r.FormValue("firstName")
		lastName := r.FormValue("lastName")
		message := r.FormValue("message")
		pickupDate := r.FormValue("pickupDate")
		orderType := r.FormValue("orderType")

		msgToBB := &mail.Message{
			Sender:   "The Bakers Box Cafe <[email protected]>",
			ReplyTo:  addr,
			To:       []string{"[email protected]"},
			Subject:  "New Inquiry from: " + firstName + " " + lastName + "!",
			HTMLBody: message + "order by date: " + pickupDate + "\norder type: " + orderType,
		}
		if err := mail.Send(c, msgToBB); err != nil {
			log.Errorf(c, "Message failed to send: %v", err)
		}

		msg := &mail.Message{
			Sender:   "The Bakers Box Cafe <[email protected]>",
			To:       []string{addr},
			Subject:  "Thank you for contacting me!",
			HTMLBody: confirmMessage,
		}
		if err := mail.Send(c, msg); err != nil {
			log.Errorf(c, "Alas, my user, the email failed to sendeth: %v", err)
		}
	}

	// Redirect user to home page after sent email
	http.Redirect(w, r, "/", 303)
}

func NotifyAdmin(c *gin.Context, user *auth.User) {
	r := c.Request
	ctx := appengine.NewContext(r)
	addr := "[email protected]"
	msg := &mail.Message{
		Sender:  "[email protected]",
		To:      []string{addr},
		Subject: fmt.Sprintf("User %s raised volunteer request", user.Email),
		Body:    fmt.Sprintf("User Msg %s %s", user.Message),
	}
	log.Debugf(ctx, "Mail msg %v", msg)
	if err := mail.Send(ctx, msg); err != nil {
		log.Errorf(ctx, "Couldn't send email: %v", err)
	}
}

func SendEmailVolunteer(c *gin.Context, user *auth.User) {
	r := c.Request
	ctx := appengine.NewContext(r)
	addr := user.Email
	url := createConfirmationURL(user)
	msg := &mail.Message{
		Sender:  "[email protected]",
		To:      []string{addr},
		Subject: "Confirm your volunteer request",
		Body:    fmt.Sprintf(confirmMessage, url),
	}
	log.Debugf(ctx, "Mail msg %v", msg)
	if err := mail.Send(ctx, msg); err != nil {
		log.Errorf(ctx, "Couldn't send email: %v", err)
	}
}

func emailUser(ctx context.Context, username string, t *tweet) error {
	to, err := getProfileByUsername(ctx, username)
	if err == datastore.ErrNoSuchEntity {
		return nil
	} else if err != nil {
		return err
	}
	msg := &mail.Message{
		Sender:  "[email protected]",
		To:      []string{fmt.Sprintf("%s <%s>", to.Username, to.Email)},
		Subject: fmt.Sprintf("Mention from %s", t.Username),
		Body:    fmt.Sprintf("%s has mentioned you in a tweet: %s", t.Username, t.Message),
	}
	err = mail.Send(ctx, msg)
	return err
}

func echoMail(ctx context.Context, m mail.Message) {
	from, err := m.Header.AddressList("From")
	if err != nil {
		log.Warningf(ctx, "Failed getting sender of mail: %+v", m)
		return
	}

	b, _ := ioutil.ReadAll(m.Body)

	am := &appmail.Message{
		Sender:  "[email protected]",
		To:      []string{from[0].String()},
		Body:    string(b),
		Headers: m.Header,
	}

	err = appmail.Send(ctx, am)
	if err != nil {
		log.Errorf(ctx, err.Error())
	}
}