package main

import (
	"fmt"
	"net/http"
	"os"
	"strings"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/golang-jwt/jwt"
	"github.com/hrfee/jfa-go/jellyseerr"
	lm "github.com/hrfee/jfa-go/logmessages"
	"github.com/lithammer/shortuuid/v3"
	"github.com/timshannon/badgerhold/v4"
)

const (
	REFERRAL_EXPIRY_DAYS = 90
)

// @Summary Returns the logged-in user's Jellyfin ID & Username, and other details.
// @Produce json
// @Success 200 {object} MyDetailsDTO
// @Router /my/details [get]
// @tags User Page
func (app *appContext) MyDetails(gc *gin.Context) {
	resp := MyDetailsDTO{
		Id: gc.GetString("jfId"),
	}

	user, err := app.jf.UserByID(resp.Id, false)
	if err != nil {
		app.err.Printf(lm.FailedGetUsers, lm.Jellyfin, err)
		respond(500, "Failed to get user", gc)
		return
	}
	resp.Username = user.Name
	resp.Admin = user.Policy.IsAdministrator
	resp.AccountsAdmin = false
	if !app.config.Section("ui").Key("allow_all").MustBool(false) {
		adminOnly := app.config.Section("ui").Key("admin_only").MustBool(true)
		if emailStore, ok := app.storage.GetEmailsKey(resp.Id); ok {
			resp.AccountsAdmin = emailStore.Admin
		}
		resp.AccountsAdmin = resp.AccountsAdmin || (adminOnly && resp.Admin)
	}
	resp.Disabled = user.Policy.IsDisabled

	if exp, ok := app.storage.GetUserExpiryKey(user.ID); ok {
		resp.Expiry = exp.Expiry.Unix()
	}

	if emailEnabled {
		resp.Email = &MyDetailsContactMethodsDTO{}
		if email, ok := app.storage.GetEmailsKey(user.ID); ok && email.Addr != "" {
			resp.Email.Value = email.Addr
			resp.Email.Enabled = email.Contact
		}
	}

	if discordEnabled {
		resp.Discord = &MyDetailsContactMethodsDTO{}
		if discord, ok := app.storage.GetDiscordKey(user.ID); ok {
			resp.Discord.Value = RenderDiscordUsername(discord)
			resp.Discord.Enabled = discord.Contact
		}
	}

	if telegramEnabled {
		resp.Telegram = &MyDetailsContactMethodsDTO{}
		if telegram, ok := app.storage.GetTelegramKey(user.ID); ok {
			resp.Telegram.Value = telegram.Username
			resp.Telegram.Enabled = telegram.Contact
		}
	}

	if matrixEnabled {
		resp.Matrix = &MyDetailsContactMethodsDTO{}
		if matrix, ok := app.storage.GetMatrixKey(user.ID); ok {
			resp.Matrix.Value = matrix.UserID
			resp.Matrix.Enabled = matrix.Contact
		}
	}

	if app.config.Section("user_page").Key("referrals").MustBool(false) {
		// 1. Look for existing template bound to this Jellyfin ID
		//    If one exists, that means its just for us and so we
		//    can use it directly.
		inv := Invite{}
		err := app.storage.db.FindOne(&inv, badgerhold.Where("ReferrerJellyfinID").Eq(resp.Id))
		if err == nil {
			resp.HasReferrals = true
		} else {
			// 2. Look for a template matching the key found in the user storage
			//    Since this key is shared between users in a profile, we make a copy.
			user, ok := app.storage.GetEmailsKey(gc.GetString("jfId"))
			err = app.storage.db.Get(user.ReferralTemplateKey, &inv)
			if ok && err == nil {
				resp.HasReferrals = true
			}
		}
	}

	gc.JSON(200, resp)
}

// @Summary Sets whether to notify yourself through telegram/discord/matrix/email or not.
// @Produce json
// @Param SetContactMethodsDTO body SetContactMethodsDTO true "User's Jellyfin ID and whether or not to notify then through Telegram."
// @Success 200 {object} boolResponse
// @Success 400 {object} boolResponse
// @Success 500 {object} boolResponse
// @Router /my/contact [post]
// @Security Bearer
// @tags User Page
func (app *appContext) SetMyContactMethods(gc *gin.Context) {
	var req SetContactMethodsDTO
	gc.BindJSON(&req)
	req.ID = gc.GetString("jfId")
	if req.ID == "" {
		respondBool(400, false, gc)
		return
	}
	app.setContactMethods(req, gc)
}

// @Summary Logout by deleting refresh token from cookies.
// @Produce json
// @Success 200 {object} boolResponse
// @Failure 500 {object} stringResponse
// @Router /my/logout [post]
// @Security Bearer
// @tags User Page
func (app *appContext) LogoutUser(gc *gin.Context) {
	cookie, err := gc.Cookie("user-refresh")
	if err != nil {
		msg := fmt.Sprintf(lm.FailedGetCookies, "user-refresh", err)
		app.debug.Println(msg)
		respond(500, msg, gc)
		return
	}
	app.invalidTokens = append(app.invalidTokens, cookie)
	gc.SetCookie("refresh", "invalid", -1, "/my", gc.Request.URL.Hostname(), true, true)
	respondBool(200, true, gc)
}

// @Summary confirm an action (e.g. changing an email address.)
// @Produce json
// @Param jwt path string true "jwt confirmation code"
// @Router /my/confirm/{jwt} [post]
// @Success 200 {object} boolResponse
// @Failure 400 {object} stringResponse
// @Failure 404
// @Success 303
// @Failure 500 {object} stringResponse
// @tags User Page
func (app *appContext) ConfirmMyAction(gc *gin.Context) {
	app.confirmMyAction(gc, "")
}

func (app *appContext) confirmMyAction(gc *gin.Context, key string) {
	var claims jwt.MapClaims
	var target ConfirmationTarget
	var id string
	fail := func() {
		gcHTML(gc, 404, "404.html", gin.H{
			"cssClass":       app.cssClass,
			"cssVersion":     cssVersion,
			"contactMessage": app.config.Section("ui").Key("contact_message").String(),
		})
	}

	// Validate key
	if key == "" {
		key = gc.Param("jwt")
	}
	token, err := jwt.Parse(key, checkToken)
	if err != nil {
		app.err.Printf(lm.FailedParseJWT, err)
		fail()
		// respond(500, "unknownError", gc)
		return
	}
	claims, ok := token.Claims.(jwt.MapClaims)
	if !ok {
		app.err.Println(lm.FailedCastJWT)
		fail()
		// respond(500, "unknownError", gc)
		return
	}
	expiry := time.Unix(int64(claims["exp"].(float64)), 0)
	if !(ok && token.Valid && claims["type"].(string) == "confirmation" && expiry.After(time.Now())) {
		app.err.Println(lm.InvalidJWT)
		fail()
		// respond(400, "invalidKey", gc)
		return
	}
	target = ConfirmationTarget(int(claims["target"].(float64)))
	id = claims["id"].(string)

	// Perform an Action
	if target == NoOp {
		gc.Redirect(http.StatusSeeOther, "/my/account")
		return
	} else if target == UserEmailChange {
		app.modifyEmail(id, claims["email"].(string))

		app.storage.SetActivityKey(shortuuid.New(), Activity{
			Type:       ActivityContactLinked,
			UserID:     gc.GetString("jfId"),
			SourceType: ActivityUser,
			Source:     gc.GetString("jfId"),
			Value:      "email",
			Time:       time.Now(),
		}, gc, true)

		app.info.Printf(lm.UserEmailAdjusted, gc.GetString("jfId"))
		gc.Redirect(http.StatusSeeOther, "/my/account")
		return
	}
}

// @Summary Modify your email address.
// @Produce json
// @Param ModifyMyEmailDTO body ModifyMyEmailDTO true "New email address."
// @Success 200 {object} boolResponse
// @Failure 400 {object} stringResponse
// @Failure 401 {object} stringResponse
// @Failure 500 {object} stringResponse
// @Router /my/email [post]
// @Security Bearer
// @tags User Page
func (app *appContext) ModifyMyEmail(gc *gin.Context) {
	var req ModifyMyEmailDTO
	gc.BindJSON(&req)
	if !strings.ContainsRune(req.Email, '@') {
		respond(400, "Invalid Email Address", gc)
		return
	}
	id := gc.GetString("jfId")

	// We'll use the ConfirmMyAction route to do the work, even if we don't need to confirm the address.
	claims := jwt.MapClaims{
		"valid":  true,
		"id":     id,
		"email":  req.Email,
		"type":   "confirmation",
		"target": UserEmailChange,
		"exp":    time.Now().Add(time.Hour).Unix(),
	}
	tk := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
	key, err := tk.SignedString([]byte(os.Getenv("JFA_SECRET")))

	if err != nil {
		app.err.Printf(lm.FailedSignJWT, err)
		respond(500, "errorUnknown", gc)
		return
	}

	if emailEnabled && app.config.Section("email_confirmation").Key("enabled").MustBool(false) {
		user, err := app.jf.UserByID(id, false)
		name := ""
		if err == nil {
			name = user.Name
		}
		app.debug.Printf(lm.EmailConfirmationRequired, id)
		respond(401, "confirmEmail", gc)
		msg, err := app.email.constructConfirmation("", name, key, app, false)
		if err != nil {
			app.err.Printf(lm.FailedConstructConfirmationEmail, id, err)
		} else if err := app.email.send(msg, req.Email); err != nil {
			app.err.Printf(lm.FailedSendConfirmationEmail, id, req.Email, err)
		} else {
			app.err.Printf(lm.SentConfirmationEmail, id, req.Email)
		}
		return
	}

	app.confirmMyAction(gc, key)
	return
}

// @Summary Returns a 10-minute, one-use Discord server invite
// @Produce json
// @Success 200 {object} DiscordInviteDTO
// @Failure 400 {object} boolResponse
// @Failure 401 {object} boolResponse
// @Failure 500 {object} boolResponse
// @Param invCode path string true "invite Code"
// @Router /my/discord/invite [get]
// @Security Bearer
// @tags User Page
func (app *appContext) MyDiscordServerInvite(gc *gin.Context) {
	if app.discord.InviteChannel.Name == "" {
		respondBool(400, false, gc)
		return
	}
	invURL, iconURL := app.discord.NewTempInvite(10*60, 1)
	if invURL == "" {
		respondBool(500, false, gc)
		return
	}
	gc.JSON(200, DiscordInviteDTO{invURL, iconURL})
}

// @Summary Returns a linking PIN for discord/telegram
// @Produce json
// @Success 200 {object} GetMyPINDTO
// @Failure 400 {object} stringResponse
// Param service path string true "discord/telegram"
// @Router /my/pin/{service} [get]
// @Security Bearer
// @tags User Page
func (app *appContext) GetMyPIN(gc *gin.Context) {
	service := gc.Param("service")
	resp := GetMyPINDTO{}
	switch service {
	case "discord":
		resp.PIN = app.discord.NewAssignedAuthToken(gc.GetString("jfId"))
		break
	case "telegram":
		resp.PIN = app.telegram.NewAssignedAuthToken(gc.GetString("jfId"))
		break
	default:
		respond(400, "invalid service", gc)
		return
	}
	gc.JSON(200, resp)
}

// @Summary Returns true/false on whether or not your discord PIN was verified, and assigns the discord user to you.
// @Produce json
// @Success 200 {object} boolResponse
// @Failure 401 {object} boolResponse
// @Param pin path string true "PIN code to check"
// @Router /my/discord/verified/{pin} [get]
// @Security Bearer
// @tags User Page
func (app *appContext) MyDiscordVerifiedInvite(gc *gin.Context) {
	pin := gc.Param("pin")
	dcUser, ok := app.discord.AssignedUserVerified(pin, gc.GetString("jfId"))
	app.discord.DeleteVerifiedToken(pin)
	if !ok {
		respondBool(200, false, gc)
		return
	}
	if app.config.Section("discord").Key("require_unique").MustBool(false) && app.discord.UserExists(dcUser.ID) {
		respondBool(400, false, gc)
		return
	}
	existingUser, ok := app.storage.GetDiscordKey(gc.GetString("jfId"))
	if ok {
		dcUser.Lang = existingUser.Lang
		dcUser.Contact = existingUser.Contact
	}
	app.storage.SetDiscordKey(gc.GetString("jfId"), dcUser)

	if err := app.js.ModifyNotifications(gc.GetString("jfId"), map[jellyseerr.NotificationsField]any{
		jellyseerr.FieldDiscord:        dcUser.ID,
		jellyseerr.FieldDiscordEnabled: dcUser.Contact,
	}); err != nil {
		app.err.Printf(lm.FailedSyncContactMethods, lm.Jellyseerr, err)
	}

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactLinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "discord",
		Time:       time.Now(),
	}, gc, true)

	respondBool(200, true, gc)
}

// @Summary Returns true/false on whether or not your telegram PIN was verified, and assigns the telegram user to you.
// @Produce json
// @Success 200 {object} boolResponse
// @Failure 401 {object} boolResponse
// @Param pin path string true "PIN code to check"
// @Router /my/telegram/verified/{pin} [get]
// @Security Bearer
// @tags User Page
func (app *appContext) MyTelegramVerifiedInvite(gc *gin.Context) {
	pin := gc.Param("pin")
	token, ok := app.telegram.AssignedTokenVerified(pin, gc.GetString("jfId"))
	app.telegram.DeleteVerifiedToken(pin)
	if !ok {
		respondBool(200, false, gc)
		return
	}
	if app.config.Section("telegram").Key("require_unique").MustBool(false) && app.telegram.UserExists(token.Username) {
		respondBool(400, false, gc)
		return
	}
	tgUser := TelegramUser{
		ChatID:   token.ChatID,
		Username: token.Username,
		Contact:  true,
	}
	if lang, ok := app.telegram.languages[tgUser.ChatID]; ok {
		tgUser.Lang = lang
	}

	existingUser, ok := app.storage.GetTelegramKey(gc.GetString("jfId"))
	if ok {
		tgUser.Lang = existingUser.Lang
		tgUser.Contact = existingUser.Contact
	}
	app.storage.SetTelegramKey(gc.GetString("jfId"), tgUser)

	if err := app.js.ModifyNotifications(gc.GetString("jfId"), map[jellyseerr.NotificationsField]any{
		jellyseerr.FieldTelegram:        tgUser.ChatID,
		jellyseerr.FieldTelegramEnabled: tgUser.Contact,
	}); err != nil {
		app.err.Printf(lm.FailedSyncContactMethods, lm.Jellyseerr, err)
	}

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactLinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "telegram",
		Time:       time.Now(),
	}, gc, true)

	respondBool(200, true, gc)
}

// @Summary Generate and send a new PIN to your given matrix user.
// @Produce json
// @Success 200 {object} boolResponse
// @Failure 400 {object} stringResponse
// @Failure 401 {object} boolResponse
// @Failure 500 {object} boolResponse
// @Param MatrixSendPINDTO body MatrixSendPINDTO true "User's Matrix ID."
// @Router /my/matrix/user [post]
// @Security Bearer
// @tags User Page
func (app *appContext) MatrixSendMyPIN(gc *gin.Context) {
	var req MatrixSendPINDTO
	gc.BindJSON(&req)
	if req.UserID == "" {
		respond(400, "errorNoUserID", gc)
		return
	}
	if app.config.Section("matrix").Key("require_unique").MustBool(false) {
		for _, u := range app.storage.GetMatrix() {
			if req.UserID == u.UserID {
				respondBool(400, false, gc)
				return
			}
		}
	}

	ok := app.matrix.SendStart(req.UserID)
	if !ok {
		respondBool(500, false, gc)
		return
	}
	respondBool(200, true, gc)
}

// @Summary Check whether your matrix PIN is valid, and link the account to yours if so.
// @Produce json
// @Success 200 {object} boolResponse
// @Failure 401 {object} boolResponse
// @Param pin path string true "PIN code to check"
// @Param invCode path string true "invite Code"
// @Param userID path string true "Matrix User ID"
// @Router /my/matrix/verified/{userID}/{pin} [get]
// @Security Bearer
// @tags User Page
func (app *appContext) MatrixCheckMyPIN(gc *gin.Context) {
	userID := gc.Param("userID")
	pin := gc.Param("pin")
	user, ok := app.matrix.tokens[pin]
	if !ok {
		app.debug.Printf(lm.InvalidPIN, pin)
		respondBool(200, false, gc)
		return
	}
	if user.User.UserID != userID {
		app.debug.Printf(lm.UnauthorizedPIN, pin)
		respondBool(200, false, gc)
		return
	}

	mxUser := *user.User
	mxUser.Contact = true
	existingUser, ok := app.storage.GetMatrixKey(gc.GetString("jfId"))
	if ok {
		mxUser.Lang = existingUser.Lang
		mxUser.Contact = existingUser.Contact
	}

	app.storage.SetMatrixKey(gc.GetString("jfId"), mxUser)

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactLinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "matrix",
		Time:       time.Now(),
	}, gc, true)

	delete(app.matrix.tokens, pin)
	respondBool(200, true, gc)
}

// @Summary unlink the Discord account from your Jellyfin user. Always succeeds.
// @Produce json
// @Success 200 {object} boolResponse
// @Router /my/discord [delete]
// @Security Bearer
// @Tags User Page
func (app *appContext) UnlinkMyDiscord(gc *gin.Context) {
	app.storage.DeleteDiscordKey(gc.GetString("jfId"))

	if err := app.js.ModifyNotifications(gc.GetString("jfId"), map[jellyseerr.NotificationsField]any{
		jellyseerr.FieldDiscord:        jellyseerr.BogusIdentifier,
		jellyseerr.FieldDiscordEnabled: false,
	}); err != nil {
		app.err.Printf(lm.FailedSyncContactMethods, lm.Jellyseerr, err)
	}

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactUnlinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "discord",
		Time:       time.Now(),
	}, gc, true)

	respondBool(200, true, gc)
}

// @Summary unlink the Telegram account from your Jellyfin user. Always succeeds.
// @Produce json
// @Success 200 {object} boolResponse
// @Router /my/telegram [delete]
// @Security Bearer
// @Tags User Page
func (app *appContext) UnlinkMyTelegram(gc *gin.Context) {
	app.storage.DeleteTelegramKey(gc.GetString("jfId"))

	if err := app.js.ModifyNotifications(gc.GetString("jfId"), map[jellyseerr.NotificationsField]any{
		jellyseerr.FieldTelegram:        jellyseerr.BogusIdentifier,
		jellyseerr.FieldTelegramEnabled: false,
	}); err != nil {
		app.err.Printf(lm.FailedSyncContactMethods, lm.Jellyseerr, err)
	}

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactUnlinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "telegram",
		Time:       time.Now(),
	}, gc, true)

	respondBool(200, true, gc)
}

// @Summary unlink the Matrix account from your Jellyfin user. Always succeeds.
// @Produce json
// @Success 200 {object} boolResponse
// @Router /my/matrix [delete]
// @Security Bearer
// @Tags User Page
func (app *appContext) UnlinkMyMatrix(gc *gin.Context) {
	app.storage.DeleteMatrixKey(gc.GetString("jfId"))

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityContactUnlinked,
		UserID:     gc.GetString("jfId"),
		SourceType: ActivityUser,
		Source:     gc.GetString("jfId"),
		Value:      "matrix",
		Time:       time.Now(),
	}, gc, true)

	respondBool(200, true, gc)
}

// @Summary Generate & send a password reset link if the given username/email/contact method exists. Doesn't give you any info about it's success.
// @Produce json
// @Param address path string true "address/contact method associated w/ your account."
// @Success 204 {object} boolResponse
// @Failure 400 {object} boolResponse
// @Failure 500 {object} boolResponse
// @Router /my/password/reset/{address} [post]
// @Tags User Page
func (app *appContext) ResetMyPassword(gc *gin.Context) {
	// All requests should take 1 second, to make it harder to tell if a success occured or not.
	timerWait := make(chan bool)
	cancel := time.AfterFunc(1*time.Second, func() {
		timerWait <- true
	})
	usernameAllowed := app.config.Section("user_page").Key("allow_pwr_username").MustBool(true)
	emailAllowed := app.config.Section("user_page").Key("allow_pwr_email").MustBool(true)
	contactMethodAllowed := app.config.Section("user_page").Key("allow_pwr_contact_method").MustBool(true)
	address := gc.Param("address")
	if address == "" {
		cancel.Stop()
		respondBool(400, false, gc)
		return
	}
	var pwr InternalPWR
	var err error

	jfUser, ok := app.ReverseUserSearch(address, usernameAllowed, emailAllowed, contactMethodAllowed)
	if !ok {
		app.debug.Printf(lm.FailedGetUsers, lm.Jellyfin, "no results")

		for range timerWait {
			respondBool(204, true, gc)
			return
		}
		return
	}
	pwr, err = app.GenInternalReset(jfUser.ID)
	if err != nil {
		app.err.Printf(lm.FailedGetUsers, lm.Jellyfin, err)
		for range timerWait {
			respondBool(204, true, gc)
			return
		}
		return
	}
	if app.internalPWRs == nil {
		app.internalPWRs = map[string]InternalPWR{}
	}
	app.internalPWRs[pwr.PIN] = pwr
	// FIXME: Send to all contact methods
	msg, err := app.email.constructReset(
		PasswordReset{
			Pin:      pwr.PIN,
			Username: pwr.Username,
			Expiry:   pwr.Expiry,
			Internal: true,
		}, app, false,
	)
	if err != nil {
		app.err.Printf(lm.FailedConstructPWRMessage, pwr.Username, err)
		for range timerWait {
			respondBool(204, true, gc)
			return
		}
		return
	} else if err := app.sendByID(msg, jfUser.ID); err != nil {
		app.err.Printf(lm.FailedSendPWRMessage, pwr.Username, "?", err)
	} else {
		app.info.Printf(lm.SentPWRMessage, pwr.Username, "?")
	}
	for range timerWait {
		respondBool(204, true, gc)
		return
	}
}

// @Summary Change your password, given the old one and the new one.
// @Produce json
// @Param ChangeMyPasswordDTO body ChangeMyPasswordDTO true "User's old & new passwords."
// @Success 204 {object} boolResponse
// @Failure 400 {object} PasswordValidation
// @Failure 401 {object} boolResponse
// @Failure 500 {object} boolResponse
// @Router /my/password [post]
// @Security Bearer
// @Tags User Page
func (app *appContext) ChangeMyPassword(gc *gin.Context) {
	var req ChangeMyPasswordDTO
	gc.BindJSON(&req)
	if req.Old == "" || req.New == "" {
		respondBool(400, false, gc)
	}
	validation := app.validator.validate(req.New)
	for _, val := range validation {
		if !val {
			gc.JSON(400, validation)
			return
		}
	}
	user, err := app.jf.UserByID(gc.GetString("jfId"), false)
	if err != nil {
		app.err.Printf(lm.FailedGetUser, gc.GetString("jfId"), lm.Jellyfin, err)
		respondBool(500, false, gc)
		return
	}
	// Authenticate as user to confirm old password.
	user, err = app.authJf.Authenticate(user.Name, req.Old)
	if err != nil {
		respondBool(401, false, gc)
		return
	}
	err = app.jf.SetPassword(gc.GetString("jfId"), req.Old, req.New)
	if err != nil {
		respondBool(500, false, gc)
		return
	}

	app.storage.SetActivityKey(shortuuid.New(), Activity{
		Type:       ActivityChangePassword,
		UserID:     user.ID,
		SourceType: ActivityUser,
		Source:     user.ID,
		Time:       time.Now(),
	}, gc, true)

	if app.config.Section("ombi").Key("enabled").MustBool(false) {
		func() {
			ombiUser, err := app.getOmbiUser(gc.GetString("jfId"))
			if err != nil {
				app.err.Printf(lm.FailedGetUser, user.Name, lm.Ombi, err)
				return
			}
			ombiUser["password"] = req.New
			err = app.ombi.ModifyUser(ombiUser)
			if err != nil {
				app.err.Printf(lm.FailedChangePassword, lm.Ombi, ombiUser["userName"], err)
				return
			}
			app.debug.Printf(lm.ChangePassword, lm.Ombi, ombiUser["userName"])
		}()
	}
	cookie, err := gc.Cookie("user-refresh")
	if err == nil {
		app.invalidTokens = append(app.invalidTokens, cookie)
		gc.SetCookie("refresh", "invalid", -1, "/my", gc.Request.URL.Hostname(), true, true)
	} else {
		app.debug.Printf(lm.FailedGetCookies, "user-refresh", err)
	}
	respondBool(204, true, gc)
}

// @Summary Get or generate a new referral code.
// @Produce json
// @Success 200 {object} GetMyReferralRespDTO
// @Failure 400 {object} boolResponse
// @Failure 401 {object} boolResponse
// @Failure 500 {object} boolResponse
// @Router /my/referral [get]
// @Security Bearer
// @Tags User Page
func (app *appContext) GetMyReferral(gc *gin.Context) {
	// 1. Look for existing template bound to this Jellyfin ID
	//    If one exists, that means its just for us and so we
	//    can use it directly.
	inv := Invite{}
	err := app.storage.db.FindOne(&inv, badgerhold.Where("ReferrerJellyfinID").Eq(gc.GetString("jfId")))
	if err != nil {
		// 2. Look for a template matching the key found in the user storage
		//    Since this key is shared between users in a profile, we make a copy.
		user, ok := app.storage.GetEmailsKey(gc.GetString("jfId"))
		err = app.storage.db.Get(user.ReferralTemplateKey, &inv)
		if !ok || err != nil || user.ReferralTemplateKey == "" {
			app.debug.Printf(lm.FailedGetReferralTemplate, user.ReferralTemplateKey, err)
			respondBool(400, false, gc)
			return
		}
		inv.Code = GenerateInviteCode()
		expiryDelta := inv.ValidTill.Sub(inv.Created)
		inv.Created = time.Now()
		if inv.UseReferralExpiry {
			inv.ValidTill = inv.Created.Add(expiryDelta)
		} else {
			inv.ValidTill = inv.Created.Add(REFERRAL_EXPIRY_DAYS * 24 * time.Hour)
		}
		inv.IsReferral = true
		inv.ReferrerJellyfinID = gc.GetString("jfId")
		app.storage.SetInvitesKey(inv.Code, inv)
	} else if time.Now().After(inv.ValidTill) {
		// 3. We found an invite for us, but it's expired.
		//    We delete it from storage, and put it back with a fresh code and expiry.
		//    If UseReferralExpiry is enabled, we delete it and return nothing.
		app.storage.DeleteInvitesKey(inv.Code)
		if inv.UseReferralExpiry {
			app.debug.Printf(lm.DeleteOldReferral, inv.Code)
			user, ok := app.storage.GetEmailsKey(gc.GetString("jfId"))
			if ok {
				user.ReferralTemplateKey = ""
				app.storage.SetEmailsKey(gc.GetString("jfId"), user)
			}
			app.debug.Printf("Ignoring referral request, expired.")
			respondBool(400, false, gc)
			return
		}
		app.debug.Printf(lm.RenewOldReferral, inv.Code)
		inv.Code = GenerateInviteCode()
		inv.Created = time.Now()
		inv.ValidTill = inv.Created.Add(REFERRAL_EXPIRY_DAYS * 24 * time.Hour)
		app.storage.SetInvitesKey(inv.Code, inv)
	}
	gc.JSON(200, GetMyReferralRespDTO{
		Code:          inv.Code,
		RemainingUses: inv.RemainingUses,
		NoLimit:       inv.NoLimit,
		Expiry:        inv.ValidTill.Unix(),
		UseExpiry:     inv.UseReferralExpiry,
	})
}