bookhoard/internal/router/podcast_page.go

package router

// Podcast SSR pages (plan task 1.9): /podcasts (subscriptions grid +
// add-feed wizard) and /podcasts/:id (feed detail with the inline
// download lifecycle). Rendering ownership: ALL content is
// templ-rendered server data; htmx swaps partials; the sanctioned JS is
// the modal toggle + event delegation in web/src/podcasts.ts.

import (
	"bookhoard/internal/database"
	"bookhoard/internal/handlers"
	"bookhoard/internal/services"
	"bookhoard/internal/utils"
	"bookhoard/templates"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"sort"
	"strings"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
	"github.com/labstack/echo/v5"
)

func registerPodcastPages(cfg *Config) {
	pages := cfg.Echo.Group("", createJWTMiddleware(cfg))

	pages.GET("/podcasts", func(c *echo.Context) error {
		user, err := getTemplateUserWithTheme(c, cfg)
		if err != nil {
			return renderErrorPage(c, "Error loading user", "user_load_error")
		}
		data, err := buildPodcastsPageData(c, cfg)
		if err != nil {
			data = &templates.PodcastsPageData{ErrorMsg: "Could not load subscriptions"}
		}
		var buf bytes.Buffer
		if err := templates.PodcastsPage(user, *data, "/podcasts").Render(c.Request().Context(), &buf); err != nil {
			return err
		}
		return c.HTML(http.StatusOK, buf.String())
	})

	pages.GET("/podcasts/:id", func(c *echo.Context) error {
		user, err := getTemplateUserWithTheme(c, cfg)
		if err != nil {
			return renderErrorPage(c, "Error loading user", "user_load_error")
		}
		fid, ferr := parsePodcastUUID(c.Param("id"))
		if ferr != nil {
			return c.NoContent(http.StatusNotFound)
		}
		data, err := buildPodcastDetailData(c, cfg, user, fid)
		if err != nil {
			var buf bytes.Buffer
			_ = templates.ErrorPage("Feed not found", "not_found").Render(c.Request().Context(), &buf)
			return c.HTML(http.StatusNotFound, buf.String())
		}
		var buf bytes.Buffer
		if err := templates.PodcastDetailPage(user, *data).Render(c.Request().Context(), &buf); err != nil {
			return err
		}
		return c.HTML(http.StatusOK, buf.String())
	})

	// Episode list partial — the htmx refresh unit (poll while
	// downloads are active; podcast:changed events swap it too).
	pages.GET("/podcasts/:id/episodes", func(c *echo.Context) error {
		user, err := getTemplateUserWithTheme(c, cfg)
		if err != nil {
			return renderErrorPage(c, "Error loading user", "user_load_error")
		}
		fid, ferr := parsePodcastUUID(c.Param("id"))
		if ferr != nil {
			return c.NoContent(http.StatusNotFound)
		}
		data, err := buildPodcastDetailData(c, cfg, user, fid)
		if err != nil {
			return c.NoContent(http.StatusNotFound)
		}
		var buf bytes.Buffer
		if templates.HasActiveDownloads(data.Episodes) {
			err = templates.PodcastEpisodeListPolling(*data).Render(c.Request().Context(), &buf)
		} else {
			err = templates.PodcastEpisodeList(*data).Render(c.Request().Context(), &buf)
		}
		if err != nil {
			return err
		}
		return c.HTML(http.StatusOK, buf.String())
	})
}

// buildPodcastsPageData assembles the /podcasts page: subscription
// cards, facet values, server-side filters (q/host/tag/language).
func buildPodcastsPageData(c *echo.Context, cfg *Config) (*templates.PodcastsPageData, error) {
	user := handlers.MustGetAuthenticatedUser(c)
	ctx := c.Request().Context()

	libs, err := cfg.Queries.GetPodcastsLibraryForUser(ctx, user.ID)
	data := &templates.PodcastsPageData{HasLibrary: len(libs) > 0}
	if err != nil || len(libs) == 0 {
		return data, err
	}
	for _, lib := range libs {
		data.Libraries = append(data.Libraries, templates.LibraryData{
			ID:       uuid.UUID(lib.ID.Bytes).String(),
			Name:     lib.Name,
			TypeName: "podcasts",
		})
	}

	feeds, err := cfg.Queries.ListMyPodcastFeeds(ctx, user.ID)
	if err != nil {
		return data, err
	}
	// Continue aggregation (plan 2.5): first in-progress episode per
	// feed (the query is already most-recent-first).
	continueByFeed := make(map[string]*database.GetPodcastContinueForUserRow)
	if continueRows, err := cfg.Queries.GetPodcastContinueForUser(ctx, user.ID); err == nil {
		for i := range continueRows {
			row := &continueRows[i]
			key := uuid.UUID(row.SourceFeedID.Bytes).String()
			if _, ok := continueByFeed[key]; !ok {
				continueByFeed[key] = row
			}
		}
	}
	for i := range feeds {
		row := &feeds[i]
		total, _ := cfg.Queries.CountPodcastEpisodesForFeed(ctx, row.ID)
		downloaded, _ := cfg.Queries.CountDownloadedEpisodes(ctx, row.ID)
		data.Feeds = append(data.Feeds, templates.PodcastFeedCard{
			ID:                uuid.UUID(row.ID.Bytes).String(),
			LibraryID:         uuid.UUID(row.LibraryID.Bytes).String(),
			Title:             row.Title,
			DisplayName:       row.DisplayName.String,
			Description:       firstLine(row.Description.String, 220),
			Host:              row.Host.String,
			Publisher:         row.Publisher.String,
			Language:          row.Language.String,
			Tags:              row.Tags,
			Explicit:          row.Explicit,
			ArtworkPath:       row.ArtworkPath.String,
			FeedType:          row.FeedType.String,
			Medium:            row.Medium.String,
			IsComplete:        row.IsComplete,
			FeedURL:           row.FeedUrl,
			LastFetched:       pgTimeDisplay(row.LastFetchedAt, utils.PgTextString(user.Timezone)),
			SubscribedAt:      pgTimeDisplay(row.SubscribedAt, utils.PgTextString(user.Timezone)),
			EpisodeTotal:      int(total),
			DownloadedN:       int(downloaded),
			UndownloadedN:     int(total) - int(downloaded),
			NewEpisodes:       total-downloaded > 0,
			AutoDownload:      row.AutoDownload,
			AutoDownloadCount: int(row.AutoDownloadCount.Int32),
			Subscribed:        true,
		})
		if cont := continueByFeed[uuid.UUID(row.ID.Bytes).String()]; cont != nil {
			card := &data.Feeds[len(data.Feeds)-1]
			card.HasContinue = true
			card.ContinueTitle = cont.Title
			card.ContinueEpisode = int(cont.FeedPosition.Int32)
			card.ContinuePercent = cont.Percentage.Float64
			card.ContinueLastRead = cont.LastReadAt.Time
		}
	}

	// Facet values from the unfiltered subscription list (D18).
	allData := *data
	data.Facets = facetValuesFromCards(allData.Feeds)

	// Server-side filters.
	q := strings.ToLower(strings.TrimSpace(c.QueryParam("q")))
	host := c.QueryParam("host")
	tag := c.QueryParam("tag")
	lang := c.QueryParam("language")

	// Episode-level matches (issue #8 / D14): a query also hits episode
	// titles + descriptions — the feed surfaces with a match count.
	// SearchMyPodcastEpisodes is subscription-scoped via RLS (the
	// caller's identity). Only consult it when a query is present.
	matchesByFeed := make(map[string]int)
	if q != "" {
		if eps, err := cfg.Queries.SearchMyPodcastEpisodes(ctx, q); err == nil {
			for i := range eps {
				key := uuid.UUID(eps[i].SourceFeedID.Bytes).String()
				matchesByFeed[key]++
			}
		}
	}

	filtered := data.Feeds[:0:0]
	for _, f := range data.Feeds {
		if q != "" {
			hay := strings.ToLower(f.Title + " " + f.DisplayName + " " + f.Host + " " + f.Publisher + " " + f.Description)
			matched := matchesByFeed[f.ID]
			if !strings.Contains(hay, q) && matched == 0 {
				continue
			}
		}
		if host != "" && f.Host != host {
			continue
		}
		if lang != "" && !strings.EqualFold(f.Language, lang) {
			continue
		}
		if tag != "" {
			found := false
			for _, t := range f.Tags {
				if strings.EqualFold(t, tag) {
					found = true
					break
				}
			}
			if !found {
				continue
			}
		}
		filtered = append(filtered, f)
	}
	if q != "" {
		for i := range filtered {
			filtered[i].EpisodeMatches = matchesByFeed[filtered[i].ID]
		}
	}
	data.Feeds = filtered
	data.Query = q
	data.ContinueFeeds = templates.PodcastContinueFeeds(data.Feeds)
	return data, nil
}

// buildPodcastDetailData assembles the feed-detail page + episode list
// partial. RLS scopes the lookup (non-subscribers get sqlc.ErrNoRows →
// 404 semantics — no Go visibility plumbing, D20).
func buildPodcastDetailData(c *echo.Context, cfg *Config, user templates.User, feedID pgtype.UUID) (*templates.PodcastDetailData, error) {
	actor := handlers.MustGetAuthenticatedUser(c)
	ctx := c.Request().Context()

	feed, err := cfg.Queries.GetPodcastFeed(ctx, feedID)
	if err != nil {
		return nil, err
	}
	sub, _ := cfg.Queries.GetPodcastSubscription(ctx, database.GetPodcastSubscriptionParams{
		UserID: actor.ID, FeedID: feedID,
	})
	eps, err := cfg.Queries.ListPodcastEpisodes(ctx, feedID)
	if err != nil {
		return nil, err
	}
	progressRows, _ := cfg.Queries.GetPodcastEpisodeProgress(ctx, database.GetPodcastEpisodeProgressParams{
		UserID: actor.ID, SourceFeedID: feedID,
	})
	progressByItem := make(map[string]struct {
		Pct      float64
		LastRead pgtype.Timestamptz
	}, len(progressRows))
	for _, p := range progressRows {
		progressByItem[uuid.UUID(p.MediaItemID.Bytes).String()] = struct {
			Pct      float64
			LastRead pgtype.Timestamptz
		}{p.Percentage.Float64, p.LastReadAt}
	}

	total, _ := cfg.Queries.CountPodcastEpisodesForFeed(ctx, feedID)
	downloaded, _ := cfg.Queries.CountDownloadedEpisodes(ctx, feedID)
	subscriberCount, _ := cfg.Queries.CountPodcastFeedSubscribers(ctx, feedID)

	card := templates.PodcastFeedCard{
		ID:                uuid.UUID(feed.ID.Bytes).String(),
		LibraryID:         uuid.UUID(feed.LibraryID.Bytes).String(),
		Title:             feed.Title,
		DisplayName:       sub.DisplayName.String,
		Description:       feed.Description.String,
		Host:              feed.Host.String,
		Publisher:         feed.Publisher.String,
		Language:          feed.Language.String,
		Tags:              feed.Tags,
		Explicit:          feed.Explicit,
		ArtworkPath:       feed.ArtworkPath.String,
		FeedType:          feed.FeedType.String,
		Medium:            feed.Medium.String,
		IsComplete:        feed.IsComplete,
		FeedURL:           feed.FeedUrl,
		LastFetched:       pgTimeDisplay(feed.LastFetchedAt, user.Timezone),
		EpisodeTotal:      int(total),
		DownloadedN:       int(downloaded),
		UndownloadedN:     int(total) - int(downloaded),
		NewEpisodes:       total-downloaded > 0,
		AutoDownload:      sub.AutoDownload,
		AutoDownloadCount: int(sub.AutoDownloadCount.Int32),
		Subscribed:        sub.ID.Valid,
	}

	rows := make([]templates.PodcastEpisodeRow, 0, len(eps))
	gaps := 0
	seenDownloadedFrom := false // walk reversed: gap = undownloaded with a downloaded LATER in order
	for i := len(eps) - 1; i >= 0; i-- {
		ep := &eps[i]
		downloadedEp := ep.DownloadState == "downloaded"
		if !downloadedEp && seenDownloadedFrom {
			gaps++
		}
		if downloadedEp {
			seenDownloadedFrom = true
		}
	}
	// Forward pass for the actual rows (native order — the list keeps
	// feed order; the ORDER selector drives the sequence endpoint, and
	// the order control re-renders this list via the override applied
	// below).
	order := podcastOrderForFeed(cfg, c, feedID.String())
	for i := range eps {
		ep := &eps[i]
		rowID := uuid.UUID(ep.ID.Bytes).String()
		p := progressByItem[rowID]
		dateDisplay := ""
		dateSort := ""
		if ep.DatePublished.Valid {
			dateSort = ep.DatePublished.Time.Format("2006-01-02")
			dateDisplay = ep.DatePublished.Time.In(utils.UserLocation(user.Timezone)).Format("Jan 2, 2006")
		}
		rows = append(rows, templates.PodcastEpisodeRow{
			ID:            uuid.UUID(ep.ID.Bytes).String(),
			FeedID:        uuid.UUID(ep.SourceFeedID.Bytes).String(),
			Title:         ep.Title,
			Description:   firstLine(ep.Description.String, 200),
			Date:          dateDisplay,
			SortDate:      dateSort,
			Position:      int(ep.FeedPosition.Int32),
			Duration:      templates.FormatEpisodeDuration(int(ep.DeclaredDurationSeconds.Int32)),
			Size:          templates.FormatEpisodeSize(ep.FileSize.Int64),
			PlayURL:       "/readers/" + uuid.UUID(ep.ID.Bytes).String(),
			ListenPct:     p.Pct,
			Downloaded:    ep.DownloadState == "downloaded",
			DownloadState: ep.DownloadState,
			DownloadError: ep.DownloadError.String,
		})
	}
	// Order override reshapes the LIST too (the sequence endpoint is the
	// strict downloaded-only view; the list shows everything in the
	// chosen order so pending episodes stay visible). Consolidated sort
	// (§0 item 5a) — SortDate is the lexical pub-date key so the
	// tiebreak is chronological even in display-tz date strings.
	services.OrderEpisodes(rows, order,
		func(r templates.PodcastEpisodeRow) int32 { return int32(r.Position) },
		func(r templates.PodcastEpisodeRow) string { return r.SortDate },
	)

	detail := &templates.PodcastDetailData{
		Feed:            card,
		Episodes:        rows,
		GapCount:        gaps,
		Order:           order,
		IsAdmin:         actor.Role == "admin",
		IsSerial:        feed.FeedType.String == "serial" || feed.Medium.String == "audiobook",
		SubscriberCount: int(subscriberCount),
	}

	// Live byte progress for in-flight downloads (issue #1): read the
	// worker's snapshot; rows not actively downloading render states.
	if cfg.PodcastWorker != nil {
		for i := range detail.Episodes {
			row := &detail.Episodes[i]
			if row.DownloadState != "downloading" {
				continue
			}
			if recv, tot, ok := cfg.PodcastWorker.EpisodeProgress(pgtype.UUID{Bytes: uuid.MustParse(row.ID), Valid: true}); ok {
				row.ProgressKnown = true
				row.ProgressReceived = recv
				row.ProgressTotal = tot
				if tot > 0 {
					row.ProgressPct = float64(recv) / float64(tot) * 100
				}
			}
		}
	}
	return detail, nil
}

// podcastOrderForFeed reads the caller's order override (D5).
func podcastOrderForFeed(cfg *Config, c *echo.Context, feedID string) string {
	user := handlers.MustGetAuthenticatedUser(c)
	row, err := cfg.Queries.GetUserSettingByKey(c.Request().Context(), database.GetUserSettingByKeyParams{
		UserID:     user.ID,
		SettingKey: "podcast_order:" + feedID,
	})
	if err != nil {
		return "native"
	}
	var v struct {
		Order string `json:"order"`
	}
	if err := json.Unmarshal(row, &v); err != nil {
		return "native"
	}
	if !services.ValidPodcastEpisodeOrder(v.Order) {
		return "native"
	}
	return v.Order
}

// facetValuesFromCards derives the filter bar values.
// facetValuesFromCards derives the filter-bar values with feed counts,
// sorted by frequency DESC then alphabetically — the top of each group
// is what a user with hundreds of feeds actually filters by.
func facetValuesFromCards(feeds []templates.PodcastFeedCard) map[string][]templates.FacetValue {
	hosts, tags, langs := map[string]int{}, map[string]int{}, map[string]int{}
	for _, f := range feeds {
		if f.Host != "" {
			hosts[f.Host]++
		}
		for _, t := range f.Tags {
			tags[t]++
		}
		if f.Language != "" {
			langs[f.Language]++
		}
	}
	return map[string][]templates.FacetValue{
		"hosts":    sortedFacet(hosts),
		"tags":     sortedFacet(tags),
		"language": sortedFacet(langs),
	}
}

// sortedFacet: count DESC, then value ASC (stable, scannable).
func sortedFacet(set map[string]int) []templates.FacetValue {
	out := make([]templates.FacetValue, 0, len(set))
	for k, n := range set {
		out = append(out, templates.FacetValue{Value: k, Count: n})
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].Count != out[j].Count {
			return out[i].Count > out[j].Count
		}
		return out[i].Value < out[j].Value
	})
	return out
}

func firstLine(s string, max int) string {
	s = strings.TrimSpace(s)
	if i := strings.IndexAny(s, "\n\r"); i > 0 {
		s = s[:i]
	}
	if len(s) > max {
		s = s[:max] + "…"
	}
	return s
}

func pgTimeDisplay(t pgtype.Timestamptz, tz string) string {
	if !t.Valid {
		return ""
	}
	return utils.FormatTimeInTimezone(t.Time, tz)
}

func itoaPad(n int) string {
	return fmt.Sprintf("%06d", n)
}

// parsePodcastUUID parses an id path param (handlers.parseUUID is
// package-private).
func parsePodcastUUID(s string) (pgtype.UUID, error) {
	id, err := uuid.Parse(strings.TrimSpace(s))
	if err != nil {
		return pgtype.UUID{}, err
	}
	return pgtype.UUID{Bytes: id, Valid: true}, nil
}