bookhoard/internal/router/reader.go

package router

import (
	"bookhoard/internal/handlers"
	"bookhoard/internal/services"
	"bookhoard/internal/sync"
	"bookhoard/internal/utils"
	"bookhoard/templates"
	"bytes"
	"net/http"

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

func registerReaderRoutes(cfg *Config) {
	e := cfg.Echo

	// Create reader service and handler
	readerService := services.NewReaderService(cfg.Queries, cfg.Worker)
	cfg.ReaderHandler = handlers.NewReaderHandler(
		cfg.Queries,
		services.NewLibraryService(cfg.Queries),
		readerService,
		cfg.Worker,
	)

	jwtMiddleware := createJWTMiddleware(cfg)

	// Reader page routes (SSR + API)
	reader := e.Group("/readers", jwtMiddleware)

	// Reader page (SSR)
	reader.GET("/:mediaItemId", func(c *echo.Context) error {
		// Get user
		user, err := getTemplateUserWithTheme(c, cfg)
		if err != nil {
			return renderErrorPage(c, "Error loading user", "user_load_error")
		}
		// Parse mediaItemID
		mediaItemID := c.Param("mediaItemId")
		parsedUUID, err := uuid.Parse(mediaItemID)
		if err != nil {
			return renderErrorPage(c, "Invalid media item ID", "invalid_id")
		}
		// Fetch media item (directly, no handler)
		mediaItem, err := cfg.Queries.GetMediaItem(c.Request().Context(), pgtype.UUID{Bytes: parsedUUID, Valid: true})
		if err != nil {
			return renderErrorPage(c, "Media item not found", "not_found")
		}
		// Check library access (using pattern from opds.go)
		userUUID, _ := uuid.Parse(user.ID)
		libraries, err := cfg.Queries.GetUserVisibleLibraries(c.Request().Context(), uuidToPGType(userUUID))
		if err != nil {
			return renderErrorPage(c, "Failed to check access", "access_error")
		}

		visible := false
		for _, lib := range libraries {
			if lib.ID == mediaItem.LibraryID {
				visible = true
				break
			}
		}
		if !visible {
			return renderErrorPage(c, "Access denied", "access_denied")
		}
		// Library type decides comic reader treatment: fixed-layout items
		// (e.g. manga PDFs) shelved in comics/manga libraries are paged
		// through like comics — bookmarks only, no highlights or search.
		libraryWithType, err := cfg.Queries.GetLibraryWithType(c.Request().Context(), mediaItem.LibraryID)
		if err != nil {
			return renderErrorPage(c, "Failed to get library info", "library_error")
		}
		// Convert to template types. Reading state is deliberately NOT
		// fetched or embedded: the reader pulls position, bookmarks, and
		// annotations from the APIs at open time so the page can never
		// carry (nor write back) a stale snapshot.
		mediaUUID, _ := uuid.FromBytes(mediaItem.ID.Bytes[0:16])
		libUUID, _ := uuid.FromBytes(mediaItem.LibraryID.Bytes[0:16])
		metadata := templates.ReaderMetadata{
			MediaItemID: mediaUUID.String(),
			Title:       mediaItem.Title,
			Author:      utils.PgTextString(mediaItem.Author),
			// Sidecar covers store a raw library-relative path; resolve to
			// the cookie-authed /uploads URL (idempotent for items whose
			// stored value is already a servable path).
			CoverImagePath:   utils.ResolveMediaURL(mediaItem.LibraryID, mediaItem.CoverImagePath),
			LibraryType:      mediaItem.FormatGroup,
			MimeType:         utils.PgTextString(mediaItem.MimeType),
			FilePath:         mediaItem.FilePath,
			TotalPages:       int(mediaItem.PageCount.Int32),
			ChapterCount:     int(mediaItem.ChapterCount.Int32),
			FormatGroup:      mediaItem.FormatGroup,
			MangaType:        utils.PgTextString(mediaItem.MangaType),
			ReadingDirection: utils.PgTextString(mediaItem.ReadingDirection),
			LibraryID:        libUUID.String(),
			FileURL:          utils.ResolveMediaURL(mediaItem.LibraryID, pgtype.Text{String: mediaItem.FilePath, Valid: true}),
			TotalCharacters:  mediaItem.TotalCharacters.Int64,
			EstimatedPages:   sync.EstimatedPages(mediaItem.TotalCharacters.Int64),
			TreatAsComic:     handlers.ShouldTreatAsComic(libraryWithType.TypeName, mediaItem.FormatGroup),
		}
		// Render template
		var buf bytes.Buffer
		// Audiobooks get the audio player page — the foliate document
		// engine is deliberately not involved (handoff item 3 Batch A).
		if mediaItem.FormatGroup == "audiobook" {
			err = templates.AudioReader(user, metadata).Render(c.Request().Context(), &buf)
		} else {
			err = templates.Reader(user, metadata).Render(c.Request().Context(), &buf)
		}
		if err != nil {
			return renderErrorPage(c, "Error rendering reader", "render_error")
		}
		return c.HTML(http.StatusOK, buf.String())
	})

	// Content serving (lazy-loaded pages)
	reader.GET("/:mediaItemId/pages/:pageNumber", cfg.ReaderHandler.GetPage)

	// Chapter metadata
	reader.GET("/:mediaItemId/chapters", cfg.ReaderHandler.GetChapters)

	// Panel data (comics/manga)
	reader.GET("/:mediaItemId/panels/:pageNumber", cfg.ReaderHandler.GetPanels)
	reader.PUT("/:mediaItemId/panels/:pageNumber", cfg.ReaderHandler.UpdatePanels)

	// PDF outline/TOC
	reader.GET("/:mediaItemId/outline", cfg.ReaderHandler.GetPDFOutline)

	// PDF thumbnails (for mini-map)
	reader.GET("/:mediaItemId/thumbnails/:pageNumber", cfg.ReaderHandler.GetPDFThumbnail)

	// Reading speed
	reader.GET("/:mediaItemId/reading-speed", cfg.ReaderHandler.GetReadingSpeed)
	reader.POST("/:mediaItemId/reading-speed", cfg.ReaderHandler.UpdateReadingSpeed)

	// Dictionary lookup
	reader.GET("/dictionary/:word", cfg.ReaderHandler.LookupWord)

	// Reader settings
	reader.GET("/settings", cfg.ReaderHandler.GetSettings)
	reader.PUT("/settings", cfg.ReaderHandler.UpdateSettings)
}