config.go

package main

import (
	"cmp"
	"errors"
	"net/http"
	"net/url"
	"slices"
	"strconv"
	"strings"
	"sync"

	"github.com/samber/lo"
	"github.com/spf13/viper"
	"maunium.net/go/mautrix"
)

type config struct {
	Server            *configServer            `mapstructure:"server"`
	Db                *configDb                `mapstructure:"database"`
	Cache             *configCache             `mapstructure:"cache"`
	DefaultBlog       string                   `mapstructure:"defaultblog"`
	Blogs             map[string]*configBlog   `mapstructure:"blogs"`
	User              *configUser              `mapstructure:"user"`
	OIDC              *configOIDC              `mapstructure:"oidc"`
	Hooks             *configHooks             `mapstructure:"hooks"`
	Plugins           []*configPlugin          `mapstructure:"plugins"`
	Micropub          *configMicropub          `mapstructure:"micropub"`
	PathRedirects     []*configRegexRedirect   `mapstructure:"pathRedirects"`
	ActivityPub       *configActivityPub       `mapstructure:"activityPub"`
	Webmention        *configWebmention        `mapstructure:"webmention"`
	Notifications     *configNotifications     `mapstructure:"notifications"`
	PrivateMode       *configPrivateMode       `mapstructure:"privateMode"`
	MediaOptimization *configMediaOptimization `mapstructure:"mediaOptimization"`
	IndexNow          *configIndexNow          `mapstructure:"indexNow"`
	EasterEgg         *configEasterEgg         `mapstructure:"easterEgg"`
	MapTiles          *configMapTiles          `mapstructure:"mapTiles"`
	TTS               *configTTS               `mapstructure:"tts"`
	Reactions         *configReactions         `mapstructure:"reactions"`
	Pprof             *configPprof             `mapstructure:"pprof"`
	RobotsTxt         *configRobotsTxt         `mapstructure:"robotstxt"`
	Debug             bool                     `mapstructure:"debug"`
	initialized       bool
}

type configServer struct {
	Logging            bool     `mapstructure:"logging"`
	LogFile            string   `mapstructure:"logFile"`
	Port               int      `mapstructure:"port"`
	PublicAddress      string   `mapstructure:"publicAddress"`
	ShortPublicAddress string   `mapstructure:"shortPublicAddress"`
	MediaAddress       string   `mapstructure:"mediaAddress"`
	AltAddresses       []string `mapstructure:"altAddresses"`
	IndieAuthAddress   string   `mapstructure:"indieAuthAddress"`
	PublicHTTPS        bool     `mapstructure:"publicHttps"`
	AcmeDir            string   `mapstructure:"acmeDir"`
	AcmeEabKid         string   `mapstructure:"acmeEabKid"`
	AcmeEabKey         string   `mapstructure:"acmeEabKey"`
	HTTPSCert          string   `mapstructure:"httpsCert"`
	HTTPSKey           string   `mapstructure:"httpsKey"`
	HTTPSRedirect      bool     `mapstructure:"httpsRedirect"`
	HTTPSRedirectPort  int      `mapstructure:"httpsRedirectPort"`
	HealthCheckAddress string   `mapstructure:"healthCheckAddress"`
	Tor                bool     `mapstructure:"tor"`
	SecurityHeaders    bool     `mapstructure:"securityHeaders"`
	CSPDomains         []string `mapstructure:"cspDomains"`
	publicHost         string
	shortPublicHost    string
	mediaHost          string
	altHosts           []string
	manualHTTPS        bool
}

type configDb struct {
	File           string `mapstructure:"file"`
	DumpFile       string `mapstructure:"dumpFile"`
	MigrationCache string `mapstructure:"migrationCache"`
	Debug          bool   `mapstructure:"debug"`
}

type configCache struct {
	Enable     bool `mapstructure:"enable"`
	Expiration int  `mapstructure:"expiration"`
}

type configBlog struct {
	Path            string                    `mapstructure:"path"`
	Lang            string                    `mapstructure:"lang"`
	Title           string                    `mapstructure:"title"`
	Description     string                    `mapstructure:"description"`
	LongDescription string                    `mapstructure:"-"` // Set via the blog settings UI, stored in the database
	Pagination      int                       `mapstructure:"pagination"`
	DefaultSection  string                    `mapstructure:"defaultsection"`
	Sections        map[string]*configSection `mapstructure:"sections"` // Moved to web ui, but keep it loading the db state to this struct and the initial migration from config to db.
	Taxonomies      []*configTaxonomy         `mapstructure:"taxonomies"`
	Menus           map[string]*configMenu    `mapstructure:"menus"`
	Photos          *configPhotos             `mapstructure:"photos"`
	Search          *configSearch             `mapstructure:"search"`
	BlogStats       *configBlogStats          `mapstructure:"blogStats"`
	Blogroll        *configBlogroll           `mapstructure:"blogroll"`
	Telegram        *configTelegram           `mapstructure:"telegram"`
	PostAsHome      bool                      `mapstructure:"postAsHome"`
	RandomPost      *configRandomPost         `mapstructure:"randomPost"`
	OnThisDay       *configOnThisDay          `mapstructure:"onThisDay"`
	Comments        *configComments           `mapstructure:"comments"`
	Map             *configGeoMap             `mapstructure:"map"`
	Contact         *configContact            `mapstructure:"contact"`
	Announcement    *configAnnouncement       `mapstructure:"announcement"`
	Atproto         *configAtproto            `mapstructure:"atproto"`
	// Configs read from database
	hideOldContentWarning bool
	hideShareButton       bool
	hideTranslateButton   bool
	hideSpeakButton       bool
	addReplyTitle         bool
	addReplyContext       bool
	addLikeTitle          bool
	addLikeContext        bool
	reactionsEnabled      bool
	allowedReactions      []string
	// Original config values (for deprecation detection)
	configTitle       string
	configDescription string
	// Editor state WebSockets
	esws sync.Map
	esm  sync.Mutex
}

type configSection struct {
	Title        string `mapstructure:"title"`
	Description  string `mapstructure:"description"`
	PathTemplate string `mapstructure:"pathtemplate"`
	ShowFull     bool   `mapstructure:"showFull"`
	HideOnStart  bool   `mapstructure:"hideOnStart"`
	Name         string
}

type configTaxonomy struct {
	Name        string `mapstructure:"name"`
	Title       string `mapstructure:"title"`
	Description string `mapstructure:"description"`
}

type configMenu struct {
	Items []*configMenuItem `mapstructure:"items"`
}

type configMenuItem struct {
	Title string `mapstructure:"title"`
	Link  string `mapstructure:"link"`
}

type configPhotos struct {
	Enabled     bool   `mapstructure:"enabled"`
	Path        string `mapstructure:"path"`
	Title       string `mapstructure:"title"`
	Description string `mapstructure:"description"`
}

type configSearch struct {
	Enabled     bool   `mapstructure:"enabled"`
	Path        string `mapstructure:"path"`
	Title       string `mapstructure:"title"`
	Description string `mapstructure:"description"`
	Placeholder string `mapstructure:"placeholder"`
}

type configBlogStats struct {
	Enabled     bool   `mapstructure:"enabled"`
	Path        string `mapstructure:"path"`
	Title       string `mapstructure:"title"`
	Description string `mapstructure:"description"`
}

type configBlogroll struct {
	Enabled     bool     `mapstructure:"enabled"`
	Path        string   `mapstructure:"path"`
	Opml        string   `mapstructure:"opml"`
	AuthHeader  string   `mapstructure:"authHeader"`
	AuthValue   string   `mapstructure:"authValue"`
	Categories  []string `mapstructure:"categories"`
	Title       string   `mapstructure:"title"`
	Description string   `mapstructure:"description"`
}

type configRandomPost struct {
	Enabled bool   `mapstructure:"enabled"`
	Path    string `mapstructure:"path"`
}

type configOnThisDay struct {
	Enabled bool   `mapstructure:"enabled"`
	Path    string `mapstructure:"path"`
}

type configComments struct {
	Enabled bool `mapstructure:"enabled"`
}

type configGeoMap struct {
	Enabled  bool   `mapstructure:"enabled"`
	Path     string `mapstructure:"path"`
	Title    string `mapstructure:"title"`
	AllBlogs bool   `mapstructure:"allBlogs"`
}

type configContact struct {
	Enabled       bool   `mapstructure:"enabled"`
	Path          string `mapstructure:"path"`
	Title         string `mapstructure:"title"`
	Description   string `mapstructure:"description"`
	PrivacyPolicy string `mapstructure:"privacyPolicy"`
	SMTPHost      string `mapstructure:"smtpHost"`
	SMTPPort      int    `mapstructure:"smtpPort"`
	SMTPUser      string `mapstructure:"smtpUser"`
	SMTPPassword  string `mapstructure:"smtpPassword"`
	SMTPSSL       bool   `mapstructure:"smtpSSL"`
	EmailFrom     string `mapstructure:"emailFrom"`
	EmailTo       string `mapstructure:"emailTo"`
	EmailSubject  string `mapstructure:"emailSubject"`
}

type configAnnouncement struct {
	Text string `mapstructure:"text"`
}

type configUser struct {
	Nick                     string               `mapstructure:"nick"`
	Name                     string               `mapstructure:"name"`
	Password                 string               `mapstructure:"password"`
	TOTP                     string               `mapstructure:"totp"`
	AppPasswords             []*configAppPassword `mapstructure:"appPasswords"`
	Email                    string               `mapstructure:"email"`
	Link                     string               `mapstructure:"link"`
	Identities               []string             `mapstructure:"identities"`
	ProfileImageFile         string               `mapstructure:"profileImageFile"`
	showProfileImageInHeader bool
}

type configAppPassword struct {
	Username string `mapstructure:"username"`
	Password string `mapstructure:"password"`
}

type configOIDC struct {
	Enabled      bool   `mapstructure:"enabled"`
	Issuer       string `mapstructure:"issuer"`
	ClientID     string `mapstructure:"clientId"`
	ClientSecret string `mapstructure:"clientSecret"`
}

type configHooks struct {
	Shell    string   `mapstructure:"shell"`
	Hourly   []string `mapstructure:"hourly"`
	PreStart []string `mapstructure:"prestart"`
	// Can use template
	PostPost     []string `mapstructure:"postpost"`
	PostUpdate   []string `mapstructure:"postupdate"`
	PostDelete   []string `mapstructure:"postdelete"`
	PostUndelete []string `mapstructure:"postundelete"`
}

type configMicropub struct {
	CategoryParam         string               `mapstructure:"categoryParam"`
	ReplyParam            string               `mapstructure:"replyParam"`
	ReplyTitleParam       string               `mapstructure:"replyTitleParam"`
	ReplyContextParam     string               `mapstructure:"replyContextParam"`
	LikeParam             string               `mapstructure:"likeParam"`
	LikeTitleParam        string               `mapstructure:"likeTitleParam"`
	LikeContextParam      string               `mapstructure:"likeContextParam"`
	BookmarkParam         string               `mapstructure:"bookmarkParam"`
	AudioParam            string               `mapstructure:"audioParam"`
	PhotoParam            string               `mapstructure:"photoParam"`
	PhotoDescriptionParam string               `mapstructure:"photoDescriptionParam"`
	LocationParam         string               `mapstructure:"locationParam"`
	MediaStorage          *configMicropubMedia `mapstructure:"mediaStorage"`
}

type configMicropubMedia struct {
	MediaURL string `mapstructure:"mediaURL"`
	// BunnyCDN
	BunnyStorageKey    string `mapstructure:"bunnyStorageKey"`
	BunnyStorageName   string `mapstructure:"bunnyStorageName"`
	BunnyStorageRegion string `mapstructure:"bunnyStorageRegion"`
	// FTP
	FTPAddress  string `mapstructure:"ftpAddress"`
	FTPUser     string `mapstructure:"ftpUser"`
	FTPPassword string `mapstructure:"ftpPassword"`
}

type configRegexRedirect struct {
	From string `mapstructure:"from"`
	To   string `mapstructure:"to"`
	Type int    `mapstructure:"type"`
}

type configActivityPub struct {
	Enabled            bool     `mapstructure:"enabled"`
	TagsTaxonomies     []string `mapstructure:"tagsTaxonomies"`
	AttributionDomains []string `mapstructure:"attributionDomains"`
	AlsoKnownAs        []string `mapstructure:"alsoKnownAs"`
}

type configNotifications struct {
	Ntfy     *configNtfy     `mapstructure:"ntfy"`
	Telegram *configTelegram `mapstructure:"telegram"`
	Matrix   *configMatrix   `mapstructure:"matrix"`
}

type configNtfy struct {
	Enabled bool   `mapstructure:"enabled"`
	Topic   string `mapstructure:"topic"`
	Server  string `mapstructure:"server"`
	User    string `mapstructure:"user"`
	Pass    string `mapstructure:"pass"`
	Email   string `mapstructure:"email"`
}

type configTelegram struct {
	Enabled  bool   `mapstructure:"enabled"`
	ChatID   string `mapstructure:"chatId"`
	BotToken string `mapstructure:"botToken"`
}

type configMatrix struct {
	Enabled    bool   `mapstructure:"enabled"`
	HomeServer string `mapstructure:"homeserver"`
	Username   string `mapstructure:"username"`
	Password   string `mapstructure:"password"`
	Room       string `mapstructure:"room"`
	DeviceID   string `mapstructure:"deviceid"`
	client     *mautrix.Client
	err        error
	clientInit sync.Once
}

type configPrivateMode struct {
	Enabled bool `mapstructure:"enabled"`
}

type configIndexNow struct {
	Enabled bool `mapstructure:"enabled"`
}

type configEasterEgg struct {
	Enabled bool `mapstructure:"enabled"`
}

type configWebmention struct {
	DisableSending             bool `mapstructure:"disableSending"`
	DisableReceiving           bool `mapstructure:"disableReceiving"`
	DisableInterGoblogMentions bool `mapstructure:"disableInterGoblogMentions"`
}

type configMapTiles struct {
	Source      string `mapstructure:"source"`
	Attribution string `mapstructure:"attribution"`
	MinZoom     int    `mapstructure:"minZoom"`
	MaxZoom     int    `mapstructure:"maxZoom"`
}

type configTTS struct {
	Enabled       bool   `mapstructure:"enabled"`
	GoogleAPIKey  string `mapstructure:"googleApiKey"`
	MistralAPIKey string `mapstructure:"mistralApiKey"`
	MistralModel  string `mapstructure:"mistralModel"`
	MistralVoice  string `mapstructure:"mistralVoice"`
}

type configReactions struct {
	Enabled bool `mapstructure:"enabled"`
}

type configPprof struct {
	Enabled bool   `mapstructure:"enabled"`
	Address string `mapstructure:"address"`
}

type configPlugin struct {
	Path   string         `mapstructure:"path"`
	Import string         `mapstructure:"import"`
	Config map[string]any `mapstructure:"config"`
}

type configRobotsTxt struct {
	BlockedBots []string `mapstructure:"blockedBots"`
}

type configAtproto struct {
	Enabled        bool     `mapstructure:"enabled"`
	Pds            string   `mapstructure:"pds"`
	Handle         string   `mapstructure:"handle"`
	Password       string   `mapstructure:"password"`
	TagsTaxonomies []string `mapstructure:"tagsTaxonomies"`
}

type configMediaOptimization struct {
	Enabled         bool     `mapstructure:"enabled"`
	ImgproxyURL     string   `mapstructure:"imgproxyURL"`
	Formats         []string `mapstructure:"formats"`
	Widths          []int    `mapstructure:"widths"`
	ContentMaxWidth int      `mapstructure:"contentMaxWidth"`
}

func (a *goBlog) loadConfigFile(file string) error {
	// Use viper to load the config file
	v := viper.New()
	if file != "" {
		// Use config file from the flag
		v.SetConfigFile(file)
	} else {
		// Search in default locations
		v.SetConfigName("config")
		v.AddConfigPath("./config/")
	}
	// Read config
	if err := v.ReadInConfig(); err != nil {
		return err
	}
	// Unmarshal config
	a.cfg = createDefaultConfig()
	return v.Unmarshal(a.cfg)
}

func (a *goBlog) initConfig(logging bool) error {
	if a.cfg == nil {
		a.cfg = createDefaultConfig()
	}
	if a.cfg.initialized {
		return nil
	}
	// Update log level
	a.updateLogLevel()
	// Init database
	if err := a.initDatabase(logging); err != nil {
		return err
	}
	// Parse addresses and hostnames
	if a.cfg.Server.PublicAddress == "" {
		return errors.New("no public address configured")
	}
	publicURL, err := url.Parse(a.cfg.Server.PublicAddress)
	if err != nil {
		return errors.New("Invalid public address: " + err.Error())
	}
	a.cfg.Server.publicHost = publicURL.Hostname()
	if sa := a.cfg.Server.ShortPublicAddress; sa != "" {
		shortPublicURL, err := url.Parse(sa)
		if err != nil {
			return errors.New("Invalid short public address: " + err.Error())
		}
		a.cfg.Server.shortPublicHost = shortPublicURL.Hostname()
	}
	if ma := a.cfg.Server.MediaAddress; ma != "" {
		mediaURL, err := url.Parse(ma)
		if err != nil {
			return errors.New("Invalid media address: " + err.Error())
		}
		a.cfg.Server.mediaHost = mediaURL.Hostname()
	}
	a.cfg.Server.altHosts = []string{}
	for _, aa := range a.cfg.Server.AltAddresses {
		altURL, err := url.Parse(aa)
		if err != nil {
			return errors.New("Invalid alternative address: " + err.Error())
		}
		a.cfg.Server.altHosts = append(a.cfg.Server.altHosts, altURL.Hostname())
	}
	// Check IndieAuth address
	if ia := a.cfg.Server.IndieAuthAddress; ia != "" {
		// Validate that IndieAuthAddress is one of the AltAddresses
		if !slices.Contains(a.cfg.Server.AltAddresses, ia) {
			return errors.New("indieAuthAddress must be one of the altAddresses")
		}
	}
	// Check OIDC config
	if oidc := a.cfg.OIDC; oidc != nil && oidc.Enabled {
		if oidc.Issuer == "" || oidc.ClientID == "" {
			return errors.New("oidc issuer and clientId are required when oidc is enabled")
		}
	}
	// Check port or set default
	if a.cfg.Server.Port == 0 {
		finalPort := 8080
		if port := publicURL.Port(); port != "" {
			finalPort, err = strconv.Atoi(port)
			if err != nil {
				return errors.New("Failed to parse port: " + err.Error())
			}
		} else if publicURL.Scheme == "https" {
			finalPort = 443
		}
		a.cfg.Server.Port = finalPort
	}
	// Check HTTPS
	if a.cfg.Server.HTTPSCert != "" && a.cfg.Server.HTTPSKey != "" {
		a.cfg.Server.manualHTTPS = true
	}
	if a.cfg.Server.PublicHTTPS || a.cfg.Server.manualHTTPS {
		a.cfg.Server.SecurityHeaders = true
	}
	if a.cfg.Server.PublicHTTPS {
		a.cfg.Server.HTTPSRedirect = true
	}
	// Check if any blog is configured
	if len(a.cfg.Blogs) == 0 {
		a.cfg.Blogs = map[string]*configBlog{
			"default": createDefaultBlog(),
		}
	}
	// Check if default blog is set
	if a.cfg.DefaultBlog == "" {
		// Set default blog to the only blog that is configured
		a.cfg.DefaultBlog = lo.Keys(a.cfg.Blogs)[0]
	}
	// Check if default blog exists
	if a.cfg.Blogs[a.cfg.DefaultBlog] == nil {
		return errors.New("default blog does not exist")
	}
	// Check media storage config
	if ms := a.cfg.Micropub.MediaStorage; ms != nil && ms.MediaURL != "" {
		ms.MediaURL = strings.TrimSuffix(ms.MediaURL, "/")
	}
	// Load webmention settings from DB (migrating from config on first run)
	if a.cfg.Webmention == nil {
		a.cfg.Webmention = &configWebmention{}
	}
	wm := a.cfg.Webmention
	_ = a.migrateBooleanSetting(webmentionDisableSendingSetting, &wm.DisableSending)
	_ = a.migrateBooleanSetting(webmentionDisableReceivingSetting, &wm.DisableReceiving)
	_ = a.migrateBooleanSetting(webmentionDisableInterGoblogSetting, &wm.DisableInterGoblogMentions)
	// Check if path for profile image is set
	if a.cfg.User.ProfileImageFile == "" {
		return errors.New("no file for profile image configured")
	}
	// Check if sections already migrated to db
	const sectionMigrationKey = "sections_migrated"
	if val, err := a.getSettingValue(sectionMigrationKey); err != nil {
		return err
	} else if val == "" {
		if err = a.saveAllSections(); err != nil {
			return err
		}
		if err = a.saveSettingValue(sectionMigrationKey, "1"); err != nil {
			return err
		}
	}
	// Load db sections
	if err = a.loadSections(); err != nil {
		return err
	}
	// Load other settings from database
	// User nick
	if err = a.migrateStringSetting(userNickSetting, &a.cfg.User.Nick); err != nil {
		return err
	}
	// User name
	if err = a.migrateStringSetting(userNameSetting, &a.cfg.User.Name); err != nil {
		return err
	}
	// User email
	if err = a.migrateStringSetting(userEmailSetting, &a.cfg.User.Email); err != nil {
		return err
	}
	// Show profile image in header
	showProfileImageInHeader, err := a.getBooleanSettingValue(showProfileImageInHeaderSetting, false)
	if err != nil {
		return err
	}
	a.cfg.User.showProfileImageInHeader = showProfileImageInHeader
	// Migrate auth from config to database
	if err := a.migrateAuthFromConfig(logging); err != nil {
		return err
	}
	// Check config for each blog
	for blog, bc := range a.cfg.Blogs {
		// Check pagination
		if bc.Pagination == 0 {
			bc.Pagination = 10
		}
		// Check sections and add section if none exists
		if len(bc.Sections) == 0 {
			bc.Sections = createDefaultSections()
			if err = a.saveAllSections(); err != nil {
				return err
			}
		}
		// Check default section
		if defaultSection, err := a.getSettingValue(settingNameWithBlog(blog, defaultSectionSetting)); err != nil {
			// Failed to read value
			return err
		} else if defaultSection == "" {
			// No value defined in database
			if _, ok := bc.Sections[bc.DefaultSection]; !ok {
				bc.DefaultSection = lo.Keys(bc.Sections)[0]
			}
			// Save to database
			if err = a.saveSettingValue(settingNameWithBlog(blog, defaultSectionSetting), bc.DefaultSection); err != nil {
				return err
			}
		} else {
			// Set value from database
			bc.DefaultSection = defaultSection
		}
		// Check if language is set
		if bc.Lang == "" {
			bc.Lang = "en"
		}
		// Blogroll
		if br := bc.Blogroll; br != nil && br.Enabled && br.Opml == "" {
			br.Enabled = false
		}
		// Save original config values for deprecation detection, then load/migrate blog title and description
		bc.configTitle = bc.Title
		bc.configDescription = bc.Description
		// Blog title
		if err = a.migrateStringSetting(settingNameWithBlog(blog, blogTitleSetting), &bc.Title); err != nil {
			return err
		}
		// Blog description
		if err = a.migrateStringSetting(settingNameWithBlog(blog, blogDescriptionSetting), &bc.Description); err != nil {
			return err
		}
		// Blog long description
		if err = a.migrateStringSetting(settingNameWithBlog(blog, blogLongDescriptionSetting), &bc.LongDescription); err != nil {
			return err
		}
		// Blog reactions
		if err = a.migrateBooleanSetting(settingNameWithBlog(blog, reactionsEnabledSetting), &bc.reactionsEnabled); err != nil {
			return err
		}
		// Special migration: if blog-specific setting not in DB but global config enabled is set
		if val, _ := a.getSettingValue(settingNameWithBlog(blog, reactionsEnabledSetting)); val == "" && a.cfg.Reactions != nil && a.cfg.Reactions.Enabled {
			bc.reactionsEnabled = true
			if err = a.saveBooleanSettingValue(settingNameWithBlog(blog, reactionsEnabledSetting), true); err != nil {
				return err
			}
		}
		reactionsVal, err := a.getSettingValue(settingNameWithBlog(blog, reactionsSetting))
		if err != nil {
			return err
		}
		if reactionsVal != "" {
			bc.allowedReactions = lo.Filter(lo.Map(strings.Split(reactionsVal, ","), func(s string, _ int) string {
				return strings.TrimSpace(s)
			}), func(s string, _ int) bool {
				return s != ""
			})
		}
		// Load other settings from database
		configs := []*bool{
			&bc.hideOldContentWarning, &bc.hideShareButton, &bc.hideTranslateButton, &bc.hideSpeakButton,
			&bc.addReplyTitle, &bc.addReplyContext, &bc.addLikeTitle, &bc.addLikeContext,
		}
		settings := []string{
			hideOldContentWarningSetting, hideShareButtonSetting, hideTranslateButtonSetting, hideSpeakButtonSetting,
			addReplyTitleSetting, addReplyContextSetting, addLikeTitleSetting, addLikeContextSetting,
		}
		defaults := []bool{
			false, false, false, false,
			false, false, false, false,
		}
		for i := range configs {
			*configs[i], err = a.getBooleanSettingValue(settingNameWithBlog(blog, settings[i]), defaults[i])
			if err != nil {
				return err
			}
		}
	}
	// Log success
	a.cfg.initialized = true
	if logging {
		a.info("Initialized configuration")
	}
	return nil
}

func createDefaultConfig() *config {
	return &config{
		Server: &configServer{
			PublicAddress: "http://localhost:8080",
			LogFile:       "data/access.log",
		},
		Db: &configDb{
			File:           "data/db.sqlite",
			MigrationCache: "data/media-migrate.json",
		},
		Cache: &configCache{
			Enable:     true,
			Expiration: 600,
		},
		User: &configUser{
			Nick:             "admin",
			ProfileImageFile: "data/profileImage",
		},
		Hooks: &configHooks{
			Shell: "/bin/bash",
		},
		Micropub: &configMicropub{
			CategoryParam:         "tags",
			ReplyParam:            "replylink",
			ReplyTitleParam:       "replytitle",
			ReplyContextParam:     "replycontext",
			LikeParam:             "likelink",
			LikeTitleParam:        "liketitle",
			LikeContextParam:      "likecontext",
			BookmarkParam:         "link",
			AudioParam:            "audio",
			PhotoParam:            "images",
			PhotoDescriptionParam: "imagealts",
			LocationParam:         "location",
		},
		ActivityPub: &configActivityPub{
			TagsTaxonomies: []string{"tags"},
		},
		Webmention: &configWebmention{},
		MediaOptimization: &configMediaOptimization{
			Formats: []string{
				"avif",
				"jpeg",
			},
			Widths: []int{800, 1400, 2000},
		},
	}
}

func createDefaultBlog() *configBlog {
	return &configBlog{
		Path:        "/",
		Lang:        "en",
		Title:       "My Blog",
		Description: "Welcome to my blog.",
		Taxonomies: []*configTaxonomy{
			{
				Name:  "tags",
				Title: "Tags",
			},
		},
	}
}

func createDefaultSections() map[string]*configSection {
	return map[string]*configSection{
		"posts": {
			Title: "Posts",
		},
	}
}

func (a *goBlog) useSecureCookies() bool {
	return a.cfg.Server.SecurityHeaders || strings.HasPrefix(a.cfg.Server.PublicAddress, "https")
}

func (a *goBlog) getBlog(r *http.Request) (string, *configBlog) {
	if r == nil {
		return a.cfg.DefaultBlog, a.cfg.Blogs[a.cfg.DefaultBlog]
	}
	blog := a.cfg.DefaultBlog
	if ctxBlog := r.Context().Value(blogKey); ctxBlog != nil {
		if ctxBlogString, ok := ctxBlog.(string); ok {
			blog = ctxBlogString
		}
	}
	return blog, a.cfg.Blogs[blog]
}

func (a *goBlog) getBlogFromPost(p *post) *configBlog {
	return a.cfg.Blogs[cmp.Or(p.Blog, a.cfg.DefaultBlog)]
}

func (a *goBlog) isLocalURL(urlStr string) bool {
	if strings.HasPrefix(urlStr, a.cfg.Server.PublicAddress) {
		return true
	}
	if a.cfg.Server.ShortPublicAddress != "" && strings.HasPrefix(urlStr, a.cfg.Server.ShortPublicAddress) {
		return true
	}
	for _, altDomain := range a.cfg.Server.AltAddresses {
		if strings.HasPrefix(urlStr, altDomain) {
			return true
		}
	}
	return false
}