refactor: have routes in separate files

1 files changed, 7 insertions, 335 deletions

diff --git a/main.go b/main.go
index e07ca6b..85839b9 100644
--- a/main.go
+++ b/main.go
@@ -1,24 +1,15 @@
 package main
 
 import (
-	"bytes"
 	"flag"
-	"fmt"
-	"html/template"
 	"log"
 	"log/slog"
-	"net/url"
 	"os"
-	"regexp"
-	"slices"
-	"strconv"
-	"strings"
-	"time"
 
 	"github.com/SayaAndy/saya-today-web/config"
 	"github.com/SayaAndy/saya-today-web/internal/b2"
-	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
 	"github.com/SayaAndy/saya-today-web/internal/lightgallery"
+	"github.com/SayaAndy/saya-today-web/internal/router"
 	"github.com/SayaAndy/saya-today-web/internal/tailwind"
 	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
 	"github.com/SayaAndy/saya-today-web/locale"
@@ -100,333 +91,14 @@ func main() {
 		StatusCode: 301,
 	}))
 
-	app.Get("/", func(c *fiber.Ctx) error {
-		content, err := tm.Render("index", fiber.Map{
-			"AvailableLanguages": cfg.AvailableLanguages,
-		})
-		if err != nil {
-			slog.Warn("failed to generate page", slog.String("page", "/"), slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
-		}
-
-		return c.Type("html").Send(content)
-	})
-
-	app.Get("/:lang/map", func(c *fiber.Ctx) error {
-		lang := c.Params("lang")
-		if !slices.Contains(availableLanguages, lang) {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
-		}
-
-		pages, err := b2Client.Scan(lang + "/")
-		status := fiber.StatusOK
-		if err != nil {
-			status = fiber.StatusPartialContent
-			pages = []*b2.BlogPage{}
-		}
-
-		type MapMarker struct {
-			Title          string  `json:"Title"`
-			PageLink       string  `json:"PageLink"`
-			Lat            float64 `json:"Lat"`
-			Long           float64 `json:"Long"`
-			AccuracyMeters int64   `json:"AccuracyMeters"`
-			Thumbnail      string  `json:"Thumbnail"`
-		}
-
-		mapMarkers := make([]*MapMarker, 0, len(pages))
-		for _, page := range pages {
-			geolocationParts := strings.Split(page.Metadata.Geolocation, " ")
-			if len(geolocationParts) < 2 {
-				continue
-			}
-
-			var x, y float64
-			var areaError int64
-			if len(geolocationParts) >= 2 {
-				x, _ = strconv.ParseFloat(geolocationParts[0], 64)
-				y, _ = strconv.ParseFloat(geolocationParts[1], 64)
-			}
-			if len(geolocationParts) >= 3 {
-				areaError, _ = strconv.ParseInt(geolocationParts[2], 10, 64)
-			}
-
-			mapMarkers = append(mapMarkers, &MapMarker{
-				Title:          page.Metadata.Title,
-				PageLink:       fmt.Sprintf("/%s/blog/%s", lang, page.FileName),
-				Lat:            x,
-				Long:           y,
-				AccuracyMeters: areaError,
-				Thumbnail:      page.Metadata.Thumbnail,
-			})
-		}
-
-		content, err := tm.Render("global-map", fiber.Map{
-			"Lang":            lang,
-			"L":               localization[lang],
-			"MapLocationLat":  45.4507,
-			"MapLocationLong": 68.8319,
-			"MapMarkers":      mapMarkers,
-		})
-		if err != nil {
-			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/map"), slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
-		}
-
-		return c.Type("html").Status(status).Send(content)
-	})
-
-	app.Get("/:lang/blog", func(c *fiber.Ctx) error {
-		lang := c.Params("lang")
-		if !slices.Contains(availableLanguages, lang) {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
-		}
-
-		querySort := c.Query("sort")
-		if querySort == "" {
-			querySort = "publicationDateDesc"
-		}
-
-		encodedQuery := c.Request().URI().QueryString()
-		re, err := regexp.Compile(`tags\[\]=([\w]+)`)
-		if err != nil {
-			slog.Warn("failed to generate regex for tags gathering", slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate regex for tags gathering")
-		}
-		decodedQuery, err := url.QueryUnescape(string(encodedQuery))
-		matches := re.FindAllStringSubmatch(decodedQuery, -1)
-
-		queryTags := make([]string, 0, len(matches))
-		for _, match := range matches {
-			queryTags = append(queryTags, string(match[1]))
-		}
-
-		pages, err := b2Client.Scan(lang + "/")
-		status := fiber.StatusOK
-		if err != nil {
-			status = fiber.StatusPartialContent
-			pages = []*b2.BlogPage{}
-		}
-
-		tagsMap := make(map[string]int)
-		for _, page := range pages {
-			slog.Debug("enlist page for catalogue", slog.Any("page", page), slog.String("endpoint", "/"+lang+"/blog"))
-			for _, tag := range page.Metadata.Tags {
-				tagsMap[tag]++
-			}
-		}
-
-		type Tag struct {
-			Name  string `json:"Name" yaml:"name"`
-			Count int    `json:"Count" yaml:"count"`
-		}
-
-		tagsArray := make([]Tag, 0, len(tagsMap))
-		for tag, count := range tagsMap {
-			tagsArray = append(tagsArray, Tag{tag, count})
-		}
-		slices.SortFunc(tagsArray, func(a Tag, b Tag) int {
-			return strings.Compare(a.Name, b.Name)
-		})
-
-		content, err := tm.Render("blog-catalogue", fiber.Map{
-			"QuerySort":     querySort,
-			"QueryTags":     strings.Join(queryTags, ","),
-			"Tags":          tagsArray,
-			"Lang":          lang,
-			"L":             localization[lang],
-			"PublishedYear": "2025",
-			"Title":         localization[lang].BlogSearch.Header,
-		})
-		if err != nil {
-			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/blog"), slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
-		}
-
-		return c.Type("html").Status(status).Send(content)
-	})
-
-	app.Get("/:lang/blog/:title", func(c *fiber.Ctx) error {
-		lang := c.Params("lang")
-		if !slices.Contains(availableLanguages, lang) {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language... yet??", lang))
-		}
-
-		metadata, parsedMarkdown, err := readBlogPost(lang + "/" + c.Params("title"))
-		if err != nil {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("failed to find '%s' post", c.Params("title")))
-		}
-
-		geolocationParts := strings.Split(metadata.Geolocation, " ")
-		var x, y, areaError string
-		if len(geolocationParts) >= 2 {
-			x = geolocationParts[0]
-			y = geolocationParts[1]
-		}
-		if len(geolocationParts) >= 3 {
-			areaError = geolocationParts[2]
-		}
-
-		content, err := tm.Render("blog-page", fiber.Map{
-			"Title":                 metadata.Title,
-			"PublishedDate":         metadata.PublishedTime.Format("2006-01-02 15:04:05 -07:00"),
-			"PublishedYear":         strconv.Itoa(metadata.PublishedTime.Year()),
-			"ParsedMarkdown":        template.HTML(parsedMarkdown),
-			"MapLocationX":          x,
-			"MapLocationY":          y,
-			"MapLocationAreaMeters": areaError,
-			"Lang":                  lang,
-		})
-		if err != nil {
-			slog.Warn("failed to generate page", slog.String("page", "/"+lang+"/blog/"+c.Params("title")), slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate page")
-		}
-
-		return c.Type("html").Send(content)
-	})
-
-	app.Get("/api/v1/tz", func(c *fiber.Ctx) error {
-		timestampString := c.Query("timestamp")
-		tz := c.Query("tz")
-
-		loc, err := time.LoadLocation(tz)
-		if err != nil {
-			loc = time.UTC
-			slog.Warn("unable to parse a client timezone, defaulting to UTC", slog.String("error", err.Error()), slog.String("tz", tz))
-		}
-
-		var format string
-		var timestamp time.Time
-		for _, format = range []string{"2006-01-02 15:04:05 -07:00", time.RFC3339} {
-			if timestamp, err = time.Parse(format, timestampString); err == nil {
-				break
-			}
-		}
-
-		c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-
-		if err != nil {
-			return c.Status(fiber.StatusBadRequest).SendString("invalid timestamp format")
-		}
-
-		return c.Status(fiber.StatusOK).SendString(timestamp.In(loc).Format(format))
-	})
-
-	app.Get("/api/v1/blog-search", func(c *fiber.Ctx) error {
-		sort := c.Query("sort")
-		lang := c.Query("lang")
-		tz := c.Query("tz")
-
-		if !slices.Contains(availableLanguages, lang) {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrNotFound.Code).SendString(fmt.Sprintf("server does not support '%s' language", lang))
-		}
-
-		loc, err := time.LoadLocation(tz)
-		if err != nil {
-			loc = time.UTC
-			slog.Warn("unable to parse a client timezone, defaulting to UTC", slog.String("error", err.Error()), slog.String("tz", tz))
-		}
-
-		pages, err := b2Client.Scan(lang + "/")
-		if err != nil {
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString(fmt.Sprintf("failed to scan pages for '%s' lang: %v", lang, err))
-		}
-
-		encodedQuery := c.Request().URI().QueryString()
-		re, err := regexp.Compile(`tags\[\]=([\w]+)`)
-		if err != nil {
-			slog.Warn("failed to generate regex for tags gathering", slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate regex for tags gathering")
-		}
-		decodedQuery, err := url.QueryUnescape(string(encodedQuery))
-		matches := re.FindAllStringSubmatch(decodedQuery, -1)
-
-		tags := make([]string, 0, len(matches))
-		for _, match := range matches {
-			tags = append(tags, string(match[1]))
-		}
-
-		pageMeta := make([]fiber.Map, 0, len(pages))
-		for _, page := range pages {
-			for _, tag := range page.Metadata.Tags {
-				if len(tags) == 0 || slices.Contains(tags, tag) {
-					pageMeta = append(pageMeta, fiber.Map{
-						"Link":             page.Link,
-						"ArticleLink":      "/" + lang + "/blog/" + page.FileName,
-						"Title":            page.Metadata.Title,
-						"PublishedTime":    page.Metadata.PublishedTime.In(loc).Format("2006-01-02 15:04:05 -07:00"),
-						"ActionDate":       page.Metadata.ActionDate,
-						"ShortDescription": page.Metadata.ShortDescription,
-						"Thumbnail":        page.Metadata.Thumbnail,
-						"Tags":             page.Metadata.Tags,
-					})
-					break
-				}
-			}
-		}
-
-		slices.SortFunc(pageMeta, func(a, b fiber.Map) int {
-			switch sort {
-			case "titleAsc":
-				return strings.Compare(a["Title"].(string), b["Title"].(string))
-			case "titleDesc":
-				return strings.Compare(b["Title"].(string), a["Title"].(string))
-			case "actionDateAsc":
-				return strings.Compare(a["ActionDate"].(string), b["ActionDate"].(string))
-			case "actionDateDesc":
-				return strings.Compare(b["ActionDate"].(string), a["ActionDate"].(string))
-			case "publicationDateAsc":
-				publishedTimeA, _ := time.Parse("2006-01-02 15:04:05 -07:00", a["PublishedTime"].(string))
-				publishedTimeB, _ := time.Parse("2006-01-02 15:04:05 -07:00", b["PublishedTime"].(string))
-				return publishedTimeA.Compare(publishedTimeB)
-			case "publicationDateDesc":
-				publishedTimeA, _ := time.Parse("2006-01-02 15:04:05 -07:00", a["PublishedTime"].(string))
-				publishedTimeB, _ := time.Parse("2006-01-02 15:04:05 -07:00", b["PublishedTime"].(string))
-				return publishedTimeB.Compare(publishedTimeA)
-			}
-			return 0
-		})
-
-		content, err := tm.Render("catalogue-blog-cards", fiber.Map{
-			"BlogPages": pageMeta,
-			"L":         localization[lang],
-		})
-		if err != nil {
-			slog.Warn("failed to generate div", slog.String("page", "/"+lang+"/blog"), slog.String("error", err.Error()))
-			c.Set(fiber.HeaderContentType, fiber.MIMETextPlainCharsetUTF8)
-			return c.Status(fiber.ErrInternalServerError.Code).SendString("failed to generate div")
-		}
-
-		return c.Type("html").Send(content)
-	})
+	app.Get("/", router.Root(tm, cfg.AvailableLanguages))
+	app.Get("/:lang/map", router.Lang_Map(tm, localization, availableLanguages, b2Client))
+	app.Get("/:lang/blog", router.Lang_Blog(tm, localization, availableLanguages, b2Client))
+	app.Get("/:lang/blog/:title", router.Lang_Blog_Title(tm, localization, availableLanguages, b2Client, md))
+	app.Get("/api/v1/tz", router.Api_V1_TZ())
+	app.Get("/api/v1/blog-search", router.Api_V1_BlogSearch(tm, localization, availableLanguages, b2Client))
 
 	app.Static("/", "./static")
 
 	log.Fatal(app.Listen(":3000"))
 }
-
-func readBlogPost(sourceName string) (metadata *frontmatter.Metadata, html string, err error) {
-	metadata, markdown, err := b2Client.ReadFrontmatter(sourceName + ".md")
-	if err != nil {
-		return nil, "", fmt.Errorf("failed to read a frontmatter file: %w", err)
-	}
-
-	var buf bytes.Buffer
-	if err := md.Convert(markdown, &buf); err != nil {
-		return nil, "", fmt.Errorf("convert source context from md to html: %w", err)
-	}
-
-	return metadata, buf.String(), nil
-}