path: root/internal/handlers/shopping.go

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 <option> elements
// for the quick-action modal's store picker.
//
// This replaces the Trello-lists endpoint the modal used to call. Note the
// store names come from the items themselves — there is no separate store
// registry yet, so a store with nothing in it does not appear here.
func (h *Handler) HandleGetShoppingStores(w http.ResponseWriter, r *http.Request) {
	stores := h.aggregateShoppingLists(r.Context())

	w.Header().Set("Content-Type", "text/html")
	for _, s := range stores {
		_, _ = fmt.Fprintf(w, `<option value="%s">%s</option>`,
			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,
				Category: item.Section,
				Store:    storeName,
				Source:   "user",
				Checked:  item.Checked,
			}
			storeMap[storeName][item.Section] = append(storeMap[storeName][item.Section], unified)
		}
	}

	// 3. Every registered store appears even when empty. Without this you
	// cannot move an item into a store that has nothing in it yet, and moving
	// the last item out of a store makes it vanish mid-edit.
	registered, err := h.store.GetShoppingStores()
	if err != nil {
		log.Printf("ERROR [Shopping/Stores]: %v", err)
	} else {
		for _, st := range registered {
			if storeMap[st.Name] == nil {
				storeMap[st.Name] = make(map[string][]models.UnifiedShoppingItem)
			}
			// Likewise for sections: an empty section still needs to be a
			// destination in the edit form.
			for _, sec := range st.Sections {
				if _, ok := storeMap[st.Name][sec.Name]; !ok {
					storeMap[st.Name][sec.Name] = nil
				}
			}
		}
	}

	// 4. 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
}