package handlers
import (
"context"
"fmt"
"html/template"
"log"
"net/http"
"net/url"
"sort"
"strings"
"github.com/go-chi/chi/v5"
"task-dashboard/internal/auth"
"task-dashboard/internal/models"
)
// HandleTabShopping renders the Shopping tab (PlanToEat + user-added items)
func (h *Handler) HandleTabShopping(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
stores := h.aggregateShoppingLists(ctx)
grouped := r.URL.Query().Get("grouped") != "false" // Default to grouped
HTMLResponse(w, h.renderer, "shopping-tab", struct {
Stores []models.ShoppingStore
Grouped bool
}{stores, grouped})
}
// HandleShoppingQuickAdd adds a user shopping item
func (h *Handler) HandleShoppingQuickAdd(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
JSONError(w, http.StatusBadRequest, "Failed to parse form", err)
return
}
name := strings.TrimSpace(r.FormValue("name"))
storeName := strings.TrimSpace(r.FormValue("store"))
mode := r.FormValue("mode") // "shopping-mode" if from shopping mode page
if name == "" {
JSONError(w, http.StatusBadRequest, "Name is required", nil)
return
}
if storeName == "" {
JSONError(w, http.StatusBadRequest, "Store is required", nil)
return
}
if err := h.store.SaveUserShoppingItem(name, storeName); err != nil {
JSONError(w, http.StatusInternalServerError, "Failed to save item", err)
return
}
ctx := r.Context()
allStores := h.aggregateShoppingLists(ctx)
// If called from shopping mode, return just the items for that store
if mode == "shopping-mode" {
items := models.FlattenItemsForStore(allStores, storeName)
HTMLResponse(w, h.renderer, "shopping-mode-items", struct {
StoreName string
Items []models.UnifiedShoppingItem
}{storeName, items})
return
}
// Return just the items content (not the entire tab) to preserve scroll position
grouped := r.FormValue("grouped") != "false"
HTMLResponse(w, h.renderer, "shopping-items-content", struct {
Stores []models.ShoppingStore
Grouped bool
}{allStores, grouped})
}
// HandleShoppingMode renders the focused shopping mode for a single store
func (h *Handler) HandleShoppingMode(w http.ResponseWriter, r *http.Request) {
storeName := chi.URLParam(r, "store")
if storeName == "" {
http.Redirect(w, r, "/?tab=shopping", http.StatusFound)
return
}
// URL decode the store name
storeName, _ = url.QueryUnescape(storeName)
ctx := r.Context()
allStores := h.aggregateShoppingLists(ctx)
data := struct {
StoreName string
Items []models.UnifiedShoppingItem
StoreNames []string
CSRFToken string
}{
StoreName: storeName,
Items: models.FlattenItemsForStore(allStores, storeName),
StoreNames: models.StoreNames(allStores),
CSRFToken: auth.GetCSRFTokenFromContext(ctx),
}
HTMLResponse(w, h.renderer, "shopping-mode.html", data)
}
// HandleShoppingModeComplete removes an item from the shopping list
func (h *Handler) HandleShoppingModeComplete(w http.ResponseWriter, r *http.Request) {
storeName := chi.URLParam(r, "store")
if err := r.ParseForm(); err != nil {
JSONError(w, http.StatusBadRequest, "Failed to parse form", err)
return
}
id := r.FormValue("id")
source := r.FormValue("source")
// Complete (remove) the item
switch source {
case "user":
var userID int64
if _, err := fmt.Sscanf(id, "user-%d", &userID); err != nil {
JSONError(w, http.StatusBadRequest, "Invalid user item ID", err)
return
}
if err := h.store.DeleteUserShoppingItem(userID); err != nil {
JSONError(w, http.StatusInternalServerError, "Failed to delete item", err)
return
}
case "plantoeat":
// Mark as checked (will be filtered out of view)
if err := h.store.SetShoppingItemChecked(source, id, true); err != nil {
JSONError(w, http.StatusInternalServerError, "Failed to complete item", err)
return
}
}
// URL decode the store name
storeName, _ = url.QueryUnescape(storeName)
// Return updated item list partial
ctx := r.Context()
allStores := h.aggregateShoppingLists(ctx)
var items []models.UnifiedShoppingItem
for _, store := range allStores {
if strings.EqualFold(store.Name, storeName) {
for _, cat := range store.Categories {
items = append(items, cat.Items...)
}
}
}
// Sort alphabetically (checked items already filtered in template)
sort.Slice(items, func(i, j int) bool {
return items[i].Name < items[j].Name
})
HTMLResponse(w, h.renderer, "shopping-mode-items", struct {
StoreName string
Items []models.UnifiedShoppingItem
}{storeName, items})
}
// HandleGetShoppingStores returns the current store names as `,
template.HTMLEscapeString(s.Name),
template.HTMLEscapeString(s.Name))
}
}
// aggregateShoppingLists combines PlanToEat and user shopping items by store
func (h *Handler) aggregateShoppingLists(ctx context.Context) []models.ShoppingStore {
storeMap := make(map[string]map[string][]models.UnifiedShoppingItem)
// Fetch locally stored checked states for the remaining external source.
// Trello is no longer a shopping source: its items were read-only here and
// its list names were doubling as an accidental store registry. See
// migration 032 for the one-time import that preceded removing it.
plantoeatChecks, _ := h.store.GetShoppingItemChecks("plantoeat")
// 1. Fetch PlanToEat shopping list
if h.planToEatClient != nil {
items, err := h.planToEatClient.GetShoppingList(ctx)
if err != nil {
log.Printf("ERROR [Shopping/PlanToEat]: %v", err)
} else {
log.Printf("DEBUG [Shopping/PlanToEat]: Found %d items", len(items))
for _, item := range items {
storeName := item.Store
if storeName == "" {
storeName = "PlanToEat"
}
if storeMap[storeName] == nil {
storeMap[storeName] = make(map[string][]models.UnifiedShoppingItem)
}
// Use locally stored check state if available, otherwise use scraped state
checked := item.Checked
if localChecked, ok := plantoeatChecks[item.ID]; ok {
checked = localChecked
}
unified := models.UnifiedShoppingItem{
ID: item.ID,
Name: item.Name,
Quantity: item.Quantity,
Category: item.Category,
Store: storeName,
Source: "plantoeat",
Checked: checked,
}
storeMap[storeName][item.Category] = append(storeMap[storeName][item.Category], unified)
}
}
} else {
log.Printf("DEBUG [Shopping/PlanToEat]: Client not configured")
}
// 2. Fetch user-added shopping items
userItems, err := h.store.GetUserShoppingItems()
if err != nil {
log.Printf("ERROR [Shopping/User]: %v", err)
} else {
for _, item := range userItems {
storeName := item.Store
if storeName == "" {
continue // Skip items without a store
}
if storeMap[storeName] == nil {
storeMap[storeName] = make(map[string][]models.UnifiedShoppingItem)
}
unified := models.UnifiedShoppingItem{
ID: fmt.Sprintf("user-%d", item.ID),
Name: item.Name,
Store: storeName,
Source: "user",
Checked: item.Checked,
}
storeMap[storeName][""] = append(storeMap[storeName][""], unified)
}
}
// 3. Convert map to sorted slice
var stores []models.ShoppingStore
for storeName, categories := range storeMap {
store := models.ShoppingStore{Name: storeName}
// Get sorted category names
var catNames []string
for catName := range categories {
catNames = append(catNames, catName)
}
sort.Strings(catNames)
for _, catName := range catNames {
items := categories[catName]
sort.Slice(items, func(i, j int) bool {
return items[i].Name < items[j].Name
})
store.Categories = append(store.Categories, models.ShoppingCategory{
Name: catName,
Items: items,
})
}
stores = append(stores, store)
}
// Sort stores alphabetically
sort.Slice(stores, func(i, j int) bool {
return stores[i].Name < stores[j].Name
})
return stores
}