package handler

import (
	"context"
	"net/http"
	"time"

	"projectreshoot/internal/models"
	"projectreshoot/internal/view/component/account"
	"projectreshoot/internal/view/page"

	"git.haelnorr.com/h/golib/hws"
	"git.haelnorr.com/h/golib/hwsauth"

	"git.haelnorr.com/h/golib/cookies"

	"github.com/pkg/errors"
	"github.com/uptrace/bun"
)

// Renders the account page on the 'General' subpage
func AccountPage() http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			cookie, err := r.Cookie("subpage")
			subpage := "General"
			if err == nil {
				subpage = cookie.Value
			}
			page.Account(subpage).Render(r.Context(), w)
		},
	)
}

// Handles a request to change the subpage for the Accou/accountnt page
func AccountSubpage() http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			r.ParseForm()
			subpage := r.FormValue("subpage")
			cookies.SetCookie(w, "subpage", "/account", subpage, 300)
			account.AccountContainer(subpage).Render(r.Context(), w)
		},
	)
}

// Handles a request to change the users username
func ChangeUsername(
	server *hws.Server,
	auth *hwsauth.Authenticator[*models.UserBun, bun.Tx],
	db *bun.DB,
) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
			defer cancel()

			// Start the transaction
			tx, err := db.BeginTx(ctx, nil)
			if err != nil {
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusServiceUnavailable,
					Message:    "Error updating username",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			r.ParseForm()
			newUsername := r.FormValue("username")
			unique, err := models.IsUsernameUnique(ctx, tx, newUsername)
			if err != nil {
				tx.Rollback()
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusInternalServerError,
					Message:    "Error updating username",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			if !unique {
				tx.Rollback()
				account.ChangeUsername("Username is taken", newUsername).
					Render(r.Context(), w)
				return
			}
			user := auth.CurrentModel(r.Context())
			err = user.ChangeUsername(ctx, tx, newUsername)
			if err != nil {
				tx.Rollback()
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusInternalServerError,
					Message:    "Error updating username",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			tx.Commit()
			w.Header().Set("HX-Refresh", "true")
		},
	)
}

// Handles a request to change the users bio
func ChangeBio(
	server *hws.Server,
	auth *hwsauth.Authenticator[*models.UserBun, bun.Tx],
	db *bun.DB,
) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
			defer cancel()

			// Start the transaction
			tx, err := db.BeginTx(ctx, nil)
			if err != nil {
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusServiceUnavailable,
					Message:    "Error updating bio",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			r.ParseForm()
			newBio := r.FormValue("bio")
			leng := len([]rune(newBio))
			if leng > 128 {
				tx.Rollback()
				account.ChangeBio("Bio limited to 128 characters", newBio).
					Render(r.Context(), w)
				return
			}
			user := auth.CurrentModel(r.Context())
			err = user.ChangeBio(ctx, tx, newBio)
			if err != nil {
				tx.Rollback()
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusInternalServerError,
					Message:    "Error updating bio",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			tx.Commit()
			w.Header().Set("HX-Refresh", "true")
		},
	)
}
func validateChangePassword(
	r *http.Request,
) (string, error) {
	r.ParseForm()
	formPassword := r.FormValue("password")
	formConfirmPassword := r.FormValue("confirm-password")
	if formPassword != formConfirmPassword {
		return "", errors.New("Passwords do not match")
	}
	if len(formPassword) > 72 {
		return "", errors.New("Password exceeds maximum length of 72 bytes")
	}
	return formPassword, nil
}

// Handles a request to change the users password
func ChangePassword(
	server *hws.Server,
	auth *hwsauth.Authenticator[*models.UserBun, bun.Tx],
	db *bun.DB,
) http.Handler {
	return http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			ctx, cancel := context.WithTimeout(r.Context(), 15*time.Second)
			defer cancel()

			// Start the transaction
			tx, err := db.BeginTx(ctx, nil)
			if err != nil {
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusServiceUnavailable,
					Message:    "Error updating password",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			newPass, err := validateChangePassword(r)
			if err != nil {
				tx.Rollback()
				account.ChangePassword(err.Error()).Render(r.Context(), w)
				return
			}
			user := auth.CurrentModel(r.Context())
			err = user.SetPassword(ctx, tx, newPass)
			if err != nil {
				tx.Rollback()
				err := server.ThrowError(w, r, hws.HWSError{
					StatusCode: http.StatusInternalServerError,
					Message:    "Error updating password",
					Error:      err,
				})
				if err != nil {
					server.ThrowFatal(w, err)
				}
				return
			}
			tx.Commit()
			w.Header().Set("HX-Refresh", "true")
		},
	)
}