ambient

type AppLogger interface {
	Logger

	// Fatal is reserved for the app level only.
	Fatal(format string, v ...interface{})
	SetLogLevel(level LogLevel)
	Named(name string) AppLogger
	Name() string
}

type AppRouter interface {
	Router

	ServeHTTP(w http.ResponseWriter, r *http.Request)
	SetNotFound(notFound http.Handler)
	SetServeHTTP(h func(w http.ResponseWriter, r *http.Request, err error))
}

type AppSession interface {
	AuthenticatedUser(r *http.Request) (string, error)
	Login(r *http.Request, username string)
	Logout(r *http.Request)
	LogoutAll(r *http.Request) error
	Persist(r *http.Request, persist bool)
	SetCSRF(r *http.Request) string
	CSRF(r *http.Request, token string) bool
	SessionValue(r *http.Request, name string) string
	SetSessionValue(r *http.Request, name string, value string) error
	DeleteSessionValue(r *http.Request, name string)
}

type Asset struct {
	// Filetype is the type of asset: generic, stylesheet, or javascript. (required)
	Filetype AssetType `json:"filetype"`
	// Location is the location on the HTML page where the asset will be
	// added. (required)
	Location AssetLocation `json:"location"`
	// Auth determines whether to show the asset to all users, only authenticated
	// users, or only non-authenticated users. Will display to all users if
	// not specified. (optional)
	Auth AuthType `json:"auth"`
	// Attributes are a list of HTML attributes on all filetypes except on
	// generic with no TagName. (optional)
	Attributes []Attribute `json:"attributes"`
	// LayoutOnly are a list of layout types where the element will be added.
	// Supports page and post. Will display on all layouts if not specified.
	// (optional)
	LayoutOnly []LayoutType `json:"layout"`

	// TagName is only for generic assets when Inline is true. Will specify the
	// type of element to create. If empty, then the asset will be written to
	// the page without a surrounding HTML element.
	TagName string `json:"tagname"`
	// ClosingTag, if true, will add a closing tag. It's only for generic assets
	// when inline is false.
	ClosingTag bool `json:"closingtag"`

	// External, if true, will just use the path as the source of the element.
	// It is only for stylesheet and javascript filetypes.
	External bool `json:"external"`
	// Inline if true, will output the contents from an embedded file (Path) or
	// the contents (Content) after doing a find/replace (Replace).
	Inline bool `json:"inline"`
	// SkipExistCheck if true, will not check for the file existing because it's
	// managed by a route.
	SkipExistCheck bool `json:"skipexist"`
	// Path is relative path to the embedded file or the full path to the
	// external asset. (optional)
	Path string `json:"path"`
	// Content is the content that will output on the page. Path must be empty
	// for content to be used and content is only used when Inline is true.
	Content string `json:"content"`
	// Replace is a list of find and replace strings that are run on the Path
	// or Content when Inline is true.
	Replace []Replace `json:"replace"`
}

type AssetInjector interface {
	Inject(injector LayoutInjector, t *template.Template, r *http.Request, layoutType LayoutType, vars map[string]interface{}) (*template.Template, error)
	DebugTemplates() bool
	EscapeTemplates() bool
}

type AssetLocation string

type AssetType string

type Attribute struct {
	Name  string
	Value interface{}
}

type AuthType string

type CustomServeHTTP func(log Logger, renderer Renderer,
	w http.ResponseWriter, r *http.Request, err error)

type DataStorer interface {
	Save([]byte) error
	Load() ([]byte, error)
}

type Error interface {
	error
	Status() int
	Message() string
}

type FileSystemReader interface {
	Open(name string) (fs.File, error)
	ReadDir(name string) ([]fs.DirEntry, error)
	ReadFile(name string) ([]byte, error)
}

type GRPCPluginBase struct {
	PluginBase
	// contains filtered or unexported fields
}

type GRPCSystem interface {
	// Monitor starts monitoring the gRPC plugins.
	Monitor(securesite SecureSite)
	// ConnectAll will connect to all initial gRPC plugins in the plugin system.
	ConnectAll()
	// Connect will connect to a new gRPC plugin, these don't have to be in the
	// initial plugin loader.
	Connect(p Plugin, middleware bool)
	// Disconnect stops the gRPC clients.
	Disconnect()
}

type Grant string

type GrantRequest struct {
	Grant       Grant
	Description string
}

type LayoutInjector interface {
	Head(t *template.Template, content string, fm template.FuncMap, data map[string]interface{}) (*template.Template, error)
	Header(t *template.Template, content string, fm template.FuncMap, data map[string]interface{}) (*template.Template, error)
	Main(t *template.Template, content string, fm template.FuncMap, data map[string]interface{}) (*template.Template, error)
	Footer(t *template.Template, content string, fm template.FuncMap, data map[string]interface{}) (*template.Template, error)
	Body(t *template.Template, content string, fm template.FuncMap, data map[string]interface{}) (*template.Template, error)
}

type LayoutType string

type LogLevel int

type Logger interface {
	Log(level LogLevel, format string, v ...interface{})
	Debug(format string, v ...interface{})
	Info(format string, v ...interface{})
	Warn(format string, v ...interface{})
	Error(format string, v ...interface{})
}

type LoggingPlugin interface {
	PluginCore

	Logger(appName string, appVersion string, writer io.Writer) (AppLogger, error)
}

type MiddlewarePlugin interface {
	Plugin

	Middleware() []func(next http.Handler) http.Handler // optional, called during enable
}

type Plugin interface {
	PluginCore

	// These should all have access to the toolkit.
	Enable(*Toolkit) error                           // optional, called during enable
	Disable() error                                  // optional, called during disable
	Routes()                                         // optional, called during enable
	Assets() ([]Asset, FileSystemReader)             // optional, called during enable
	Settings() []Setting                             // optional, called during special operations
	GrantRequests() []GrantRequest                   // optional, called during every plugin operation against data provider
	FuncMap() func(r *http.Request) template.FuncMap // optional, called on every render
}

type PluginBase struct {
	*Toolkit
}

type PluginCore interface {
	// PluginName should be globally unique. It must start with a lowercase
	// letter and then contain only lowercase letters and numbers.
	PluginName() string
	// PluginVersion must follow https://semver.org/.
	PluginVersion() string
}

type PluginData struct {
	Enabled  bool           `json:"enabled"`
	Version  string         `json:"version"`
	Grants   PluginGrants   `json:"grants"`
	Settings PluginSettings `json:"settings"`
}

type PluginGrants map[Grant]bool

type PluginLoader struct {
	Router         RouterPlugin
	TemplateEngine TemplateEnginePlugin
	SessionManager SessionManagerPlugin
	TrustedPlugins map[string]bool
	Plugins        []Plugin
	Middleware     []MiddlewarePlugin
}

type PluginSettings map[string]interface{}

type PluginSystem interface {
	// LoaderPlugins returns the loader plugins, these include initial gRPC plugins
	// as well.
	LoaderPlugins() []Plugin
	// LoaderMiddleware returns the loader middleware, these include initial gRPC plugins
	// as well.
	LoaderMiddleware() []MiddlewarePlugin
	// Plugins returns the map of plugins. This returns a map that is passed by
	// reference and all the values are pointers so any changes to it will
	// be reflected in the plugin system.
	Plugins() map[string]Plugin
	// SessionManager returns the session manager.
	SessionManager() SessionManagerPlugin
	// TemplateEngine returns the template engine.
	TemplateEngine() TemplateEnginePlugin
	// Router returns the router.
	Router() RouterPlugin
	// StorageManager returns the storage manager.
	StorageManager() Storage
	// LoadPlugin loads a single plugin into the plugin system and saves the config.
	LoadPlugin(plugin Plugin, middleware bool, grpcPlugin bool) (err error)
	// Load will load the storage and return an error if one occurs.
	Load() error
	// Save will save the storage and return an error if one occurs.
	Save() error
	// InitializePlugin will initialize the plugin in the storage and will return
	// an error if one occurs.
	InitializePlugin(pluginName string, pluginVersion string) error
	// RemovePlugin will delete the plugin from the storage and will return
	// an error if one occurs.
	RemovePlugin(pluginName string) error
	// Names returns a list of plugin names.
	Names() []string
	// MiddlewareNames returns a list of middleware plugin names.
	MiddlewareNames() []string
	// IsMiddleware returns if the plugin is middleware.
	IsMiddleware(name string) bool
	// TrustedPluginNames returns a list of sorted trusted names.
	TrustedPluginNames() []string
	// Trusted returns if a plugin is trusted.
	Trusted(pluginName string) bool
	// Routes returns a list of plugin routes.
	Routes(pluginName string) []Route
	// PluginsData returns the plugin data map.
	PluginsData() map[string]PluginData
	// Plugin returns a plugin by name.
	Plugin(name string) (Plugin, error)
	// PluginData returns a plugin data by name.
	PluginData(name string) (PluginData, error)
	// Enabled returns if the plugin is enabled or not. If it cannot be found, it
	// will still return false.
	Enabled(name string) bool
	// SetEnabled sets a plugin as enabled or not.
	SetEnabled(pluginName string, enabled bool) error
	// GrantRequests returns a list of grant requests.
	GrantRequests(pluginName string, grant Grant) ([]GrantRequest, error)
	// Authorized returns whether a plugin is inherited granted for a plugin.
	Authorized(pluginName string, grant Grant) bool
	// Granted returns whether a plugin is explicitly granted for a plugin.
	Granted(pluginName string, grant Grant) bool
	// SetGrant sets a plugin grant.
	SetGrant(pluginName string, grant Grant) error
	// RemoveGrant removes a plugin grant.
	RemoveGrant(pluginName string, grant Grant) error
	// SetSetting sets a plugin setting.
	SetSetting(pluginName string, settingName string, value interface{}) error
	// Setting returns a setting value.
	Setting(pluginName string, settingName string) (interface{}, error)
	// SettingDefault returns a setting default for a setting.
	SettingDefault(pluginName string, settingName string) (interface{}, error)
	// SetRoute saves a route.
	SetRoute(pluginName string, route []Route)
	// SetTitle sets the title.
	SetTitle(title string) error
	// Title returns the title.
	Title() string
	// SetScheme sets the site scheme.
	SetScheme(scheme string) error
	// Scheme returns the site scheme.
	Scheme() string
	// SetURL sets the site URL.
	SetURL(URL string) error
	// URL returns the URL without the scheme at the beginning.
	URL() string
	// FullURL returns the URL with the scheme at the beginning.
	FullURL() string
	// Updated returns the home last updated timestamp.
	Updated() time.Time
	// Tags returns the list of tags.
	Tags(onlyPublished bool) TagList
	// SetContent sets the home page content.
	SetContent(content string) error
	// Content returns the site home page content.
	Content() string
	// SavePost saves a post.
	SavePost(ID string, post Post) error
	// PostsAndPages returns the list of posts and pages.
	PostsAndPages(onlyPublished bool) PostWithIDList
	// PublishedPosts returns the list of published posts.
	PublishedPosts() []Post
	// PublishedPages returns the list of published pages.
	PublishedPages() []Post
	// PostBySlug returns the post by slug.
	PostBySlug(slug string) PostWithID
	// PostByID returns the post by ID.
	PostByID(ID string) (Post, error)
	// DeletePostByID deletes a post.
	DeletePostByID(ID string) error
}

type Post struct {
	Title     string    `json:"title"`
	URL       string    `json:"url"`
	Canonical string    `json:"canonical"`
	Created   time.Time `json:"created"`
	Updated   time.Time `json:"updated"`
	Timestamp time.Time `json:"timestamp"`
	Content   string    `json:"content"`
	Published bool      `json:"published"`
	Page      bool      `json:"page"`
	Tags      TagList   `json:"tags"`
}

type PostList []Post

type PostWithID struct {
	Post
	ID string `json:"id"`
}

type PostWithIDList []PostWithID

type Renderer interface {
	Page(w http.ResponseWriter, r *http.Request, assets FileSystemReader, templateName string,
		fm func(r *http.Request) template.FuncMap, vars map[string]interface{}) (err error)
	PageContent(w http.ResponseWriter, r *http.Request, content string,
		fm func(r *http.Request) template.FuncMap, vars map[string]interface{}) (err error)
	Post(w http.ResponseWriter, r *http.Request, assets FileSystemReader, templateName string,
		fm func(r *http.Request) template.FuncMap, vars map[string]interface{}) (err error)
	PostContent(w http.ResponseWriter, r *http.Request, content string,
		fm func(r *http.Request) template.FuncMap, vars map[string]interface{}) (err error)
	Error(w http.ResponseWriter, r *http.Request, content string, statusCode int,
		fm func(r *http.Request) template.FuncMap, vars map[string]interface{}) (err error)
}

type Replace struct {
	Find    string
	Replace string
}

type Route struct {
	Method string
	Path   string
}

type Router interface {
	Handle(method string, path string, fn func(http.ResponseWriter, *http.Request) error)
	Get(path string, fn func(http.ResponseWriter, *http.Request) error)
	Post(path string, fn func(http.ResponseWriter, *http.Request) error)
	Patch(path string, fn func(http.ResponseWriter, *http.Request) error)
	Put(path string, fn func(http.ResponseWriter, *http.Request) error)
	Delete(path string, fn func(http.ResponseWriter, *http.Request) error)
	Head(path string, fn func(http.ResponseWriter, *http.Request) error)
	Options(path string, fn func(http.ResponseWriter, *http.Request) error)
	StatusError(status int, err error) error
	Error(status int, w http.ResponseWriter, r *http.Request)
	Param(r *http.Request, name string) string
	Wrap(handler http.HandlerFunc) func(w http.ResponseWriter, r *http.Request) (err error)
}

type RouterPlugin interface {
	PluginCore

	Router(logger Logger, render Renderer) (AppRouter, error)
}

type SecureSite interface {
	// Error handles returning the proper error.
	Error(siteError error) (err error)
	// Load forces a reload of the data.
	Load() error
	// Authorized determines if the current context has access.
	Authorized(grant Grant) bool
	// NeighborPluginGrantList gets the grants requests for a neighbor plugin.
	NeighborPluginGrantList(pluginName string) ([]GrantRequest, error)
	// NeighborPluginGrants gets the map of granted permissions.
	NeighborPluginGrants(pluginName string) (map[Grant]bool, error)
	// NeighborPluginGranted returns true if the plugin has the grant.
	NeighborPluginGranted(pluginName string, grantName Grant) (bool, error)
	// NeighborPluginRequestedGrant returns true if the plugin requests the grant.
	// This shouldn't be used to determine if a plugin has been approved the grant.
	NeighborPluginRequestedGrant(pluginName string, grantName Grant) (bool, error)
	// SetNeighborPluginGrant sets a grant for a neighbor plugin.
	SetNeighborPluginGrant(pluginName string, grantName Grant, granted bool) error
	// Plugins returns the plugin list.
	Plugins() (map[string]PluginData, error)
	// PluginNames returns the list of plugin name.
	PluginNames() ([]string, error)
	// DeletePlugin deletes a plugin.
	DeletePlugin(name string) error
	// EnablePlugin enables a plugin.
	EnablePlugin(pluginName string, loadPlugin bool) error
	// LoadSinglePluginPages loads the plugin.
	LoadSinglePluginPages(name string)
	// DisablePlugin disables a plugin.
	DisablePlugin(pluginName string, unloadPlugin bool) error
	// SavePost saves a post.
	SavePost(ID string, post Post) error
	// PostsAndPages returns the list of posts and pages.
	PostsAndPages(onlyPublished bool) (PostWithIDList, error)
	// PublishedPosts returns the list of published posts.
	PublishedPosts() ([]Post, error)
	// PublishedPages returns the list of published pages.
	PublishedPages() ([]Post, error)
	// PostBySlug returns the post by slug.
	PostBySlug(slug string) (PostWithID, error)
	// PostByID returns the post by ID.
	PostByID(ID string) (Post, error)
	// DeletePostByID deletes a post.
	DeletePostByID(ID string) error
	// PluginNeighborRoutesList gets the routes for a neighbor plugin.
	PluginNeighborRoutesList(pluginName string) ([]Route, error)
	// AuthenticatedUser returns if the current user is authenticated.
	AuthenticatedUser(r *http.Request) (string, error)
	// UserLogin sets the current user as authenticated.
	UserLogin(r *http.Request, username string) error
	// UserPersist sets the user session to retain after browser close.
	UserPersist(r *http.Request, persist bool) error
	// UserLogout logs out the current user.
	UserLogout(r *http.Request) error
	// LogoutAllUsers logs out all users.
	LogoutAllUsers(r *http.Request) error
	// SetCSRF sets the session with a token and returns the token for use in a form
	// or header.
	SetCSRF(r *http.Request) string
	// CSRF returns true if the CSRF token is valid.
	CSRF(r *http.Request, token string) bool
	// SessionValue returns session value by name.
	SessionValue(r *http.Request, name string) string
	// SetSessionValue sets a value on the current session.
	SetSessionValue(r *http.Request, name string, value string) error
	// DeleteSessionValue deletes a session value on the current session.
	DeleteSessionValue(r *http.Request, name string)
	// PluginNeighborSettingsList gets the grants requests for a neighbor plugin.
	PluginNeighborSettingsList(pluginName string) ([]Setting, error)
	// SetPluginSetting sets a variable for the plugin.
	SetPluginSetting(settingName string, value string) error
	// PluginSettingBool returns a plugin setting as a bool.
	PluginSettingBool(name string) (bool, error)
	// PluginSettingString returns a setting for the plugin as a string.
	PluginSettingString(fieldName string) (string, error)
	// PluginSetting returns a setting for the plugin as an interface{}.
	PluginSetting(fieldName string) (interface{}, error)
	// SetNeighborPluginSetting sets a setting for a neighbor plugin.
	SetNeighborPluginSetting(pluginName string, settingName string, value string) error
	// NeighborPluginSettingString returns a setting for a neighbor plugin as a string.
	NeighborPluginSettingString(pluginName string, fieldName string) (string, error)
	// NeighborPluginSetting returns a setting for a neighbor plugin as an interface{}.
	NeighborPluginSetting(pluginName string, fieldName string) (interface{}, error)
	// PluginTrusted returns whether a plugin is trusted or not.
	PluginTrusted(pluginName string) (bool, error)
	// SetTitle sets the title.
	SetTitle(title string) error
	// Title returns the title.
	Title() (string, error)
	// SetScheme sets the site scheme.
	SetScheme(scheme string) error
	// Scheme returns the site scheme.
	Scheme() (string, error)
	// SetURL sets the site URL.
	SetURL(URL string) error
	// URL returns the URL without the scheme at the beginning.
	URL() (string, error)
	// FullURL returns the URL with the scheme at the beginning.
	FullURL() (string, error)
	// Updated returns the home last updated timestamp.
	Updated() (time.Time, error)
	// SetContent sets the home page content.
	SetContent(content string) error
	// Content returns the site home page content.
	Content() (string, error)
	// Tags returns the list of tags.
	Tags(onlyPublished bool) (TagList, error)
}

type SessionManagerPlugin interface {
	PluginCore

	// Session manager should have middleware with it.
	SessionManager(logger Logger, sessionStorer SessionStorer) (AppSession, error)
	Middleware() []func(next http.Handler) http.Handler
}

type SessionStorer interface {
	Save([]byte) error
	Load() ([]byte, error)
}

type Setting struct {
	Name        string             `json:"name"`
	Type        SettingType        `json:"type"`
	Description SettingDescription `json:"description"`
	Hide        bool               `json:"hide"`
	Default     interface{}        `json:"default"`
}

type SettingDescription struct {
	Text string `json:"text"`
	URL  string `json:"url"`
}

type SettingType string

type Site struct {
	Title         string                `json:"title"`   // Title of the site.
	Content       string                `json:"content"` // Home or default content.
	Scheme        string                `json:"scheme"`  // http or https
	URL           string                `json:"url"`     // URL without scheme and without trailing slash.
	Updated       time.Time             `json:"updated"` // Save time the data was saved (not only changed).
	Posts         map[string]Post       `json:"posts"`   // List of posts.
	PluginStorage map[string]PluginData `json:"plugins"` // List of plugins, whether they are found, enabled, and what fields they support.
}

type StatusError struct {
	Code     int
	Err      error
	Friendly string
}

type Storage interface {
	// Save writes the site object to the data storage and returns an error if it
	// cannot be written.
	Save() error
	// SaveDecrypted writes the site object to the data storage always decrypted and
	// returns an error if it cannot be written.
	SaveDecrypted() error
	// Load reads the site object from the data storage and returns an error if
	// it cannot be read.
	Load() error
	// LoadDecrypted reads the site object from the data storage always decrypted
	// and returns an error if it cannot be read.
	LoadDecrypted() error
}

type StorageEncryption interface {
	Encrypt(data []byte) ([]byte, error)
	Decrypt(enc []byte) ([]byte, error)
}

type StoragePlugin interface {
	PluginCore

	Storage(logger Logger) (DataStorer, SessionStorer, error)
}

type StoragePluginGroup struct {
	Storage    StoragePlugin
	Encryption StorageEncryption
}

type Tag struct {
	Name      string    `json:"name"`
	Timestamp time.Time `json:"timestamp"`
}

type TagList []Tag

type TemplateEnginePlugin interface {
	PluginCore

	TemplateEngine(logger Logger, injector AssetInjector) (Renderer, error)
}

type Toolkit struct {
	Log    Logger
	Mux    Router
	Render Renderer
	Site   SecureSite
}