server

type ApiHandler struct {
	AuthMiddleware *httpauth.Middleware
	ClientMgr      *services.ClientMgr

	// Here we can have to ways of accessing the services - either via clients or by actual service instead if you are not
	// running the services on a dedicated port
	DisableIndexer       bool
	DisableGamesService  bool
	DisableWorldsService bool
	// contains filtered or unexported fields
}

type AttackSimulatorPage struct {
	BasePage
	Header Header

	// URL parameters for pre-populating form
	AttackerUnit    string
	AttackerTerrain string
	AttackerHealth  string
	DefenderUnit    string
	DefenderTerrain string
	DefenderHealth  string
	WoundBonus      string
	NumSimulations  string

	// Terrain and unit data for dropdowns
	AllTerrains []TerrainType
	AllUnits    []UnitType
	Theme       string
}

type BasePage struct {
	goal.BasePage
}

type ConnectGameSyncServiceAdapter struct {
	// contains filtered or unexported fields
}

type ConnectGamesServiceAdapter struct {
	// contains filtered or unexported fields
}

type ConnectIndexerServiceAdapter struct {
	// contains filtered or unexported fields
}

type ConnectWorldsServiceAdapter struct {
	// contains filtered or unexported fields
}

type CrossingType struct {
	ID          string `json:"id"`   // "road" or "bridge"
	Name        string `json:"name"` // Display name
	IconDataURL string `json:"iconDataURL"`
}

type FixSimulatorPage struct {
	BasePage
	Header Header

	// URL parameters for pre-populating form
	FixingUnit       string
	FixingUnitHealth string
	InjuredUnit      string
	NumSimulations   string

	// Units data for dropdowns
	// FixingUnits only includes units with fix_value > 0
	FixingUnits []UnitType
	// AllUnits includes all units (for injured unit dropdown)
	AllUnits []UnitType
	Theme    string
}

type ForbiddenPage struct {
	BasePage
	Header  Header
	Message string
}

type ForgotPasswordPage struct {
	BasePage
	CustomHeader bool
	Sent         bool
}

type GameCreatorPage struct {
	BasePage
	Header        Header
	Game          *protos.Game
	Errors        map[string]string
	AllowCustomId bool
}

type GameDetailPage struct {
	BasePage
	Header Header
	Game   *protos.Game
	GameId string
}

type GameListView struct {
	goal.WithPagination
	goal.WithFiltering

	Games []*protos.Game
}

type GameListingPage struct {
	BasePage
	Header Header

	GameListView GameListView
	ListingData  *goal.EntityListingData[*protos.Game]
}

type GameViewerPage struct {
	BasePage
	Header      Header
	GameId      string
	WorldId     string
	Game        *protos.Game
	GameState   *protos.GameState
	GameHistory *protos.GameMoveHistory

	// Game creation parameters from URL
	PlayerCount      int
	MaxTurns         int
	UnitRestrictions map[string]string // unitId -> restriction level

	WasmExecJsPath string
	WasmBundlePath string

	// Viewer context for Join functionality
	ViewerUserId string
}

type GamesGroup struct {
	// contains filtered or unexported fields
}

type GenericPage struct {
	BasePage
	Header Header
}

type Header struct {
	AppName             string
	PageData            any
	HeaderLogo          func() template.HTML
	LogoTitle           string
	Styles              map[string]any
	Width               string
	HeaderStyleLink     string
	MenuStyleLink       string
	FixedHeader         bool
	ShowHomeButton      bool
	ShowComposeButton   bool
	ShowLoginButton     bool
	ShowLogoutButton    bool
	HomeButtonImage     string
	CenterMenuItems     []HeaderMenuItem
	SpecialMenuItems    []HeaderMenuItem
	RightMenuItems      []HeaderMenuItem
	HideCenterMenuItems bool
	IsLoggedIn          bool
	LoggedInUserId      string
	Username            string
	DisplayName         string // Shown in header: Nickname -> Name -> UserID
}

type HeaderMenuItem struct {
	Id            string
	Title         string
	Link          string
	Class         string
	LowWidthClass string
	Raw           string
	OnClick       string
	Attributes    map[string]string
}

type HomePage struct {
	BasePage
	Header Header

	// Dashboard data
	RecentGames  []*v1.Game
	RecentWorlds []*v1.World
	TotalGames   int32
	TotalWorlds  int32
}

type IndexerAppServer struct {
	goal.WebAppServer
}

type LilBattleApp struct {
	// Auth
	Auth           *httpauth.OneAuth
	AuthMiddleware *httpauth.Middleware
	AuthService    *goalservices.AuthService
	UsernameStore  accounts.UsernameStore // Username → UserID mapping for login alias
	Session        *scs.SessionManager

	// Services
	Api       *ApiHandler
	ClientMgr *services.ClientMgr

	// Views (thin wrapper for page routing)
	ViewsRoot *RootViewsHandler

	// App config
	HideGames  bool
	HideWorlds bool

	// Ad config - all default to enabled, can be disabled per-placement
	AdsEnabled        bool   // Master switch: LILBATTLE_ADS_ENABLED (default: true)
	AdsFooterEnabled  bool   // Footer banner: LILBATTLE_ADS_FOOTER (default: true)
	AdsHomeEnabled    bool   // Homepage mid-section: LILBATTLE_ADS_HOME (default: true)
	AdsListingEnabled bool   // Listing pages: LILBATTLE_ADS_LISTING (default: true)
	AdNetworkId       string // Google AdSense publisher ID: LILBATTLE_AD_NETWORK_ID
	AdSlotId          string // Google AdSense ad unit slot ID: LILBATTLE_AD_SLOT_ID

	BaseUrl string
	// contains filtered or unexported fields
}

type LoginPage struct {
	goal.SampleLoginPage[*LilBattleApp]
	Header             Header
	EnableTwitterLogin bool
}

type NotFoundPage struct {
	BasePage
	Header Header
	Path   string
}

type PrivacyPolicy struct {
	BasePage
	Header Header
}

type ProfilePage struct {
	goal.SampleProfilePage[*LilBattleApp]
	Header Header

	// App-specific user information
	User accounts.User

	// Username fields - for login alias (stored in UsernameStore)
	UsernameNeeded bool // True if user hasn't set a username yet

	// Nickname fields (Nickname is in SampleProfilePage base)
	NicknameNeeded    bool   // True if user needs to set their nickname
	SuggestedNickname string // Random suggestion for nickname

	// Password availability
	HasLocalAuth bool // True if user has an email identity (can potentially have password)
	HasPassword  bool // True if user has a local channel with password set
}

type RegisterPage struct {
	goal.SampleRegisterPage[*LilBattleApp]
	Header Header
}

type ResendEmailSender struct {
	// contains filtered or unexported fields
}

type ResetPasswordPage struct {
	BasePage
	CustomHeader bool
	Token        string
	InvalidToken bool
	Success      bool
	Error        string
}

type RootViewsHandler struct {
	LilBattleApp *LilBattleApp            // Pure app context
	GoalApp      *goal.App[*LilBattleApp] // goal.App wrapper for templates/rendering
	// contains filtered or unexported fields
}

type RulesGroup struct{}

type SecurityHeadersMiddleware struct {
	// IsDevelopment disables some strict policies for local development
	IsDevelopment bool
}

type SelectWorldPage struct {
	BasePage
	Header        Header
	WorldListView WorldListView
}

type SitemapIndex struct {
	XMLName  xml.Name            `xml:"sitemapindex"`
	XMLNS    string              `xml:"xmlns,attr"`
	Sitemaps []SitemapIndexEntry `xml:"sitemap"`
}

type SitemapIndexEntry struct {
	Loc     string `xml:"loc"`
	LastMod string `xml:"lastmod,omitempty"`
}

type SitemapURL struct {
	Loc        string `xml:"loc"`
	LastMod    string `xml:"lastmod,omitempty"`
	ChangeFreq string `xml:"changefreq,omitempty"`
	Priority   string `xml:"priority,omitempty"`
}

type StartGamePage struct {
	BasePage
	Header            Header
	World             *protos.World
	WorldData         *protos.WorldData
	WorldId           string
	UnitTypes         []UnitType
	GameConfiguration *protos.GameConfiguration

	// Form fields (can be pre-filled or from error retry)
	GameId       string
	GameName     string
	ErrorMessage string // Error message for ID conflicts etc.
}

type TBButton struct {
	ButtonId  string
	IconImage string
	Label     string
	Command   string
}

type TermsOfService struct {
	BasePage
	Header Header
}

type TerrainData struct {
	ID           int32        // `json:"id"`
	Name         string       // `json:"name"`
	BaseMoveCost float64      // `json:"baseMoveCost"` // Base movement cost for this terrain
	DefenseBonus float64      // `json:"defenseBonus"`
	Type         TerrainType2 // `json:"type"` // Nature or Player terrain
	Properties   []string     // `json:"properties,omitempty"`

}

type TerrainType struct {
	TerrainData
	IconDataURL     string `json:"iconDataURL"`
	HasPlayerColors bool   `json:"hasPlayerColors"`
}

type TerrainType2 int32

type ThemeManager struct {
	// contains filtered or unexported fields
}

type ThemeMapping struct {
	Units    map[string]ThemeMappingEntry `json:"units"`
	Terrains map[string]ThemeMappingEntry `json:"terrains"`
}

type ThemeMappingEntry struct {
	Old   string `json:"old"`
	Name  string `json:"name"`
	Image string `json:"image"`
}

type TwitterOAuth2 struct {
	ClientId       string
	ClientSecret   string
	CallbackURL    string
	HandleUser     accounts.HandleUserFunc
	AuthFailureUrl string
	// contains filtered or unexported fields
}

type TwitterUserResponse struct {
	Data struct {
		ID              string `json:"id"`
		Name            string `json:"name"`
		Username        string `json:"username"`
		ProfileImageURL string `json:"profile_image_url"`
	} `json:"data"`
}

type URLSet struct {
	XMLName xml.Name     `xml:"urlset"`
	XMLNS   string       `xml:"xmlns,attr"`
	URLs    []SitemapURL `xml:"url"`
}

type UnitType struct {
	*protos.UnitDefinition
	IconDataURL string `json:"iconDataURL"`
}

type UsersHandler struct {
	App *LilBattleApp
}

type WebAppServer struct {
	goal.WebAppServer
}

type WorldCreatePage struct {
	BasePage
	Header Header

	// Form fields (pre-filled on conflict retry)
	SuggestedId  string
	ErrorMessage string
	WorldName    string
}

type WorldEditorPage struct {
	BasePage
	Header         Header
	IsOwner        bool
	WorldId        string
	World          *protos.World
	WorldData      *protos.WorldData
	Errors         map[string]string
	TBButtons      []*TBButton
	AllowCustomId  bool
	NatureTerrains []TerrainType
	CityTerrains   []TerrainType
	UnitTypes      []UnitType
	Crossings      []CrossingType // Road and Bridge crossings
	PlayerCount    int
	Theme          string // Theme name from query parameter (default, fantasy, modern)
}

type WorldListView struct {
	goal.WithPagination
	goal.WithFiltering

	Worlds     []*protos.World
	ActionMode string // "manage" or "select"
}

type WorldListingPage struct {
	BasePage
	Header Header

	WorldListView WorldListView
	ListingData   *goal.EntityListingData[*protos.World]
}

type WorldViewerPage struct {
	BasePage
	Header    Header
	World     *protos.World
	WorldData *protos.WorldData
	WorldId   string
}

type WorldsGroup struct {
	// contains filtered or unexported fields
}