honeyDueAPI/internal/handlers/static_data_handler.go

package handlers

import (
	"net/http"
	"strings"

	"github.com/labstack/echo/v4"
	"github.com/redis/go-redis/v9"
	"github.com/rs/zerolog/log"

	"github.com/treytartt/honeydue-api/internal/dto/responses"
	"github.com/treytartt/honeydue-api/internal/i18n"
	"github.com/treytartt/honeydue-api/internal/services"
)

// SeededDataResponse represents the unified seeded data response
type SeededDataResponse struct {
	ResidenceTypes        interface{}                             `json:"residence_types"`
	TaskCategories        interface{}                             `json:"task_categories"`
	TaskPriorities        interface{}                             `json:"task_priorities"`
	TaskFrequencies       interface{}                             `json:"task_frequencies"`
	ContractorSpecialties interface{}                             `json:"contractor_specialties"`
	TaskTemplates         responses.TaskTemplatesGroupedResponse  `json:"task_templates"`
	HomeProfileOptions    map[string][]services.HomeProfileOption `json:"home_profile_options"`
	DocumentTypes         []services.HomeProfileOption            `json:"document_types"`
	DocumentCategories    []services.HomeProfileOption            `json:"document_categories"`
}

// StaticDataHandler handles static/lookup data endpoints
type StaticDataHandler struct {
	residenceService    *services.ResidenceService
	taskService         *services.TaskService
	contractorService   *services.ContractorService
	taskTemplateService *services.TaskTemplateService
	cache               *services.CacheService
}

// NewStaticDataHandler creates a new static data handler
func NewStaticDataHandler(
	residenceService *services.ResidenceService,
	taskService *services.TaskService,
	contractorService *services.ContractorService,
	taskTemplateService *services.TaskTemplateService,
	cache *services.CacheService,
) *StaticDataHandler {
	return &StaticDataHandler{
		residenceService:    residenceService,
		taskService:         taskService,
		contractorService:   contractorService,
		taskTemplateService: taskTemplateService,
		cache:               cache,
	}
}

// GetStaticData handles GET /api/static_data/
// Returns all lookup/reference data in a single response with ETag support
func (h *StaticDataHandler) GetStaticData(c echo.Context) error {
	ctx := c.Request().Context()

	// Lookup display labels and home-profile options are localized for the
	// request's language, so the cache + ETag are keyed by locale.
	locale := i18n.GetLocale(c)
	localizer := i18n.GetLocalizer(c)

	// Check If-None-Match header for conditional request
	// Strip W/ prefix if present (added by reverse proxy, but we store without it)
	clientETag := strings.TrimPrefix(c.Request().Header.Get("If-None-Match"), "W/")

	// Try to get cached ETag first (fast path for 304 responses)
	if h.cache != nil && clientETag != "" {
		cachedETag, err := h.cache.GetSeededDataETag(ctx, locale)
		if err == nil && cachedETag == clientETag {
			// Client has the latest data, return 304 Not Modified
			return c.NoContent(http.StatusNotModified)
		}
	}

	// Try to get cached seeded data
	if h.cache != nil {
		var cachedData SeededDataResponse
		err := h.cache.GetCachedSeededData(ctx, locale, &cachedData)
		if err == nil {
			// Cache hit - get the ETag and return data
			etag, etagErr := h.cache.GetSeededDataETag(ctx, locale)
			if etagErr == nil {
				c.Response().Header().Set("ETag", etag)
				c.Response().Header().Set("Cache-Control", "private, max-age=3600")
			}
			return c.JSON(http.StatusOK, cachedData)
		} else if err != redis.Nil {
			// Log cache error but continue to fetch from DB
			log.Warn().Err(err).Msg("Failed to get cached seeded data")
		}
	}

	// Cache miss - fetch all data from services
	residenceTypes, err := h.residenceService.GetResidenceTypes(c.Request().Context())
	if err != nil {
		return err
	}

	taskCategories, err := h.taskService.GetCategories(c.Request().Context())
	if err != nil {
		return err
	}

	taskPriorities, err := h.taskService.GetPriorities(c.Request().Context())
	if err != nil {
		return err
	}

	taskFrequencies, err := h.taskService.GetFrequencies(c.Request().Context())
	if err != nil {
		return err
	}

	contractorSpecialties, err := h.contractorService.GetSpecialties(c.Request().Context())
	if err != nil {
		return err
	}

	taskTemplates, err := h.taskTemplateService.GetGrouped()
	if err != nil {
		return err
	}

	// Localize the lookup display_name fields in place for this request's locale.
	services.LocalizeLookups(localizer, residenceTypes, taskCategories, taskPriorities, taskFrequencies, contractorSpecialties)

	// Build response
	seededData := SeededDataResponse{
		ResidenceTypes:        residenceTypes,
		TaskCategories:        taskCategories,
		TaskPriorities:        taskPriorities,
		TaskFrequencies:       taskFrequencies,
		ContractorSpecialties: contractorSpecialties,
		TaskTemplates:         taskTemplates,
		HomeProfileOptions:    services.BuildHomeProfileOptions(localizer),
		DocumentTypes:         services.BuildDocumentTypes(localizer),
		DocumentCategories:    services.BuildDocumentCategories(localizer),
	}

	// Cache the data and get ETag (per-locale)
	if h.cache != nil {
		etag, cacheErr := h.cache.CacheSeededData(ctx, locale, seededData)
		if cacheErr != nil {
			log.Warn().Err(cacheErr).Msg("Failed to cache seeded data")
		} else {
			c.Response().Header().Set("ETag", etag)
			c.Response().Header().Set("Cache-Control", "private, max-age=3600")
		}
	}

	return c.JSON(http.StatusOK, seededData)
}

// RefreshStaticData handles POST /api/static_data/refresh/
// This is a no-op since data is fetched fresh each time
// Kept for API compatibility with mobile clients
func (h *StaticDataHandler) RefreshStaticData(c echo.Context) error {
	return c.JSON(http.StatusOK, map[string]interface{}{
		"message": i18n.LocalizedMessage(c, "message.static_data_refreshed"),
		"status":  "success",
	})
}