memby/server/internal/api/hero_admin.go

package api

import (
	"context"
	"encoding/json"
	"net/http"
	"strings"

	"github.com/ponzischeme89/memby/server/internal/store"
)

type heroAdminItem struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	Type string `json:"type"`
	Year int    `json:"year,omitempty"`
}

type heroAdminPolicy struct {
	PinnedItems   []heroAdminItem               `json:"pinnedItems"`
	Items         []heroAdminItem               `json:"items"`
	PrimeSubtitle string                        `json:"primeSubtitle"`
	Placements    map[string]heroAdminPlacement `json:"placements"`
	Schedules     []store.HeroSchedule          `json:"schedules"`
}

type heroAdminPlacement struct {
	PinnedItems   []heroAdminItem `json:"pinnedItems"`
	PrimeSubtitle string          `json:"primeSubtitle"`
}

func adminHeroItem(raw json.RawMessage) (heroAdminItem, bool) {
	fact, ok := heroFactsOf(raw)
	if !ok || !fact.Playable ||
		(!strings.EqualFold(fact.Type, "Movie") && !strings.EqualFold(fact.Type, "Series")) {
		return heroAdminItem{}, false
	}
	return heroAdminItem{ID: fact.ID, Name: fact.Name, Type: fact.Type, Year: heroYearOf(fact)}, true
}

func (s *Server) heroAdminPolicy(ctx context.Context) heroAdminPolicy {
	policy, err := s.store.HeroPolicy(ctx)
	if err != nil {
		s.loggerFor(ctx).Warn("hero policy unavailable to admin", "error", err)
		return heroAdminPolicy{PinnedItems: []heroAdminItem{}, Placements: map[string]heroAdminPlacement{}}
	}
	allIDs := []string{}
	for _, placement := range policy.Placements {
		allIDs = append(allIDs, placement.PinnedItemIDs...)
	}
	for _, schedule := range policy.Schedules {
		allIDs = append(allIDs, schedule.ItemID)
	}
	allIDs = uniqueHeroIDs(allIDs)
	items, err := s.store.LibraryItemsByID(ctx, allIDs)
	if err != nil {
		s.loggerFor(ctx).Warn("pinned hero titles unavailable to admin", "error", err)
		return heroAdminPolicy{PinnedItems: []heroAdminItem{}, Placements: map[string]heroAdminPlacement{}}
	}
	byID := make(map[string]heroAdminItem, len(items))
	for _, raw := range items {
		if item, ok := adminHeroItem(raw); ok {
			byID[item.ID] = item
		}
	}
	out := heroAdminPolicy{
		Placements: make(map[string]heroAdminPlacement, len(policy.Placements)),
		Items:      []heroAdminItem{},
		Schedules:  policy.Schedules,
	}
	for _, id := range allIDs {
		if item, ok := byID[id]; ok {
			out.Items = append(out.Items, item)
		}
	}
	for name, placement := range policy.Placements {
		adminPlacement := heroAdminPlacement{PinnedItems: []heroAdminItem{}, PrimeSubtitle: placement.PrimeSubtitle}
		for _, id := range placement.PinnedItemIDs {
			if item, ok := byID[id]; ok {
				adminPlacement.PinnedItems = append(adminPlacement.PinnedItems, item)
			}
		}
		out.Placements[name] = adminPlacement
	}
	home := out.Placements[store.HeroPlacementHome]
	out.PinnedItems, out.PrimeSubtitle = home.PinnedItems, home.PrimeSubtitle
	return out
}

func (s *Server) handleAdminHeroSearch(w http.ResponseWriter, r *http.Request) {
	items, err := s.store.SearchLibrary(r.Context(), r.URL.Query().Get("q"), 20)
	if err != nil {
		s.loggerFor(r.Context()).Error("hero library search failed", "error", err)
		writeError(w, http.StatusInternalServerError, "could not search the library")
		return
	}
	results := make([]heroAdminItem, 0, len(items))
	for _, raw := range items {
		if item, ok := adminHeroItem(raw); ok {
			results = append(results, item)
		}
	}
	writeJSON(w, http.StatusOK, map[string]any{"items": results})
}

func (s *Server) handleAdminHeroPolicy(w http.ResponseWriter, r *http.Request) {
	var request struct {
		PinnedItemIDs []string `json:"pinnedItemIds"`
		PrimeSubtitle string   `json:"primeSubtitle"`
		Placements    map[string]struct {
			PinnedItemIDs []string `json:"pinnedItemIds"`
			PrimeSubtitle string   `json:"primeSubtitle"`
		} `json:"placements"`
		Schedules []store.HeroSchedule `json:"schedules"`
	}
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
		writeError(w, http.StatusBadRequest, "invalid hero policy")
		return
	}
	if request.Placements == nil {
		request.Placements = map[string]struct {
			PinnedItemIDs []string `json:"pinnedItemIds"`
			PrimeSubtitle string   `json:"primeSubtitle"`
		}{
			store.HeroPlacementHome: {PinnedItemIDs: request.PinnedItemIDs, PrimeSubtitle: request.PrimeSubtitle},
		}
	}
	allIDs := []string{}
	placementPolicies := map[string]store.HeroPlacementPolicy{}
	for name, placement := range request.Placements {
		if !store.ValidHeroPlacement(name) {
			writeError(w, http.StatusBadRequest, "unknown hero placement")
			return
		}
		ids := uniqueHeroIDs(placement.PinnedItemIDs)
		if len(ids) > 4 {
			writeError(w, http.StatusBadRequest, "each hero can pin at most four titles")
			return
		}
		placementPolicies[name] = store.HeroPlacementPolicy{PinnedItemIDs: ids, PrimeSubtitle: placement.PrimeSubtitle}
		allIDs = append(allIDs, ids...)
	}
	for _, schedule := range request.Schedules {
		allIDs = append(allIDs, schedule.ItemID)
	}
	items, err := s.store.LibraryItemsByID(r.Context(), uniqueHeroIDs(allIDs))
	if err != nil {
		s.loggerFor(r.Context()).Error("hero title validation failed", "error", err)
		writeError(w, http.StatusInternalServerError, "could not validate hero titles")
		return
	}
	valid := map[string]heroAdminItem{}
	for _, raw := range items {
		if item, ok := adminHeroItem(raw); ok {
			valid[item.ID] = item
		}
	}
	for name, placement := range placementPolicies {
		for _, id := range placement.PinnedItemIDs {
			item, ok := valid[id]
			if !ok || (name == store.HeroPlacementMovies && !strings.EqualFold(item.Type, "Movie")) || (name == store.HeroPlacementTVShows && !strings.EqualFold(item.Type, "Series")) {
				writeError(w, http.StatusBadRequest, "every pinned item must match its hero placement")
				return
			}
		}
	}
	for _, schedule := range request.Schedules {
		item, ok := valid[strings.TrimSpace(schedule.ItemID)]
		if !ok {
			writeError(w, http.StatusBadRequest, "every scheduled hero must be a playable library film or series")
			return
		}
		placements := schedule.Placements
		if len(placements) == 0 {
			placements = []string{store.HeroPlacementHome}
		}
		for _, name := range placements {
			if !store.ValidHeroPlacement(name) ||
				(name == store.HeroPlacementMovies && !strings.EqualFold(item.Type, "Movie")) ||
				(name == store.HeroPlacementTVShows && !strings.EqualFold(item.Type, "Series")) {
				writeError(w, http.StatusBadRequest, "every scheduled item must match its hero placement")
				return
			}
		}
	}
	policy := store.HeroPolicy{Placements: placementPolicies, Schedules: request.Schedules}
	if err := s.store.SetHeroPolicy(r.Context(), policy); err != nil {
		s.loggerFor(r.Context()).Error("hero policy write failed", "error", err)
		writeError(w, http.StatusInternalServerError, "could not save hero policy")
		return
	}
	s.invalidateAllHomeCaches(r.Context())
	writeJSON(w, http.StatusOK, map[string]any{"saved": true})
}

func uniqueHeroIDs(ids []string) []string {
	seen := map[string]bool{}
	out := make([]string, 0, len(ids))
	for _, id := range ids {
		id = strings.TrimSpace(id)
		if id == "" || seen[id] {
			continue
		}
		seen[id] = true
		out = append(out, id)
	}
	return out
}

func (s *Server) invalidateAllHomeCaches(ctx context.Context) {
	users, err := s.store.KnownUsers(ctx)
	if err != nil {
		s.loggerFor(ctx).Warn("hero cache invalidation could not list users", "error", err)
		return
	}
	for _, user := range users {
		if err := s.cache.InvalidateUser(ctx, user.ID); err != nil {
			s.loggerFor(ctx).Warn("hero cache invalidation failed", "user", user.ID, "error", err)
		}
	}
}