package handlers

import (
	"errors"
	"net/http"
	"strings"
	"time"

	"github.com/mixeme/selfpost/internal/store"
	"github.com/mixeme/selfpost/internal/web/validate"
	"github.com/mixeme/selfpost/internal/web/view"
	"golang.org/x/crypto/bcrypt"
)

// Account is the signed-in user's own half of what used to be one Settings
// page: who they are to the panel (username, e-mail) and their password. Every
// role has it. Each part is its own form and its own POST, so changing one
// never asks for the others.
//
// The e-mail is the user's — what the panel writes to. A domain's DMARC report
// address is set in the domain's settings, where a button fills it with this
// e-mail; nothing here refers to a domain.

// accountForm is what the page shows back: the stored values, or the ones just
// submitted when a form is re-rendered with an error.
type accountForm struct {
	Err      string
	Username string
	Email    string
	Notify   bool
}

func (h *Handlers) accountUser(w http.ResponseWriter, r *http.Request) (store.User, bool) {
	p, ok := h.principal(r)
	if !ok {
		http.NotFound(w, r)
		return store.User{}, false
	}
	u, err := h.store.GetUser(p.ID)
	if err != nil {
		logf("panel: account: get user %d: %v", p.ID, err)
		http.Error(w, "internal error", http.StatusInternalServerError)
		return store.User{}, false
	}
	return u, true
}

func formOf(u store.User) accountForm {
	return accountForm{Username: u.Username, Email: u.Email, Notify: u.Notify}
}

// HandleAccount shows the Account page.
func (h *Handlers) HandleAccount(w http.ResponseWriter, r *http.Request) {
	u, ok := h.accountUser(w, r)
	if !ok {
		return
	}
	h.renderAccount(w, r, http.StatusOK, u, formOf(u))
}

func (h *Handlers) renderAccount(w http.ResponseWriter, r *http.Request, status int, u store.User, f accountForm) {
	page := view.NewAccount(h.shellMeta(r), string(u.Role))
	page.Username, page.Email, page.Notify = f.Username, f.Email, f.Notify
	var sent time.Time
	if l, err := h.store.LatestUserLink(u.ID, store.LinkConfirm, time.Now()); err == nil && l.Email == u.Email {
		sent = l.CreatedAt
	}
	page.WithEmailState(u.Email, !u.EmailConfirmed.IsZero(), sent)
	page.WithResult(accountFlash(r), f.Err)
	h.view.Render(w, status, "account", page)
}

func accountFlash(r *http.Request) string {
	switch r.URL.Query().Get("done") {
	case "profile":
		return "Profile saved."
	case "profile-link":
		return "Profile saved. A link to confirm the new address is on its way."
	case "link":
		return "A new link is on its way."
	case "password":
		return "Password changed. Any other signed-in sessions were signed out."
	}
	return ""
}

// HandleAccountProfile saves the username and the account e-mail.
func (h *Handlers) HandleAccountProfile(w http.ResponseWriter, r *http.Request) {
	u, ok := h.accountUser(w, r)
	if !ok {
		return
	}
	f := formOf(u)
	fail := func(status int, msg string) {
		f.Err = msg
		h.renderAccount(w, r, status, u, f)
	}
	if err := r.ParseForm(); err != nil {
		fail(http.StatusBadRequest, "Invalid form submission.")
		return
	}
	f.Username = strings.TrimSpace(r.PostFormValue("username"))
	f.Email = strings.TrimSpace(r.PostFormValue("email"))
	// An unticked checkbox is not sent at all: absent is off.
	// HTML Living Standard, form-control-infrastructure.html#constructing-entry-list:
	// a checkbox whose checkedness is false is skipped.
	f.Notify = r.PostFormValue("notify") != ""
	if f.Username == "" {
		f.Username = u.Username
	}
	if f.Username != u.Username {
		if err := validate.Username(f.Username); err != nil {
			fail(http.StatusBadRequest, err.Error())
			return
		}
	}
	if err := validate.AccountEmail(f.Email); err != nil {
		fail(http.StatusBadRequest, err.Error())
		return
	}
	// The e-mail is where a reset link goes once it is confirmed, so
	// changing it asks for the password, as changing the password does
	// (roadmap password-reset; 2.0 security review), on the same limit.
	emailChanged := f.Email != u.Email
	if emailChanged {
		if !h.auth.AllowPasswordChange(u.ID) {
			fail(http.StatusTooManyRequests, "Too many attempts. Please wait and try again.")
			return
		}
		current := r.PostFormValue("current_password")
		if current == "" {
			fail(http.StatusUnauthorized, "Your current password is needed to change the e-mail.")
			return
		}
		if err := bcrypt.CompareHashAndPassword([]byte(u.PasswordHash), []byte(current)); err != nil {
			fail(http.StatusUnauthorized, "Current password is incorrect.")
			return
		}
	}
	if err := h.store.UpdateUser(u.ID, f.Username, u.PasswordHash, f.Email); err != nil {
		if errors.Is(err, store.ErrUserExists) {
			fail(http.StatusConflict, "That username is already in use.")
			return
		}
		logf("panel: account: update user %d: %v", u.ID, err)
		fail(http.StatusInternalServerError, "Could not save the profile. Please check the logs and try again.")
		return
	}
	if f.Notify != u.Notify {
		if err := h.store.SetUserNotify(u.ID, f.Notify); err != nil {
			logf("panel: account: set notifications of user %d: %v", u.ID, err)
			fail(http.StatusInternalServerError, "Could not save the profile. Please check the logs and try again.")
			return
		}
	}
	logf("panel: user %d profile updated (username: %t, e-mail: %t, notifications: %t)", u.ID, f.Username != u.Username, f.Email != u.Email, f.Notify)
	if emailChanged && f.Email != "" && h.sendConfirmation(u.ID) {
		http.Redirect(w, r, "/account?done=profile-link", http.StatusSeeOther)
		return
	}
	http.Redirect(w, r, "/account?done=profile", http.StatusSeeOther)
}

// HandleAccountConfirmLink sends the account's unconfirmed address its link
// again (Account, "Send the link again").
func (h *Handlers) HandleAccountConfirmLink(w http.ResponseWriter, r *http.Request) {
	u, ok := h.accountUser(w, r)
	if !ok {
		return
	}
	if u.Email == "" || !u.EmailConfirmed.IsZero() {
		http.Redirect(w, r, "/account", http.StatusSeeOther)
		return
	}
	f := formOf(u)
	if !h.auth.AllowConfirmationLink(u.ID) {
		f.Err = "Too many links asked for. Please wait and try again."
		h.renderAccount(w, r, http.StatusTooManyRequests, u, f)
		return
	}
	h.auth.SendConfirmationLater(u)
	http.Redirect(w, r, "/account?done=link", http.StatusSeeOther)
}

// sendConfirmation mails the user's unconfirmed address its link after the
// answer, within the limit of links to one address; whether one was sent off.
// A link that cannot go is logged: the address is saved all the same, and
// Account offers to send it again.
func (h *Handlers) sendConfirmation(userID int64) bool {
	if h.auth == nil || !h.auth.CanMail() {
		return false
	}
	u, err := h.store.GetUser(userID)
	if err != nil || u.Email == "" || !u.EmailConfirmed.IsZero() {
		return false
	}
	if !h.auth.AllowConfirmationLink(u.ID) {
		logf("panel: user %d: confirmation links asked for too often; none was sent", u.ID)
		return false
	}
	h.auth.SendConfirmationLater(u)
	return true
}

// HandleAccountPassword changes the password. It asks for the current one and
// is rate-limited like a sign-in: the form is a place to guess a password from
// an unattended session.
func (h *Handlers) HandleAccountPassword(w http.ResponseWriter, r *http.Request) {
	u, ok := h.accountUser(w, r)
	if !ok {
		return
	}
	f := formOf(u)
	fail := func(status int, msg string) {
		f.Err = msg
		h.renderAccount(w, r, status, u, f)
	}
	if !h.auth.AllowPasswordChange(u.ID) {
		fail(http.StatusTooManyRequests, "Too many attempts. Please wait and try again.")
		return
	}
	if err := r.ParseForm(); err != nil {
		fail(http.StatusBadRequest, "Invalid form submission.")
		return
	}
	current := r.PostFormValue("current_password")
	password := r.PostFormValue("new_password")
	confirm := r.PostFormValue("new_password_confirm")
	if err := bcrypt.CompareHashAndPassword([]byte(u.PasswordHash), []byte(current)); err != nil {
		fail(http.StatusUnauthorized, "Current password is incorrect.")
		return
	}
	if password != confirm {
		fail(http.StatusBadRequest, "New passwords do not match.")
		return
	}
	if err := validate.AdminPassword(password); err != nil {
		fail(http.StatusBadRequest, err.Error())
		return
	}
	hash, err := bcrypt.GenerateFromPassword([]byte(password), bcryptCost)
	if err != nil {
		logf("panel: account: hashing password failed: %v", err)
		fail(http.StatusInternalServerError, "Internal error. Please try again.")
		return
	}
	if err := h.store.UpdateUser(u.ID, u.Username, string(hash), u.Email); err != nil {
		logf("panel: account: update password of user %d: %v", u.ID, err)
		fail(http.StatusInternalServerError, "Could not save the password. Please check the logs and try again.")
		return
	}
	if token, ok := h.auth.SessionToken(r); ok {
		h.auth.DestroyOtherSessions(u.ID, token)
	}
	// A password set another way leaves no reset link behind it.
	if err := h.store.DeleteUserLinks(u.ID, store.LinkReset); err != nil {
		logf("panel: account: %v", err)
	}
	logf("panel: user %d changed their password", u.ID)
	http.Redirect(w, r, "/account?done=password", http.StatusSeeOther)
}