main.go

package main

import (
	_ "embed"
	"flag"
	"fmt"
	"log"
	_ "net/http/pprof"
	"os"
	"os/signal"
	"runtime"
	"slices"
	"strings"
	"syscall"
	"time"
	_ "time/tzdata"

	"github.com/mkmccarty/TokenTimeBoostBot/src/ai"
	"github.com/mkmccarty/TokenTimeBoostBot/src/boost"
	"github.com/mkmccarty/TokenTimeBoostBot/src/bottools"
	"github.com/mkmccarty/TokenTimeBoostBot/src/config"
	"github.com/mkmccarty/TokenTimeBoostBot/src/dashboard"
	"github.com/mkmccarty/TokenTimeBoostBot/src/dc"
	"github.com/mkmccarty/TokenTimeBoostBot/src/eb"
	"github.com/mkmccarty/TokenTimeBoostBot/src/ei"
	"github.com/mkmccarty/TokenTimeBoostBot/src/events"
	"github.com/mkmccarty/TokenTimeBoostBot/src/farmerstate"
	"github.com/mkmccarty/TokenTimeBoostBot/src/guildstate"
	"github.com/mkmccarty/TokenTimeBoostBot/src/launch"
	"github.com/mkmccarty/TokenTimeBoostBot/src/leaderboard"
	"github.com/mkmccarty/TokenTimeBoostBot/src/mint"
	"github.com/mkmccarty/TokenTimeBoostBot/src/server"
	"github.com/mkmccarty/TokenTimeBoostBot/src/tasks"
	"github.com/mkmccarty/TokenTimeBoostBot/src/version"
	"github.com/mkmccarty/TokenTimeBoostBot/src/virtue"
	"github.com/mkmccarty/TokenTimeBoostBot/src/watch"
	"github.com/natefinch/lumberjack/v3"
)

const (
	configFileName         = ".config.json"
	statusMessagesFileName = "ttbb-data/status-messages.json"
)

const (
	unknownCommandPathMessage   = "Unknown command path. Please run the command again, or use /help if this persists."
	unknownModalPathMessage     = "Unknown modal action. Please rerun the related command to open a fresh dialog."
	unknownComponentPathMessage = "Unknown interaction action. Use the latest message buttons/menus, or rerun the command."
)

// Admin Slash Command Constants
const slashAdminContractsList string = "admin-contract-list"
const slashAdminCoordinator string = "admin-coordinator"
const slashReloadContracts string = "admin-reload-contracts"
const slashAdminGetContractData string = "admin-get-contract-data"
const slashAdminListRoles string = "list-roles"
const slashAdminSetGuildSetting string = "admin-set-guild-setting"
const slashAdminGetGuildSettings string = "admin-get-guild-settings"
const slashAdminSetGuildFlag string = "admin-set-guild-flag"
const slashAdminGetGuildFlag string = "admin-get-guild-flag"
const slashAdminGuildstate string = "admin-guildstate"
const slashAdminMembers string = "admin-members"
const slashAdminForceDownload string = "admin-force-download"
const slashAdminSetServerBanner string = "admin-set-server-banner"
const slashSetServerBanner string = "set-server-banner"
const slashActiveContracts string = "active-contracts"
const slashStatusMessage string = "status-message"
const slashAdminExit string = "admin-exit"
const slashAdminTasks string = "admin-tasks"

// Slash Command Constants
const slashContract string = "contract"
const slashSkip string = "skip"
const slashBoost string = "boost"
const slashBoostOrder string = "boost-order"
const slashCatalyst string = "catalyst"
const slashChangeOneBooster string = "change-one-booster"
const slashChangePlannedStartCommand string = "change-start"
const slashChangeSpeedRunSink string = "change-speedrun-sink"
const slashChangeCommand string = "change"
const slashUpdateCommand string = "update"
const slashUnboost string = "unboost"
const slashPrune string = "prune"
const slashJoinContract string = "join-contract"
const slashSetEggIncName string = "seteggincname"
const slashBump string = "bump"
const slashBumpCR string = "bump-cr"
const slashToggleContractPings string = "toggle-contract-pings"
const slashContractSettings string = "contract-settings"
const slashHelp string = "help"
const slashSpeedrun string = "speedrun"
const slashCoopETA string = "coopeta"
const slashLaunchHelper string = "launch-helper"
const slashLaunchPlanner string = "launch-planner"
const slashEventHelper string = "events"

// const slashTokenRemove string = "token-remove"
const slashTokenEdit string = "token-edit"
const slashCalcContractTval string = "calc-contract-tval"
const slashCoopTval string = "coop-tval"
const slashVolunteerSink string = "volunteer-sink"
const slashVoluntellSink string = "voluntell-sink"
const slashLinkAlternate string = "link-alternate"

//go:embed doc/CustomBoostOrder.md
var customBoostOrderDoc []byte

const slashBoostOrderHelpers string = "boost-order-helpers"
const slashCustomBoostOrder string = "custom-boost-order"
const slashTeamworkEval string = "teamwork"
const slashEstimateTime string = "estimate-contract-time"
const slashCsEstimate string = "cs-estimate"
const slashLobby string = "lobby"
const slashRenameThread string = "rename-thread"
const slashFun string = "fun"
const slashStones string = "stones"
const slashLeaderboard string = "leaderboard"
const slashTimer string = "timer"
const slashDashboard string = "dashboard"
const slashArtifact string = "artifact"
const slashScoreExplorer string = "score-explorer"
const slashRemoveDMMessage string = "remove-dm-message"
const slashPrivacy string = "privacy"
const slashRerun string = "rerun"
const slashRerunEval string = "rerun-eval"
const slashContractReport string = "contract-report"
const slashContractScores string = "contract-scores"
const slashVirtue string = "virtue"
const slashEb string = "eb"
const slashRegister string = "register"
const slashRegisterAlt string = "register-alt"
const slashPredictions string = "predictions"
const slashPred string = "pred"
const slashMint string = "mint"
const slashUploadBanner string = "upload-banner"
const slashAvailability string = "availability"
const slashAdminLB string = "admin-lb"
const slashLBPlayer string = "lb"
const slashChill string = "chill"
const slashRoll string = "roll"
const slashWatch string = "watch"
const slashActAs string = "act-as"

// const slashSignup string = "signup"
var bot = dc.NewBot()

// gatewayIntents is the event subscription the bot identifies with.
const gatewayIntents = dc.IntentGuilds |
	dc.IntentGuildMessages |
	dc.IntentDirectMessages |
	dc.IntentGuildMessageReactions |
	dc.IntentDirectMessageReactions

// Version is set by the build system
var Version = "development"

var debugLogging = true

func init() {
	// Read values from .env file
	err := config.ReadConfig(configFileName)
	if err != nil {
		log.Println(err.Error())
		return
	}

	// Only logg to a file when not using the dev bot
	if !config.IsDevBot() {

		l, _ := lumberjack.NewRoller(fmt.Sprintf("%s/BoostBot.log", "ttbb-data"),
			1*1024*1024, // 1 megabyte
			&lumberjack.Options{
				MaxBackups: 12,
				MaxAge:     28 * time.Hour * 24, // 28 days
				Compress:   false,
			})
		log.SetOutput(l)
		c := make(chan os.Signal, 1)
		signal.Notify(c, syscall.SIGHUP)

		safeGo("logrotate-sighup", func() {
			for {
				<-c
				_ = l.Rotate()
			}
		})
	}

	version.Version = Version
	log.Printf("Starting Discord Bot: %s (%s)\n", version.Release, Version)
	// For the daemon Log
	fmt.Printf("Starting Discord Bot: %s (%s) at %s\n", version.Release, Version, time.Now().Format(time.RFC3339))

	// Load status messages
	ei.LoadStatusMessages(statusMessagesFileName)

	// Wire the coop status fix check to avoid import cycle in ei package
	ei.CoopStatusFixEnabled = func() bool {
		return guildstate.GetGuildSettingString("DEFAULT", "coop_status_fix") == "1"
	}

	// Wire the suspect mission handler to avoid import cycle in ei package
	ei.SuspectMissionHandler = func(discordID string, mission *ei.MissionInfo, baseSeconds float64, actualSeconds float64, eventMultiplier float64) {
		_ = farmerstate.InsertSuspectMission(farmerstate.InsertSuspectMissionParams{
			UserID:           discordID,
			MissionID:        mission.GetIdentifier(),
			Ship:             int64(mission.GetShip()),
			Status:           int64(mission.GetStatus()),
			DurationType:     int64(mission.GetDurationType()),
			MissionType:      int64(mission.GetType()),
			Level:            int64(mission.GetLevel()),
			Capacity:         int64(mission.GetCapacity()),
			QualityBump:      float64(mission.GetQualityBump()),
			TargetArtifact:   int64(mission.GetTargetArtifact()),
			DurationSeconds:  actualSeconds,
			StartTimeDerived: float64(mission.GetStartTimeDerived()),
			BaseSeconds:      baseSeconds,
			EventMultiplier:  eventMultiplier,
		})
	}

	// Read application parameters
	flag.Parse()

	if *BotToken == "" {
		BotToken = &config.DiscordToken
	}

	if *AppID == "" {
		AppID = &config.DiscordAppID
	}

	if *GuildID == "" {
		GuildID = &config.DiscordGuildID
	}

	bottools.SyncCustomBannerCallback = farmerstate.SyncCustomBanner
	bottools.RefreshGuildContractsForBannerCallback = func(guildID string) {
		boost.RefreshGuildContractsForBannerUpdate(botClient(), guildID)
	}
}

func init() {
	boost.SetCustomBoostOrderDoc(customBoostOrderDoc)

	// if ttbb-data directory doesn't exist, create it
	if _, err := os.Stat("ttbb-data"); os.IsNotExist(err) {
		err := os.Mkdir("ttbb-data", 0755)
		if err != nil {
			log.Print(err)
		}
	}
}

// Bot parameters to override .config.json parameters
var (
	GuildID        = flag.String("guild", "", "Test guild ID")
	BotToken       = flag.String("token", "", "Bot access token")
	AppID          = flag.String("app", "", "Application ID")
	RemoveCommands = flag.Bool("rmcmd", false, "Remove all commands after shutdowning or not")

	commandRegistry []CommandDef
	adminCommands   []*dc.Command
	globalCommands  []*dc.Command
	commands        []*dc.Command

	// Define the handlers for modal submissions
	modalHandlers = map[string]func(*dc.ModalEvent){
		"m_eggid":         boost.HandleEggIDModalSubmit,
		"m_threshold":     func(e *dc.ModalEvent) { boost.HandleThresholdModalSubmit(botClient(), e) },
		"m_custom_order":  func(e *dc.ModalEvent) { boost.HandleCustomOrderModalSubmit(botClient(), e) },
		"m_define_order":  func(e *dc.ModalEvent) { boost.HandleDefineCustomOrderModalSubmit(botClient(), e) },
		"m_save_order":    func(e *dc.ModalEvent) { boost.HandleSaveCustomOrderModalSubmit(botClient(), e) },
		"m_publish_order": func(e *dc.ModalEvent) { boost.HandlePublishCustomOrderModalSubmit(botClient(), e) },
		"m_actas_reg":     func(e *dc.ModalEvent) { farmerstate.HandleActAsRegisterModalSubmit(botClient(), e) },
	}

	// Define the handlers for component interactions
	componentHandlers = map[string]func(*dc.ComponentEvent){
		"fd_tokens4": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 4, 0)
		},
		"fd_tokens5": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 5, 0)
		},
		"fd_tokens6": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 6, 0)
		},
		"fd_tokens8": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 8, 0)
		},
		"fd_tokens1": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 0, 1)
		},
		"fd_tokens_sub": func(e *dc.ComponentEvent) {
			boost.AddBoostTokensInteraction(botClient(), e, 0, -1)
		},
		"fd_restart":              func(e *dc.ComponentEvent) { boost.HandleRestartContract(botClient(), e) },
		"fd_delete":               func(e *dc.ComponentEvent) { boost.HandleContractDelete(botClient(), e) },
		"rc_":                     func(e *dc.ComponentEvent) { boost.HandleContractReactions(botClient(), e) },
		"menu":                    func(e *dc.ComponentEvent) { boost.HandleMenuReactions(botClient(), e) },
		"cs_":                     func(e *dc.ComponentEvent) { boost.HandleContractSettingsReactions(botClient(), e) },
		"as_":                     func(e *dc.ComponentEvent) { boost.HandleArtifactReactions(botClient(), e) },
		"fd_stones":               func(e *dc.ComponentEvent) { boost.HandleStonesPage(botClient(), e) },
		"fd_teamwork":             boost.HandleTeamworkPage,
		"fd_playground":           boost.HandleScoreExplorerPage,
		"bo_order":                func(e *dc.ComponentEvent) { boost.HandleBoostOrderReactions(botClient(), e) },
		"bo_custom":               func(e *dc.ComponentEvent) { boost.HandleCustomOrderReactions(botClient(), e) },
		"bo_define":               func(e *dc.ComponentEvent) { boost.HandleDefineCustomOrderReactions(botClient(), e) },
		"predictions":             boost.HandlePredictionsPage,
		"pred":                    func(e *dc.ComponentEvent) { boost.HandlePredPage(botClient(), e) },
		"leaderboard":             boost.HandleLeaderboardPage,
		"active-contracts":        func(e *dc.ComponentEvent) { boost.HandleActiveContractsPage(botClient(), e) },
		"admin-contract-list":     func(e *dc.ComponentEvent) { boost.HandleAdminContractListComponent(botClient(), e) },
		"admin_exit":              func(e *dc.ComponentEvent) { boost.HandleAdminExitButton(botClient(), e) },
		"privacy_btn":             farmerstate.HandlePrivacyButton,
		"fd_signupStart":          func(e *dc.ComponentEvent) { boost.HandleSignupStart(botClient(), e) },
		"fd_signupFarmer":         func(e *dc.ComponentEvent) { boost.HandleSignupFarmer(botClient(), e) },
		"fd_signupBell":           func(e *dc.ComponentEvent) { boost.HandleSignupBell(botClient(), e) },
		"fd_signupLeave":          func(e *dc.ComponentEvent) { boost.HandleSignupLeave(botClient(), e) },
		"csestimate":              boost.HandleCsEstimateButtons,
		"lobby":                   func(e *dc.ComponentEvent) { boost.HandleLobbyButtons(botClient(), e) },
		"coop_status":             boost.HandleCoopStatusPermissionButton,
		"leaderboard_perm":        boost.HandleLeaderboardPermissionButton,
		"timer_btn":               func(e *dc.ComponentEvent) { dashboard.HandleTimerInteraction(botClient(), e) },
		"dashboard_btn":           func(e *dc.ComponentEvent) { dashboard.HandleDashboardComponent(botClient(), e) },
		"mint_preview":            mint.HandleMintPreview,
		"chart":                   boost.HandleChartReactions,
		"lb_list":                 leaderboard.HandleLBListComponent,
		"lb_stats":                leaderboard.HandleLBStatsComponent,
		"lb_p":                    leaderboard.HandleLBPageButton,
		"watch-dismiss":           func(e *dc.ComponentEvent) { watch.HandleDismiss(botClient(), e) },
		"watch-keep":              watch.HandleKeep,
		"launch_planner":          launch.HandleLaunchPlannerComponent,
		"watch-clear":             watch.HandleClear,
		"watch-page":              watch.HandlePage,
		"watch-page-first":        watch.HandlePage,
		"watch-page-prev":         watch.HandlePage,
		"watch-page-next":         watch.HandlePage,
		"watch-page-last":         watch.HandlePage,
		"watch-page-cancel":       watch.HandlePage,
		"watch-toggle-sort":       watch.HandleToggleSort,
		"watch-toggle-ultra":      watch.HandleToggleUltra,
		"watch-clear-confirm":     watch.HandleClearConfirm,
		"watch-test-contract":     func(e *dc.ComponentEvent) { watch.HandleTestContract(botClient(), e) },
		"watch-test-colleggtible": func(e *dc.ComponentEvent) { watch.HandleTestColleggtible(botClient(), e) },
	}
)

// CommandCategory represents the category of a Discord application command
type CommandCategory string

const (
	// CmdCategoryStandard represents a standard command available to all users
	CmdCategoryStandard CommandCategory = "standard"
	// CmdCategoryGlobal represents a global command available to all users
	CmdCategoryGlobal CommandCategory = "global"
	// CmdCategoryAdmin represents an admin command available to administrators
	CmdCategoryAdmin CommandCategory = "admin"
)

// CommandDef represents a Discord application command definition
type CommandDef struct {
	AppCmd       *dc.Command
	Category     CommandCategory
	Handler      func(*dc.CommandEvent)
	Autocomplete func(*dc.AutocompleteEvent)
}

// botClient is the facade's REST surface for the running gateway session. The
// component and command closures below call it lazily because the session is
// not open when the handler table is built.
func botClient() dc.Client {
	return bot.Client()
}

func setupCommands() {
	commandRegistry = []CommandDef{
		// Admin Commands
		{
			AppCmd:   boost.GetSlashAdminContractsListCommand(slashAdminContractsList),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { boost.HandleAdminContractList(botClient(), e) },
		},
		{
			AppCmd:   tasks.GetSlashReloadContractsCommand(slashReloadContracts),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { tasks.HandleReloadContracts(botClient(), e) },
		},
		{
			AppCmd:   tasks.GetSlashForceDownloadCommand(slashAdminForceDownload),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { tasks.HandleForceDownload(botClient(), e) },
		},
		{
			AppCmd:       boost.SlashAdminGetContractData(slashAdminGetContractData),
			Category:     CmdCategoryAdmin,
			Handler:      boost.HandleAdminGetContractData,
			Autocomplete: boost.HandleCoopAutoComplete,
		},
		{
			AppCmd:       boost.SlashAdminListRoles(slashAdminListRoles),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { boost.HandleAdminListRoles(botClient(), e) },
			Autocomplete: boost.HandleContractAutoComplete,
		},
		{
			AppCmd:       boost.SlashAdminGuildStateCommand(slashAdminGuildstate),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { boost.HandleAdminGuildStateCommand(botClient(), e) },
			Autocomplete: func(e *dc.AutocompleteEvent) { boost.HandleAdminGuildStateAutoComplete(botClient(), e) },
		},
		{
			AppCmd:   boost.SlashAdminMembers(slashAdminMembers),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { boost.HandleAdminMembers(botClient(), e) },
		},
		{
			AppCmd:   guildstate.SlashCoordinatorsCommand(slashAdminCoordinator),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { guildstate.HandleCoordinators(botClient(), e) },
		},
		{
			AppCmd:   boost.SlashAdminCurrentContracts(slashActiveContracts),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { boost.HandleAdminCurrentContracts(botClient(), e) },
		},
		{
			AppCmd:       boost.SlashAdminStatusMessageCommand(slashStatusMessage),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { boost.HandleAdminStatusMessageCommand(botClient(), e) },
			Autocomplete: boost.HandleAdminStatusMessageAutoComplete,
		},
		{
			AppCmd:   boost.SlashAdminExitCommand(slashAdminExit),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { boost.HandleAdminExitCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.SlashAdminTasksCommand(slashAdminTasks),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { boost.HandleAdminTasksCommand(botClient(), e) },
			Autocomplete: boost.HandleAdminTasksAutocomplete,
		},
		{
			AppCmd:       guildstate.SlashSetGuildSettingCommand(slashAdminSetGuildSetting),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { guildstate.SetGuildSetting(botClient(), e) },
			Autocomplete: guildstate.HandleSetGuildSettingAutoComplete,
		},
		{
			AppCmd:   guildstate.SlashGetGuildSettingsCommand(slashAdminGetGuildSettings),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { guildstate.GetGuildSettings(botClient(), e) },
		},
		{
			AppCmd:       guildstate.SlashSetGuildFlagCommand(slashAdminSetGuildFlag),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { guildstate.SetGuildFlag(botClient(), e) },
			Autocomplete: guildstate.HandleGuildFlagAutoComplete,
		},
		{
			AppCmd:       guildstate.SlashGetGuildFlagCommand(slashAdminGetGuildFlag),
			Category:     CmdCategoryAdmin,
			Handler:      func(e *dc.CommandEvent) { guildstate.GetGuildFlag(botClient(), e) },
			Autocomplete: guildstate.HandleGuildFlagAutoComplete,
		},
		{
			AppCmd:   guildstate.SlashAdminSetServerBannerCommand(slashAdminSetServerBanner),
			Category: CmdCategoryAdmin,
			Handler:  func(e *dc.CommandEvent) { guildstate.HandleAdminSlashAdminSetServerBannerCommand(botClient(), e) },
		},
		{
			AppCmd:   guildstate.SlashSetServerBannerCommand(slashSetServerBanner),
			Category: CmdCategoryGlobal,
			Handler:  func(e *dc.CommandEvent) { guildstate.HandleSetServerBanner(botClient(), e) },
		},

		// Global Commands
		{
			AppCmd:   events.SlashLaunchHelperCommand(slashLaunchHelper),
			Category: CmdCategoryGlobal,
			Handler:  events.HandleLaunchHelperCommand,
		},
		{
			AppCmd:       launch.GetSlashLaunchPlannerCommand(slashLaunchPlanner),
			Category:     CmdCategoryGlobal,
			Handler:      launch.HandleLaunchPlannerCommand,
			Autocomplete: launch.HandleLaunchPlannerAutocomplete,
		},
		{
			AppCmd:   events.SlashEventHelperCommand(slashEventHelper),
			Category: CmdCategoryGlobal,
			Handler:  events.HandleEventHelperCommand,
		},
		{
			AppCmd:       boost.GetSlashRerunEvalCommand(slashRerunEval),
			Category:     CmdCategoryGlobal,
			Handler:      boost.HandleReplayEval,
			Autocomplete: boost.HandleRerunEvalAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashRerunEvalCommand(slashRerun),
			Category:     CmdCategoryGlobal,
			Handler:      boost.HandleReplayEval,
			Autocomplete: boost.HandleRerunEvalAutoComplete,
		},
		{
			AppCmd:       virtue.GetSlashVirtueCommand(slashVirtue),
			Category:     CmdCategoryGlobal,
			Handler:      virtue.HandleVirtue,
			Autocomplete: virtue.HandleVirtueAutocomplete,
		},
		{
			AppCmd:       eb.GetSlashEbCommand(slashEb),
			Category:     CmdCategoryGlobal,
			Handler:      eb.HandleEb,
			Autocomplete: eb.HandleEbAutocomplete,
		},
		{
			AppCmd:       farmerstate.GetSlashActAsCommand(slashActAs),
			Category:     CmdCategoryGlobal,
			Handler:      func(e *dc.CommandEvent) { farmerstate.HandleActAsCommand(botClient(), e) },
			Autocomplete: farmerstate.HandleActAsAutocomplete,
		},

		{
			AppCmd:   boost.GetSlashRegisterCommand(slashRegister),
			Category: CmdCategoryGlobal,
			Handler:  boost.HandleRegister,
		},
		{
			AppCmd:       boost.GetSlashRegisterAltCommand(slashRegisterAlt),
			Category:     CmdCategoryGlobal,
			Handler:      boost.HandleRegisterAlt,
			Autocomplete: boost.HandleRegisterAltAutocomplete,
		},

		// Standard Commands
		{
			AppCmd:       boost.GetSlashContractCommand(slashContract),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleContractCommand(botClient(), e) },
			Autocomplete: boost.HandleContractAutoComplete,
		},
		{
			AppCmd:   boost.GetSlashSpeedrunCommand(slashSpeedrun),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleSpeedrunCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashRenameThread(slashRenameThread),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleRenameThreadCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.SlashArtifactsCommand(slashArtifact),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleArtifactCommand(botClient(), e) },
			Autocomplete: boost.HandleArtifactAltAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashScoreExplorerCommand(slashScoreExplorer),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleScoreExplorerCommand,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:   boost.GetSlashChangeSpeedRunSinkCommand(slashChangeSpeedRunSink),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleChangeSpeedrunSinkCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashUpdateCommand(slashUpdateCommand),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleUpdateCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashChangeCommand(slashChangeCommand),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleChangeCommand(botClient(), e) },
			Autocomplete: boost.HandleContractAutoComplete,
		},
		{
			AppCmd:   boost.GetSlashJoinContractCommand(slashJoinContract),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleJoinCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashBoostCommand(slashBoost),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBoostCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashBoostOrderCommand(slashBoostOrder),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBoostOrderCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashBoostOrderCommand(slashCatalyst),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBoostOrderCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashSkipCommand(slashSkip),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleSkipCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashUnboostCommand(slashUnboost),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleUnboostCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashPruneCommand(slashPrune),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandlePruneCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashCoopETACommand(slashCoopETA),
			Category: CmdCategoryStandard,
			Handler:  boost.HandleCoopETACommand,
		},
		{
			AppCmd:   boost.GetSlashVolunteerSink(slashVolunteerSink),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleSlashVolunteerSinkCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashVoluntellSink(slashVoluntellSink),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleSlashVoluntellSinkCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashLinkAlternateCommand(slashLinkAlternate),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleLinkAlternateCommand(botClient(), e) },
			Autocomplete: boost.HandleLinkAlternateAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashCalcContractTval(slashCalcContractTval),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleContractCalcContractTvalCommand,
			Autocomplete: boost.HandleAltsAutoComplete,
		},
		{
			AppCmd:   boost.GetSlashCoopTval(slashCoopTval),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleCoopTvalCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashTeamworkEval(slashTeamworkEval),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleTeamworkEvalCommand,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashContractReportCommand(slashContractReport),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleContractReport,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashContractReportCommand(slashContractScores),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleContractReport,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:   boost.GetPredictionsCommand(slashPredictions),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandlePredictionsCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.GetPredCommand(slashPred),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandlePredCommand(botClient(), e) },
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashStones(slashStones),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleStonesCommand(botClient(), e) },
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashLeaderboard(slashLeaderboard),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleLeaderboard,
			Autocomplete: boost.HandleLeaderboardAutoComplete,
		},
		{
			AppCmd:   dashboard.GetSlashTimer(slashTimer),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { dashboard.HandleTimer(botClient(), e) },
		},
		{
			AppCmd:   dashboard.GetSlashDashboardCommand(slashDashboard),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { dashboard.HandleDashboard(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashEstimateTime(slashEstimateTime),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleEstimateTimeCommand,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashCsEstimates(slashCsEstimate),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleCsEstimatesCommand,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:       boost.GetSlashLobbyCommand(slashLobby),
			Category:     CmdCategoryStandard,
			Handler:      boost.HandleLobbyCommand,
			Autocomplete: boost.HandleAllContractsAutoComplete,
		},
		{
			AppCmd:   boost.GetSlashChangeOneBoosterCommand(slashChangeOneBooster),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleChangeOneBoosterCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashChangePlannedStartCommand(slashChangePlannedStartCommand),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleChangePlannedStartCommand(botClient(), e) },
		},
		{
			AppCmd:   bottools.GetSlashRemoveMessage(slashRemoveDMMessage),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { bottools.HandleRemoveMessage(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashTokenEditCommand(slashTokenEdit),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleTokenEditInteraction(botClient(), e) },
			Autocomplete: boost.HandleTokenEditAutoComplete,
		},
		{
			AppCmd:   farmerstate.SlashSetEggIncNameCommand(slashSetEggIncName),
			Category: CmdCategoryStandard,
			Handler: func(e *dc.CommandEvent) {
				farmerstate.HandleSetEggIncName(botClient(), e, boost.IsUserCreatorOfAnyContract)
			},
		},
		{
			AppCmd:       farmerstate.GetSlashPrivacyCommand(slashPrivacy),
			Category:     CmdCategoryStandard,
			Handler:      farmerstate.HandlePrivacy,
			Autocomplete: farmerstate.HandlePrivacyAutocomplete,
		},
		{
			AppCmd:   boost.GetSlashBumpCommand(slashBump),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBumpCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashBumpCRCommand(slashBumpCR),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBumpCRCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashToggleContractPingsCommand(slashToggleContractPings),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleToggleContractPingsCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashHelpCommand(slashHelp),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleHelpCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashContractSettingsCommand(slashContractSettings),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleContractSettingsCommand(botClient(), e) },
		},
		{
			AppCmd:   boost.GetSlashBoostOrderHelpersCommand(slashBoostOrderHelpers),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { boost.HandleBoostOrderHelpersCommand(botClient(), e) },
		},
		{
			AppCmd:       boost.GetSlashCustomBoostOrderCommand(slashCustomBoostOrder),
			Category:     CmdCategoryStandard,
			Handler:      func(e *dc.CommandEvent) { boost.HandleCustomBoostOrderCommand(botClient(), e) },
			Autocomplete: boost.HandleCustomBoostOrderAutoComplete,
		},
	}

	if !slices.Contains(config.FeatureFlags, "NO_FUN") {
		commandRegistry = append(commandRegistry, CommandDef{
			AppCmd:   ai.SlashFunCommand(slashFun),
			Category: CmdCategoryStandard,
			Handler:  func(e *dc.CommandEvent) { ai.HandleFun(botClient(), e) },
		})
	}

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:   mint.GetSlashMintCommand(slashMint),
		Category: CmdCategoryStandard,
		Handler:  mint.HandleMint,
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:   boost.GetSlashUploadBannerCommand(slashUploadBanner),
		Category: CmdCategoryStandard,
		Handler:  func(e *dc.CommandEvent) { boost.HandleUploadBannerCommand(botClient(), e) },
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:   boost.GetSlashAvailabilityCommand(slashAvailability),
		Category: CmdCategoryStandard,
		Handler:  func(e *dc.CommandEvent) { boost.HandleAvailabilityCommand(botClient(), e) },
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:   server.GetSlashChillCommand(slashChill),
		Category: CmdCategoryStandard,
		Handler:  server.HandleChillCommand,
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:   server.GetSlashChillCommand(slashRoll),
		Category: CmdCategoryStandard,
		Handler:  server.HandleChillCommand,
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:       leaderboard.GetSlashAdminLBCommand(slashAdminLB),
		Category:     CmdCategoryAdmin,
		Handler:      func(e *dc.CommandEvent) { leaderboard.HandleAdminLB(botClient(), e) },
		Autocomplete: leaderboard.HandleAdminLBAutoComplete,
	})
	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:       leaderboard.GetSlashLBPlayerCommand(slashLBPlayer),
		Category:     CmdCategoryStandard,
		Handler:      func(e *dc.CommandEvent) { leaderboard.HandleLBPlayer(botClient(), e) },
		Autocomplete: leaderboard.HandleLBPlayerAutoComplete,
	})

	commandRegistry = append(commandRegistry, CommandDef{
		AppCmd:       watch.GetSlashWatchCommand(slashWatch),
		Category:     CmdCategoryStandard,
		Handler:      watch.HandleWatch,
		Autocomplete: watch.HandleWatchAutoComplete,
	})

	for _, def := range commandRegistry {
		if def.Handler != nil {
			bot.OnCommand(def.AppCmd.Name, withCommandLogging(def.AppCmd.Name, def.Handler))
		}
		if def.Autocomplete != nil {
			bot.OnAutocomplete(def.AppCmd.Name, def.Autocomplete)
		}

		switch def.Category {
		case CmdCategoryAdmin:
			adminCommands = append(adminCommands, def.AppCmd)
		case CmdCategoryGlobal:
			globalCommands = append(globalCommands, def.AppCmd)
		case CmdCategoryStandard:
			commands = append(commands, def.AppCmd)
		}
	}

	for prefix, handler := range componentHandlers {
		bot.OnComponent(prefix, handler)
	}
	for prefix, handler := range modalHandlers {
		bot.OnModal(prefix, handler)
	}
}

// withCommandLogging logs the options a command was invoked with before
// running it, which is what the interaction dispatch used to do inline.
func withCommandLogging(name string, handler func(*dc.CommandEvent)) func(*dc.CommandEvent) {
	return func(e *dc.CommandEvent) {
		if debugLogging {
			if e.GuildID() != "" {
				log.Println("Command:", name, e.OptionSummary(), e.ChannelID(), e.UserID())
			} else {
				log.Println("Command-DM:", name, e.OptionSummary(), e.ChannelID(), e.UserID())
			}
		}
		handler(e)
	}
}

// respondUnknownRoute answers an interaction that matched no handler, so the
// user sees a message instead of "this application did not respond".
func respondUnknownRoute(e *dc.UnknownEvent) {
	meta := e.Meta()
	switch meta.Kind {
	case dc.KindCommand:
		log.Printf("Unknown command handler: %s", meta.Name)
		_ = e.Respond(dc.Message{Content: unknownCommandPathMessage, Ephemeral: true})
	case dc.KindAutocomplete:
		log.Printf("Unknown autocomplete handler: %s", meta.Name)
		_ = e.RespondChoices(nil)
	case dc.KindModal:
		log.Printf("Unknown modal handler: %s", meta.CustomID)
		_ = e.Respond(dc.Message{Content: unknownModalPathMessage, Ephemeral: true})
	case dc.KindComponent:
		log.Printf("Unknown component handler: %s", meta.CustomID)
		_ = e.Respond(dc.Message{Content: unknownComponentPathMessage, Ephemeral: true})
	}
}

// registerGatewayHandlers wires the non-interaction gateway events and the
// bot-wide hooks. Every one of these has to be in place before Connect.
func registerGatewayHandlers() {
	bot.OnUnknown(respondUnknownRoute)

	bot.OnPanic(func(recovered any, meta dc.InteractionMeta) {
		handlePanic("discord-interaction", recovered, interactionCrashMetadata(meta))
	})

	bot.OnReady(func() {
		log.Printf("Ready message for: %v (%v)", botClient().BotUsername(), bot.UserID())
	})

	bot.OnMessage(func(e *dc.MessageEvent) {
		defer recoverPanic("discord-message-create", 0, withSessionHints(map[string]string{
			"guild_id":   e.GuildID(),
			"channel_id": e.ChannelID(),
			"message_id": e.MessageID(),
			"author_id":  e.AuthorID(),
		}))

		mint.HandleMintCSVUpload(botClient(), e)
	})

	bot.OnReactionAdd(func(e *dc.ReactionEvent) {
		defer recoverPanic("discord-reaction-add", 0, withSessionHints(map[string]string{
			"guild_id":   e.GuildID(),
			"channel_id": e.ChannelID(),
			"message_id": e.MessageID(),
			"emoji":      e.EmojiRef(),
			"user_id":    e.UserID(),
		}))

		if e.UserID() != bot.UserID() && e.GuildID() != "" {
			boost.ReactionAdd(botClient(), e)
		}
	})

	bot.OnReactionRemove(func(e *dc.ReactionEvent) {
		if e.UserID() == bot.UserID() {
			return
		}
		safeGoMeta("reaction-remove", withSessionHints(map[string]string{
			"guild_id":   e.GuildID(),
			"channel_id": e.ChannelID(),
			"message_id": e.MessageID(),
			"emoji":      e.EmojiRef(),
			"user_id":    e.UserID(),
		}), func() {
			boost.ReactionRemove(botClient(), e)
		})
	})
}

func syncCommands(client dc.Client, appID, guildID string, desiredCommandList []*dc.Command) {
	existingCommands, err := client.ApplicationCommands(appID, guildID)
	if err != nil {
		log.Fatalf("Failed to fetch commands for guild %s: %v", guildID, err)
		return
	}

	desiredMap := make(map[string]*dc.Command)
	for _, cmd := range desiredCommandList {
		desiredMap[cmd.Name] = cmd
	}

	// Delete commands not in the desired list
	for _, cmd := range existingCommands {
		if _, found := desiredMap[cmd.Name]; !found {
			err := client.DeleteApplicationCommand(appID, guildID, cmd.ID)
			if err != nil {
				log.Printf("Failed to delete command %s (%s) in guild %s: %v", cmd.Name, cmd.ID, guildID, err)
			} else {
				log.Printf("Successfully deleted command %s (%s) in guild %s", cmd.Name, cmd.ID, guildID)
			}
		}
	}

	payload := make([]dc.Command, 0, len(desiredCommandList))
	for _, cmd := range desiredCommandList {
		payload = append(payload, *cmd)
	}

	published, err := client.BulkOverwriteApplicationCommands(appID, guildID, payload)
	if err != nil {
		log.Fatalf("Failed to bulk overwrite commands for guild %s: %v", guildID, err)
	} else {
		bottools.UpdateCommandMap(desiredCommandList, published)
	}
}

func connectWithRetry() error {
	var err error
	backoff := time.Second * 2

	for range 5 {
		err = bot.Open()
		if err == nil {
			return nil
		}

		log.Printf("Conn failed: %v. Retrying in %v...", err, backoff)
		time.Sleep(backoff)
		backoff *= 2 // Exponentially increase wait time
	}
	return fmt.Errorf("could not connect after multiple attempts: %w", err)
}

func main() {
	defer handleCrash()

	setupCommands()

	/*
		go func() {
			log.Println(http.ListenAndServe("localhost:6060", nil))
		}()
	*/
	// Init Mongodb
	//db.Open()
	//defer db.Close()
	//bottools.GenerateBanner("EDIBLE", "Race Fuel")
	// Load the config file

	registerGatewayHandlers()

	if err := bot.Connect(*BotToken, gatewayIntents); err != nil {
		log.Fatalf("Invalid bot parameters: %v", err)
	}

	// Start our CRON job to grab Egg Inc contract data from the Carpet github repository
	startHeartbeat("/tmp/tokentimeboost.heartbeat", 1*time.Minute)
	safeGoMeta("cron-job", withSessionHints(map[string]string{
		"job": "tasks.ExecuteCronJob",
	}), func() {
		tasks.ExecuteCronJob(botClient())
	})

	if err := connectWithRetry(); err != nil {
		log.Fatalf("Cannot open the session: %v", err)
	}

	bottools.LoadEmotesWithClient(botClient(), false)
	dashboard.LaunchIndependentTimers(botClient())

	_ = bot.SetPresence(fmt.Sprintf("Starting: %s", Version))

	commandSet := append(commands, globalCommands...)

	commandSet = append(commandSet, adminCommands...)

	// Restrict some commands to a specific guild if the home_guild setting is set, to allow for faster iteration during development without affecting the global command set that everyone uses
	homeGuild := guildstate.GetGuildSettingString("DEFAULT", "home_guild")
	if homeGuild == "" {
		homeGuild = "DISABLED"
	}

	var homeGuildCommandSet []*dc.Command
	var filteredCommandSet []*dc.Command
	for _, cmd := range commandSet {
		if homeGuild != "" && cmd.GuildID == homeGuild {
			homeGuildCommandSet = append(homeGuildCommandSet, cmd)
		} else {
			filteredCommandSet = append(filteredCommandSet, cmd)
		}
	}
	commandSet = filteredCommandSet

	if homeGuild != "DISABLED" {
		syncCommands(botClient(), bot.UserID(), homeGuild, homeGuildCommandSet)
	}
	syncCommands(botClient(), bot.UserID(), config.DiscordGuildID, commandSet)

	safeGoMeta("admin-exit-restart", nil, func() {
		boost.CheckAndNotifyAdminExitRestart(botClient())
	})

	defer func() {
		if err := bot.Close(); err != nil {
			// Handle the error appropriately, e.g., logging or taking corrective actions
			log.Printf("Failed to close: %v", err)
		}
	}()

	safeGoMeta("file-watcher", withSessionHints(map[string]string{
		"watch_files": strings.Join([]string{configFileName, statusMessagesFileName}, ","),
	}), func() {
		ticker := time.NewTicker(60 * time.Second)
		defer ticker.Stop()

		lastModTimes := make(map[string]time.Time)
		filesToWatch := []string{configFileName, statusMessagesFileName}

		for _, f := range filesToWatch {
			if info, err := os.Stat(f); err == nil {
				lastModTimes[f] = info.ModTime()
			}
		}

		for range ticker.C {
			for _, f := range filesToWatch {
				info, err := os.Stat(f)
				if err != nil {
					continue // File might be temporarily missing during atomic saves
				}

				modTime := info.ModTime()
				lastModTime, exists := lastModTimes[f]

				if !exists || modTime.After(lastModTime) {
					lastModTimes[f] = modTime
					log.Println("modified file:", f)

					switch f {
					case configFileName:
						_ = config.ReadConfig(f)
					case statusMessagesFileName:
						ei.LoadStatusMessages(f)
					}
				}
			}
		}

	})

	stop := make(chan os.Signal, 1)
	signal.Notify(stop, os.Interrupt, syscall.SIGTERM, syscall.SIGINT, syscall.SIGHUP)
	log.Println("Press Ctrl+C to exit")

	<-stop

	boost.SaveAllData()

	log.Println("Graceful shutdown")
}

// Heartbeat function to update the modification time of a file at regular intervals
func startHeartbeat(filepath string, interval time.Duration) {
	safeGoMeta("heartbeat", withSessionHints(map[string]string{
		"heartbeat_path":     filepath,
		"heartbeat_interval": interval.String(),
	}), func() {
		// Create the file if it doesn't exist
		if _, err := os.Stat(filepath); os.IsNotExist(err) {
			f, err := os.Create(filepath)
			if err != nil {
				log.Printf("Heartbeat error: Could not create file: %v", err)
				return
			}
			_ = f.Close()
		}

		counter := 0
		consecutivePresenceFailures := 0
		const maxConsecutivePresenceFailures = 5

		ticker := time.NewTicker(interval)
		for range ticker.C {
			currentTime := time.Now()
			// Equivalent to 'touch' - updates modification time
			err := os.Chtimes(filepath, currentTime, currentTime)
			if err != nil {
				log.Printf("Heartbeat error: %v", err)
			}
			counter++
			if counter%10 == 0 {
				var m runtime.MemStats
				runtime.ReadMemStats(&m)
				log.Printf("Heartbeat stats: Alloc=%dMB, Sys=%dMB, Goroutines=%d", m.Alloc/1024/1024, m.Sys/1024/1024, runtime.NumGoroutine())
			}
			if counter%2 == 1 {
				// Get a random status message
				activityName, err := ei.GetRandomStatusMessage()
				if err != nil {
					log.Printf("Error getting status message: %v", err)
					activityName = "Egg, Inc."
				}

				err = bot.SetPresence(activityName)
				if err != nil {
					consecutivePresenceFailures++
					log.Printf("Heartbeat: SetPresence failed (%d/%d): %v", consecutivePresenceFailures, maxConsecutivePresenceFailures, err)
					if consecutivePresenceFailures < maxConsecutivePresenceFailures {
						// Gateway may be reconnecting/resuming, allow time to recover
						continue
					}

					log.Printf("Restarting the bot due to %d consecutive presence failures: %v", consecutivePresenceFailures, err)
					fmt.Printf("Restarting the bot due to error: %v\n", err)
					// At this point lets just exit the process and let something like systemd restart it, since the bot is likely in a bad state if we can't update the status
					// At this point, trigger a graceful shutdown so deferred cleanups (including s.Close()) run.
					boost.SaveAllData()
					// Sleep 5 seconds to allow any in-flight interactions to complete and for the save functions to finish
					time.Sleep(5 * time.Second)
					// Signal the current process to initiate the normal shutdown path instead of calling os.Exit directly.
					if serr := syscall.Kill(os.Getpid(), syscall.SIGTERM); serr != nil {
						log.Printf("Heartbeat error: could not signal shutdown (forcing exit): %v", serr)
						os.Exit(1)
					}
					return
				}
				consecutivePresenceFailures = 0
			}
		}
	})
}