admin

type Action struct {
	Icon   string
	Target string
	Title  string
	URL    string
}

type AdminApplication struct {
	*apps.AppConfig

	// Ordering is the order in which the apps are displayed
	// in the admin interface.
	Ordering []string

	Route *mux.Route

	// Apps is a map of all the apps that are registered
	// with the admin site.
	Apps *orderedmap.OrderedMap[
		string, *AppDefinition,
	]
	// contains filtered or unexported fields
}

type AdminForm[T forms.Form] struct {
	Form   T
	Panels []Panel
}

type AdminModelForm[T modelforms.ModelForm[attrs.Definer]] struct {
	*AdminForm[T]
}

type AdminModelHookFunc = func(r *http.Request, adminSite *AdminApplication, model *ModelDefinition, instance attrs.Definer)

type AdminPageComponent interface {
	HTML() template.HTML
	Ordering() int
	Media() media.Media
}

type AppDefinition struct {
	Name    string
	Options AppOptions
	Models  *orderedmap.OrderedMap[
		string, *ModelDefinition,
	]
	Routing func(django.Mux)
}

type AppOptions struct {
	// RegisterToAdminMenu allows for registering this app to the admin menu by default.
	RegisterToAdminMenu bool

	// EnableIndexView allows for enabling the index view for this app.
	//
	// If this is disabled, only a main sub-menu item will be created, but not for the index view.
	EnableIndexView bool

	// Applabel must return a human readable label for the app.
	AppLabel func() string

	// AppDescription must return a human readable description of this app.
	AppDescription func() string

	// MenuLabel must return a human readable label for the menu, this is how the app's name will appear in the admin's navigation.
	MenuLabel func() string

	// MenuOrder is the order in which the app will appear in the admin's navigation.
	MenuOrder int

	// MenuIcon must return a string representing the icon to use for the menu.
	//
	// This should be a HTML element, I.E. "<svg>...</svg>".
	MenuIcon func() string

	// MediaFn must return a media.Media object that will be used for this app.
	//
	// It will always be included in the admin's media.
	MediaFn func() media.Media

	// A custom index view for the app.
	//
	// This will override the default index view for the app.
	IndexView func(adminSite *AdminApplication, app *AppDefinition) views.View
}

type AuthConfig struct {
	// GetLoginForm is a function that returns a LoginForm
	//
	// This function is called when the user tries to login to the admin
	// interface. It should return a LoginForm that is used to render
	// the login form.
	//
	// If GetLoginHandler is set, this function will not be called.
	GetLoginForm func(r *http.Request, formOpts ...func(forms.Form)) LoginForm

	// GetLoginHandler is a function that returns a http.HandlerFunc for
	// logging a user in to the admin interface.
	//
	// If GetLoginHandler is set, this function will be called instead
	// of GetLoginForm. It should return a http.HandlerFunc that is
	// used to render the login form.
	GetLoginHandler func(w http.ResponseWriter, r *http.Request)

	// Logout is a function that is called when the user logs out of
	// the admin interface.
	Logout func(r *http.Request) error
}

type BoundFormPanel[T forms.Form, P Panel] struct {
	forms.BoundField
	Context context.Context
	Panel   P
	Form    T
}

type BoundMultiPanel[T forms.Form] struct {
	LabelFn func() string
	Context context.Context
	Panels  []BoundPanel
	Form    T
}

type BoundPanel interface {
	Component() templ.Component
	Render() template.HTML
}

type BoundTitlePanel[T forms.Form, P Panel] struct {
	BoundPanel
	Context context.Context
}

type BreadCrumb struct {
	Title string
	URL   string
}

type DeleteViewOptions struct {

	// GetHandler is a function that returns a views.View for the model.
	//
	// This allows you to have full control over the view used for deleting the model.
	//
	// This does mean that any logic provided by the admin when deleting the model should be implemented by the developer.
	GetHandler func(adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition, instance attrs.Definer) views.View

	// DeleteInstance is a function that deletes the instance.
	//
	// This allows for custom logic to be executed when deleting the instance.
	DeleteInstance func(context.Context, attrs.Definer) error
}

type FormDefiner interface {
	attrs.Definer
	AdminForm(r *http.Request, app *AppDefinition, model *ModelDefinition) modelforms.ModelForm[attrs.Definer]
}

type FormViewOptions struct {
	ViewOptions

	// Widgets are used to define the widgets for the fields in the form.
	//
	// This allows for custom rendering logic of the fields in the form.
	Widgets map[string]widgets.Widget

	// GetForm is a function that returns a modelform.ModelForm for the model.
	GetForm func(req *http.Request, instance attrs.Definer, fields []string) modelforms.ModelForm[attrs.Definer]

	// FormInit is a function that can be used to initialize the form.
	//
	// This may be useful for providing custom form initialization logic.
	FormInit func(instance attrs.Definer, form modelforms.ModelForm[attrs.Definer])

	// GetHandler is a function that returns a views.View for the model.
	//
	// This allows you to have full control over the view used for saving the model.
	//
	// This does mean that any logic provided by the admin when saving the model should be implemented by the developer.
	GetHandler func(adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition, instance attrs.Definer) views.View

	// A custom function for saving the instance.
	//
	// This function will be called when the form is saved and allows for custom logic to be executed when saving the instance.
	SaveInstance func(context.Context, attrs.Definer) error

	// Panels are used to group fields in the form.
	//
	// This allows for a more simple, maintainable and organized form layout.
	Panels []Panel
}

type ListAction[T attrs.Definer] struct {
	Classname string
	Show      func(r *http.Request, defs attrs.Definitions, row T) bool
	Text      func(r *http.Request, defs attrs.Definitions, row T) string
	URL       func(r *http.Request, defs attrs.Definitions, row T) string
}

type ListActionsColumn[T attrs.Definer] struct {
	Heading func() string
	Actions []*ListAction[T]
}

type ListViewOptions struct {
	ViewOptions

	// PerPage is the number of items to show per page.
	//
	// This is used for pagination in the list view.
	PerPage uint64

	// Columns are used to define the columns in the list view.
	//
	// This allows for custom rendering logic of the columns in the list view.
	Columns map[string]list.ListColumn[attrs.Definer]

	// Format is a map of field name to a function that formats the field value.
	//
	// I.E. map[string]func(v any) any{"Name": func(v any) any { return strings.ToUpper(v.(string)) }}
	// would uppercase the value of the "Name" field in the list view.
	Format map[string]func(v any) any

	// GetHandler is a function that returns a views.View for the model.
	//
	// This allows you to have full control over the view used for listing the models.
	//
	// This does mean that any logic provided by the admin when listing the models should be implemented by the developer.
	GetHandler func(adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition) views.View
}

type LoginForm interface {
	forms.Form
	SetRequest(req *http.Request)
	Login() error
}

type ModelDefinition struct {
	ModelOptions
	// contains filtered or unexported fields
}

type ModelOptions struct {
	// Name is the name of the model.
	//
	// This is used for the model's name in the admin.
	Name string

	// MenuIcon is a function that returns the icon for the model in the admin menu.
	//
	// This should return an HTML element, I.E. "<svg>...</svg>".
	MenuIcon func() string

	// MenuOrder is the order of the model in the admin menu.
	MenuOrder int

	// MenuLabel is the label for the model in the admin menu.
	//
	// This is used for the model's label in the admin.
	MenuLabel func() string

	// DisallowCreate is a flag that determines if the model should be disallowed from being created.
	//
	// This is used to prevent the model from being created in the admin.
	DisallowCreate bool

	// DisallowEdit is a flag that determines if the model should be disallowed from being edited.
	//
	// This is used to prevent the model from being edited in the admin.
	DisallowEdit bool

	// DisallowDelete is a flag that determines if the model should be disallowed from being deleted.
	//
	// This is used to prevent the model from being deleted in the admin.
	DisallowDelete bool

	// AddView is the options for the add view of the model.
	//
	// This allows for custom creation logic and formatting form fields / layout.
	AddView FormViewOptions

	// EditView is the options for the edit view of the model.
	//
	// This allows for custom editing logic and formatting form fields / layout.
	EditView FormViewOptions

	// ListView is the options for the list view of the model.
	//
	// This allows for custom listing logic and formatting list columns.
	ListView ListViewOptions

	// DeleteView is the options for the delete view of the model.
	//
	// Any custom logic for deleting the model should be implemented here.
	DeleteView DeleteViewOptions

	// RegisterToAdminMenu is a flag that determines if the model should be automatically registered to the admin menu.
	RegisterToAdminMenu bool

	// Labels for the fields in the model.
	//
	// This provides a simple top- level override for the labels of the fields in the model.
	//
	// Any custom labels for fields implemented in the AddView, EditView or ListView will take precedence over these labels.
	Labels map[string]func() string

	// Model is the object that the above- defined options are for.
	Model attrs.Definer
}

type PageOptions struct {
	Request     *http.Request
	TitleFn     func() string
	SubtitleFn  func() string
	MediaFn     func() media.Media
	BreadCrumbs []BreadCrumb
	Actions     []Action
}

type Panel interface {
	Fields() []string
	Bind(form forms.Form, ctx context.Context, boundFields map[string]forms.BoundField) BoundPanel
}

type PanelBoundForm struct {
	forms.BoundForm
	BoundPanels []BoundPanel
	Panels      []Panel
	Context     context.Context
}

type RegisterAdminAppPageComponentHookFunc = func(r *http.Request, adminSite *AdminApplication, app *AppDefinition) AdminPageComponent

type RegisterBreadCrumbHookFunc = func(r *http.Request, adminSite *AdminApplication) []BreadCrumb

type RegisterFooterMenuItemHookFunc = func(r *http.Request, adminSite *AdminApplication, items components.Items[menu.MenuItem])

type RegisterHomePageActionHookFunc = func(*http.Request, *AdminApplication, []Action)

type RegisterHomePageBreadcrumbHookFunc = func(*http.Request, *AdminApplication, []BreadCrumb)

type RegisterHomePageComponentHookFunc = func(*http.Request, *AdminApplication) AdminPageComponent

type RegisterMediaHookFunc = func(adminSite *AdminApplication) media.Media

type RegisterMenuItemHookFunc = func(r *http.Request, adminSite *AdminApplication, items components.Items[menu.MenuItem])

type RegisterNavActionHookFunc = func(r *http.Request, adminSite *AdminApplication) []Action

type ViewOptions struct {
	// Fields to include for the model in the view
	Fields []string

	// Fields to exclude from the model in the view
	Exclude []string

	// Labels for the fields in the view
	//
	// This is a map of field name to a function that returns the label for the field.
	//
	// Allowing for custom labels for fields in the view.
	Labels map[string]func() string
}