website/internal/handlers/messages.go

package handlers

import (
	"database/sql"
	"log"
	"net/http"

	templateHandlers "synlotto-website/internal/handlers/template"
	httpHelpers "synlotto-website/internal/helpers/http"
	securityHelpers "synlotto-website/internal/helpers/security"
	templateHelpers "synlotto-website/internal/helpers/template"

	"synlotto-website/internal/helpers"
	storage "synlotto-website/internal/storage/mysql"
)

func MessagesInboxHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		page := helpers.Atoi(r.URL.Query().Get("page"))
		if page < 1 {
			page = 1
		}
		perPage := 10

		totalCount := storage.GetInboxMessageCount(db, userID)
		totalPages := (totalCount + perPage - 1) / perPage
		if totalPages == 0 {
			totalPages = 1
		}

		messages := storage.GetInboxMessages(db, userID, page, perPage)

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)

		context["Messages"] = messages
		context["CurrentPage"] = page
		context["TotalPages"] = totalPages
		context["PageRange"] = templateHelpers.PageRange(page, totalPages)

		tmpl := templateHelpers.LoadTemplateFiles("messages.html", "templates/account/messages/index.html")

		if err := tmpl.ExecuteTemplate(w, "layout", context); err != nil {
			// ToDo: Make this load all error pages without defining explictly.
			templateHelpers.RenderError(w, r, 500)
		}
	}
}

func ReadMessageHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		idStr := r.URL.Query().Get("id")
		messageID := helpers.Atoi(idStr)

		session, _ := httpHelpers.GetSession(w, r)
		userID, ok := session.Values["user_id"].(int)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		message, err := storage.GetMessageByID(db, userID, messageID)
		if err != nil {
			log.Printf("❌ Message not found: %v", err)
			message = nil
		} else if !message.IsRead {
			_ = storage.MarkMessageAsRead(db, messageID, userID)
		}

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)
		context["Message"] = message

		tmpl := templateHelpers.LoadTemplateFiles("read-message.html", "templates/account/messages/read.html")

		tmpl.ExecuteTemplate(w, "layout", context)
	}
}

func ArchiveMessageHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := helpers.Atoi(r.URL.Query().Get("id"))
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		err := storage.ArchiveMessage(db, userID, id)
		if err != nil {
			templateHelpers.SetFlash(w, r, "Failed to archive message.")
		} else {
			templateHelpers.SetFlash(w, r, "Message archived.")
		}

		http.Redirect(w, r, "/account/messages", http.StatusSeeOther)
	}
}

func ArchivedMessagesHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		page := helpers.Atoi(r.URL.Query().Get("page"))
		if page < 1 {
			page = 1
		}
		perPage := 10

		messages := storage.GetArchivedMessages(db, userID, page, perPage)
		hasMore := len(messages) == perPage

		data := templateHandlers.BuildTemplateData(db, w, r)
		context := templateHelpers.TemplateContext(w, r, data)
		context["Messages"] = messages
		context["Page"] = page
		context["HasMore"] = hasMore

		tmpl := templateHelpers.LoadTemplateFiles("archived.html", "templates/account/messages/archived.html")
		tmpl.ExecuteTemplate(w, "layout", context)
	}
}

func SendMessageHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			data := templateHandlers.BuildTemplateData(db, w, r)
			context := templateHelpers.TemplateContext(w, r, data)
			tmpl := templateHelpers.LoadTemplateFiles("send-message.html", "templates/account/messages/send.html")

			if err := tmpl.ExecuteTemplate(w, "layout", context); err != nil {
				templateHelpers.RenderError(w, r, 500)
			}
		case http.MethodPost:
			senderID, ok := securityHelpers.GetCurrentUserID(r)
			if !ok {
				templateHelpers.RenderError(w, r, 403)
				return
			}

			recipientID := helpers.Atoi(r.FormValue("recipient_id"))
			subject := r.FormValue("subject")
			body := r.FormValue("message")

			if err := storage.SendMessage(db, senderID, recipientID, subject, body); err != nil {
				templateHelpers.SetFlash(w, r, "Failed to send message.")
			} else {
				templateHelpers.SetFlash(w, r, "Message sent.")
			}
			http.Redirect(w, r, "/account/messages", http.StatusSeeOther)
		default:
			templateHelpers.RenderError(w, r, 405)
		}
	}
}

func RestoreMessageHandler(db *sql.DB) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := helpers.Atoi(r.URL.Query().Get("id"))
		userID, ok := securityHelpers.GetCurrentUserID(r)
		if !ok {
			templateHelpers.RenderError(w, r, 403)
			return
		}

		err := storage.RestoreMessage(db, userID, id)
		if err != nil {
			templateHelpers.SetFlash(w, r, "Failed to restore message.")
		} else {
			templateHelpers.SetFlash(w, r, "Message restored.")
		}

		http.Redirect(w, r, "/account/messages/archived", http.StatusSeeOther)
	}
}