refactor: have routes in separate files

7 files changed, 425 insertions, 335 deletions

diff --git a/internal/router/api-v1-blog-search.go b/internal/router/api-v1-blog-search.go
new file mode 100644
index 0000000..2997407
--- /dev/null
+++ b/internal/router/api-v1-blog-search.go
@@ -0,0 +1,109 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"net/url"
+	"regexp"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Api_V1_BlogSearch(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		sort := c.Query("sort")
+		lang := c.Query("lang")
+		tz := c.Query("tz")
+
+		if !slices.Contains(langs, 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":         l[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)
+	}
+}
diff --git a/internal/router/api-v1-tz.go b/internal/router/api-v1-tz.go
new file mode 100644
index 0000000..4e4e462
--- /dev/null
+++ b/internal/router/api-v1-tz.go
@@ -0,0 +1,37 @@
+package router
+
+import (
+	"log/slog"
+	"time"
+
+	"github.com/gofiber/fiber/v2"
+)
+
+func Api_V1_TZ() func(c *fiber.Ctx) error {
+	return 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))
+	}
+}
diff --git a/internal/router/lang-blog-title.go b/internal/router/lang-blog-title.go
new file mode 100644
index 0000000..39d4252
--- /dev/null
+++ b/internal/router/lang-blog-title.go
@@ -0,0 +1,76 @@
+package router
+
+import (
+	"bytes"
+	"fmt"
+	"html/template"
+	"log/slog"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/frontmatter"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+	"github.com/yuin/goldmark"
+)
+
+func Lang_Blog_Title(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client, md goldmark.Markdown) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, 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(md, b2Client, 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)
+	}
+}
+
+func readBlogPost(md goldmark.Markdown, b2Client *b2.B2Client, 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
+}
diff --git a/internal/router/lang-blog.go b/internal/router/lang-blog.go
new file mode 100644
index 0000000..1a7cbca
--- /dev/null
+++ b/internal/router/lang-blog.go
@@ -0,0 +1,90 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"net/url"
+	"regexp"
+	"slices"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Lang_Blog(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, 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":             l[lang],
+			"PublishedYear": "2025",
+			"Title":         l[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)
+	}
+}
diff --git a/internal/router/lang-map.go b/internal/router/lang-map.go
new file mode 100644
index 0000000..8cc070a
--- /dev/null
+++ b/internal/router/lang-map.go
@@ -0,0 +1,82 @@
+package router
+
+import (
+	"fmt"
+	"log/slog"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/SayaAndy/saya-today-web/internal/b2"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/SayaAndy/saya-today-web/locale"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Lang_Map(tm *templatemanager.TemplateManager, l map[string]*locale.LocaleConfig, langs []string, b2Client *b2.B2Client) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		lang := c.Params("lang")
+		if !slices.Contains(langs, 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":               l[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)
+	}
+}
diff --git a/internal/router/root.go b/internal/router/root.go
new file mode 100644
index 0000000..f5be6cb
--- /dev/null
+++ b/internal/router/root.go
@@ -0,0 +1,24 @@
+package router
+
+import (
+	"log/slog"
+
+	"github.com/SayaAndy/saya-today-web/config"
+	"github.com/SayaAndy/saya-today-web/internal/templatemanager"
+	"github.com/gofiber/fiber/v2"
+)
+
+func Root(tm *templatemanager.TemplateManager, localeCfg []config.AvailableLanguageConfig) func(c *fiber.Ctx) error {
+	return func(c *fiber.Ctx) error {
+		content, err := tm.Render("index", fiber.Map{
+			"AvailableLanguages": localeCfg,
+		})
+		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)
+	}
+}
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
-}