website/internal/handlers/account/messages/archive.go

// Package accountMessageHandler
// Path: /internal/handlers/account/messages
// File: archive.go

package accountMessageHandler

import (
	"bytes"
	"net/http"
	"strconv"

	templateHandlers "synlotto-website/internal/handlers/template"
	templateHelpers "synlotto-website/internal/helpers/template"
	errors "synlotto-website/internal/http/error"

	"synlotto-website/internal/logging"
	"synlotto-website/internal/platform/bootstrap"

	"github.com/gin-gonic/gin"
	"github.com/justinas/nosurf"
)

// GET /account/messages/archived
// Renders: web/templates/account/messages/archived.html
func (h *AccountMessageHandlers) ArchivedList(c *gin.Context) {
	app := c.MustGet("app").(*bootstrap.App)
	sm := app.SessionManager
	userID := mustUserID(c)

	// pagination
	page := 1
	if ps := c.Query("page"); ps != "" {
		if n, err := strconv.Atoi(ps); err == nil && n > 0 {
			page = n
		}
	}
	pageSize := 20

	totalPages, totalCount, err := templateHelpers.GetTotalPages(
		c.Request.Context(),
		app.DB,
		"user_messages",
		"recipientId = ? AND is_archived = TRUE",
		[]any{userID},
		pageSize,
	)
	if err != nil {
		logging.Info("❌ count archived error: %v", err)
		c.String(http.StatusInternalServerError, "Failed to load archived messages")
		return
	}
	if page > totalPages {
		page = totalPages
	}

	msgsAll, err := h.Svc.ListArchived(userID)
	if err != nil {
		logging.Info("❌ list archived error: %v", err)
		c.String(http.StatusInternalServerError, "Failed to load archived messages")
		return
	}

	// slice in-memory for now
	start := (page - 1) * pageSize
	if start > len(msgsAll) {
		start = len(msgsAll)
	}
	end := start + pageSize
	if end > len(msgsAll) {
		end = len(msgsAll)
	}
	msgs := msgsAll[start:end]

	data := templateHandlers.BuildTemplateData(app, c.Writer, c.Request)
	ctx := templateHelpers.TemplateContext(c.Writer, c.Request, data)
	if f := sm.PopString(c.Request.Context(), "flash"); f != "" {
		ctx["Flash"] = f
	}
	ctx["CSRFToken"] = nosurf.Token(c.Request)
	ctx["Title"] = "Archived Messages"
	ctx["Messages"] = msgs
	ctx["CurrentPage"] = page
	ctx["TotalPages"] = totalPages
	ctx["TotalCount"] = totalCount
	ctx["PageRange"] = templateHelpers.MakePageRange(1, totalPages)

	tmpl := templateHelpers.LoadTemplateFiles("layout.html", "web/templates/account/messages/archived.html")

	var buf bytes.Buffer
	if err := tmpl.ExecuteTemplate(&buf, "layout", ctx); err != nil {
		logging.Info("❌ Template render error: %v", err)
		c.String(http.StatusInternalServerError, "Error rendering archived messages")
		return
	}
	c.Data(http.StatusOK, "text/html; charset=utf-8", buf.Bytes())
}

// POST /account/messages/archive
func (h *AccountMessageHandlers) ArchivePost(c *gin.Context) {
	app := c.MustGet("app").(*bootstrap.App)
	sm := app.SessionManager
	userID := mustUserID(c)

	idStr := c.PostForm("id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		errors.RenderStatus(c, sm, http.StatusBadRequest)
		return
	}

	if err := h.Svc.Archive(userID, id); err != nil {
		logging.Info("❌ Archive error: %v", err)
		sm.Put(c.Request.Context(), "flash", "Could not archive message.")
		c.Redirect(http.StatusSeeOther, "/account/messages")
		return
	}

	sm.Put(c.Request.Context(), "flash", "Message archived.")
	c.Redirect(http.StatusSeeOther, "/account/messages")
}

// POST /account/messages/restore
func (h *AccountMessageHandlers) RestorePost(c *gin.Context) {
	app := c.MustGet("app").(*bootstrap.App)
	sm := app.SessionManager
	//userID := mustUserID(c)

	idStr := c.PostForm("id")
	id, err := strconv.ParseInt(idStr, 10, 64)
	if err != nil || id <= 0 {
		errors.RenderStatus(c, sm, http.StatusBadRequest)
		return
	}
	//
	//	if err := h.Svc.Unarchive(userID, id); err != nil {
	//		logging.Info("❌ Restore error: %v", err)
	//		sm.Put(c.Request.Context(), "flash", "Could not restore message.")
	//	} else {
	//		sm.Put(c.Request.Context(), "flash", "Message restored.")
	//	}
	c.Redirect(http.StatusSeeOther, "/account/messages/archived")
}