eng-pad-server/internal/webserver/render.go

package webserver

import (
	"fmt"
	"net/http"
	"strconv"

	"git.wntrmute.dev/kyle/eng-pad-server/internal/render"
	"git.wntrmute.dev/kyle/eng-pad-server/internal/share"
	"github.com/go-chi/chi/v5"
)

// --- Authenticated render endpoints ---

func (ws *WebServer) handlePageSVG(w http.ResponseWriter, r *http.Request) {
	notebookID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	pageNum, _ := strconv.Atoi(chi.URLParam(r, "num"))

	strokes, pageSize, err := ws.loadPageStrokes(notebookID, pageNum)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	svg, err := render.RenderSVG(pageSize, strokes)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "image/svg+xml")
	_, _ = w.Write([]byte(svg))
}

func (ws *WebServer) handlePageJPG(w http.ResponseWriter, r *http.Request) {
	notebookID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)
	pageNum, _ := strconv.Atoi(chi.URLParam(r, "num"))

	strokes, pageSize, err := ws.loadPageStrokes(notebookID, pageNum)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	data, err := render.RenderJPG(pageSize, strokes, 95)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "image/jpeg")
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=page-%d.jpg", pageNum))
	_, _ = w.Write(data)
}

func (ws *WebServer) handleNotebookPDF(w http.ResponseWriter, r *http.Request) {
	notebookID, _ := strconv.ParseInt(chi.URLParam(r, "id"), 10, 64)

	pages, pageSize, err := ws.loadNotebookPages(notebookID)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	data, err := render.RenderPDF(pageSize, pages)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/pdf")
	w.Header().Set("Content-Disposition", "attachment; filename=notebook.pdf")
	_, _ = w.Write(data)
}

// --- Share render endpoints ---

func (ws *WebServer) handleSharePageSVG(w http.ResponseWriter, r *http.Request) {
	token := chi.URLParam(r, "token")
	notebookID, err := share.ValidateLink(ws.db, token)
	if err != nil {
		http.Error(w, "Link not found or expired", http.StatusGone)
		return
	}
	pageNum, _ := strconv.Atoi(chi.URLParam(r, "num"))

	strokes, pageSize, err := ws.loadPageStrokes(notebookID, pageNum)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	svg, err := render.RenderSVG(pageSize, strokes)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "image/svg+xml")
	_, _ = w.Write([]byte(svg))
}

func (ws *WebServer) handleSharePageJPG(w http.ResponseWriter, r *http.Request) {
	token := chi.URLParam(r, "token")
	notebookID, err := share.ValidateLink(ws.db, token)
	if err != nil {
		http.Error(w, "Link not found or expired", http.StatusGone)
		return
	}
	pageNum, _ := strconv.Atoi(chi.URLParam(r, "num"))

	strokes, pageSize, err := ws.loadPageStrokes(notebookID, pageNum)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	data, err := render.RenderJPG(pageSize, strokes, 95)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "image/jpeg")
	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=page-%d.jpg", pageNum))
	_, _ = w.Write(data)
}

func (ws *WebServer) handleSharePDF(w http.ResponseWriter, r *http.Request) {
	token := chi.URLParam(r, "token")
	notebookID, err := share.ValidateLink(ws.db, token)
	if err != nil {
		http.Error(w, "Link not found or expired", http.StatusGone)
		return
	}

	pages, pageSize, err := ws.loadNotebookPages(notebookID)
	if err != nil {
		http.Error(w, "Not found", http.StatusNotFound)
		return
	}

	data, err := render.RenderPDF(pageSize, pages)
	if err != nil {
		http.Error(w, "Render error", http.StatusInternalServerError)
		return
	}
	w.Header().Set("Content-Type", "application/pdf")
	w.Header().Set("Content-Disposition", "attachment; filename=notebook.pdf")
	_, _ = w.Write(data)
}

// --- DB helpers ---

func (ws *WebServer) loadPageStrokes(notebookID int64, pageNum int) ([]render.Stroke, string, error) {
	var pageSize string
	err := ws.db.QueryRow("SELECT page_size FROM notebooks WHERE id = ?", notebookID).Scan(&pageSize)
	if err != nil {
		return nil, "", err
	}

	var pageID int64
	err = ws.db.QueryRow(
		"SELECT id FROM pages WHERE notebook_id = ? AND page_number = ?",
		notebookID, pageNum,
	).Scan(&pageID)
	if err != nil {
		return nil, "", err
	}

	rows, err := ws.db.Query(
		"SELECT pen_size, color, style, point_data, stroke_order FROM strokes WHERE page_id = ? ORDER BY stroke_order",
		pageID,
	)
	if err != nil {
		return nil, "", err
	}
	defer func() { _ = rows.Close() }()

	var strokes []render.Stroke
	for rows.Next() {
		var s render.Stroke
		if err := rows.Scan(&s.PenSize, &s.Color, &s.Style, &s.PointData, &s.StrokeOrder); err != nil {
			return nil, "", err
		}
		strokes = append(strokes, s)
	}
	return strokes, pageSize, nil
}

func (ws *WebServer) loadNotebookPages(notebookID int64) ([]render.Page, string, error) {
	var pageSize string
	err := ws.db.QueryRow("SELECT page_size FROM notebooks WHERE id = ?", notebookID).Scan(&pageSize)
	if err != nil {
		return nil, "", err
	}

	rows, err := ws.db.Query(
		"SELECT id, page_number FROM pages WHERE notebook_id = ? ORDER BY page_number",
		notebookID,
	)
	if err != nil {
		return nil, "", err
	}
	defer func() { _ = rows.Close() }()

	var pages []render.Page
	for rows.Next() {
		var pageID int64
		var pageNum int
		if err := rows.Scan(&pageID, &pageNum); err != nil {
			return nil, "", err
		}

		strokeRows, err := ws.db.Query(
			"SELECT pen_size, color, style, point_data, stroke_order FROM strokes WHERE page_id = ? ORDER BY stroke_order",
			pageID,
		)
		if err != nil {
			return nil, "", err
		}

		var strokes []render.Stroke
		for strokeRows.Next() {
			var s render.Stroke
			if err := strokeRows.Scan(&s.PenSize, &s.Color, &s.Style, &s.PointData, &s.StrokeOrder); err != nil {
				_ = strokeRows.Close()
				return nil, "", err
			}
			strokes = append(strokes, s)
		}
		_ = strokeRows.Close()

		pages = append(pages, render.Page{PageNumber: pageNum, Strokes: strokes})
	}
	return pages, pageSize, nil
}