admin

var (
	RegisterApp   = AdminSite.RegisterApp
	IsReady       = AdminSite.IsReady
	ConfigureAuth = AdminSite.configureAuth
)

var ADMIN_BASE_URL = "admin/"

var AppHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition) {
	if !app.Options.EnableIndexView {
		except.RaiseNotFound(
			trans.T(r.Context(), "app %q does not have an index view"),
			app.Label(r.Context()),
		)
		return
	}

	if !permissions.HasPermission(r, fmt.Sprintf("admin:view_app:%s", app.Name)) {
		ReLogin(w, r, r.URL.Path)
		return
	}

	if app.Options.IndexView != nil {
		var err = views.Invoke(app.Options.IndexView(adminSite, app), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var models = app.Models
	var modelNames = make([]string, models.Len())
	var i = 0
	for front := models.Front(); front != nil; front = front.Next() {
		modelNames[i] = front.Value.Label(r.Context())
		i++
	}

	var hookName = RegisterAdminPageComponentHook(app.Name)
	var hook = goldcrest.Get[RegisterAdminAppPageComponentHookFunc](hookName)
	var components = make([]AdminPageComponent, 0)
	for _, h := range hook {
		var component = h(r, adminSite, app)
		if component != nil {
			components = append(components, component)
		}
	}
	sortComponents(components)

	var context = NewContext(
		r, adminSite, nil,
	)

	context.SetPage(PageOptions{
		TitleFn:    app.Label,
		SubtitleFn: app.Description,
		MediaFn: func() media.Media {
			var appMedia media.Media = media.NewMedia()
			for _, component := range components {
				var m = component.Media()
				if m != nil {
					appMedia = appMedia.Merge(m)
				}
			}
			return appMedia
		},
	})
	context.Set("app", app)
	context.Set("models", modelNames)
	context.Set("components", components)
	var err = tpl.FRender(w, context, BASE_KEY, "admin/views/apps/index.tmpl")
	except.AssertNil(err, 500, err)
}

var (
	BulkActionDelete = &BaseBulkAction{
		ID:       "delete",
		Ordering: 100,
		Btn:      BulkActionButton(trans.S("Delete"), components.ClassTypeDanger, "delete", true),
		PermissionsFn: func(r *http.Request, model *ModelDefinition) bool {
			return !model.DisallowDelete && permissions.HasPermission(r, "admin:delete")
		},
		Func: func(w http.ResponseWriter, r *http.Request, model *ModelDefinition, qs *queries.QuerySet[attrs.Definer]) (int, error) {
			var meta = attrs.GetModelMeta(model.NewInstance())
			var defs = meta.Definitions()
			var primary = defs.Primary()

			qs = qs.Select(primary.Name())

			var rowCnt, rowIter, err = qs.IterAll()
			if err != nil {
				return 0, err
			}

			var values = make([]string, 0, rowCnt)
			for row, err := range rowIter {
				if err != nil {
					return 0, err
				}

				var defs = row.Object.FieldDefs()
				var primary = defs.Primary()
				var val, err = primary.Value()
				if err != nil {
					return 0, err
				}

				values = append(
					values,
					attrs.ToString(val),
				)
			}

			var urlValues = url.Values{
				"pk_list": values,
				"next":    []string{r.URL.RequestURI()},
			}

			var deleteURL = fmt.Sprintf(
				"%s?%s",
				django.Reverse(
					"admin:apps:model:bulk_delete",
					model.App().Name, model.GetName(),
				),
				urlValues.Encode(),
			)

			http.Redirect(
				w, r, deleteURL, http.StatusSeeOther,
			)

			return 0, nil
		},
	}
)

var HomeHandler = &views.BaseView{
	AllowedMethods:  []string{http.MethodGet},
	BaseTemplateKey: BASE_KEY,
	TemplateName:    "admin/views/home.tmpl",
	GetContextFn: func(req *http.Request) (ctx.Context, error) {
		var context = NewContext(req, AdminSite, nil)
		var user = authentication.Retrieve(req)

		// Initialize / retrieve home page intro texts
		var pageTitle = django.ConfigGet[any](
			django.Global.Settings,
			APPVAR_HOME_PAGE_TITLE,
			trans.S("Home"),
		)
		var pageSubtitle = django.ConfigGet[any](
			django.Global.Settings,
			APPVAR_HOME_PAGE_SUBTITLE,
			func(r *http.Request) string {
				return trans.T(
					r.Context(),
					"Welcome to the Go-Django admin dashboard, %s!",
					attrs.ToString(user),
				)
			},
		)

		// Set up media files for the home page template
		var homeMedia media.Media = media.NewMedia()
		homeMedia.AddCSS(media.CSS(django.Static(
			"admin/css/home.css",
		)))

		// Initialize / retrieve the home page logo's static path
		var logo = django.ConfigGet[any](
			django.Global.Settings,
			APPVAR_HOME_PAGE_LOGO_PATH,
			django.Static("admin/images/home_logo.png"),
		)
		var logoPath string
		switch t := logo.(type) {
		case string:
			logoPath = t
		case func() string:
			logoPath = t()
		case func(*http.Request) string:
			logoPath = t(req)
		}

		// Add home page breadcrumbs and actions
		var breadCrumbs = make([]BreadCrumb, 0)
		var breadcrumbHooks = goldcrest.Get[RegisterHomePageBreadcrumbHookFunc](RegisterHomePageBreadcrumbHook)
		for _, hook := range breadcrumbHooks {
			breadCrumbs = hook(req, AdminSite, breadCrumbs)
		}

		var actions = make([]Action, 0)
		var actionHooks = goldcrest.Get[RegisterHomePageActionHookFunc](RegisterHomePageActionHook)
		for _, hook := range actionHooks {
			actions = hook(req, AdminSite, actions)
		}

		// Add custom home page components
		var componentHooks = goldcrest.Get[RegisterHomePageComponentHookFunc](RegisterHomePageComponentHook)
		var components = make([]AdminPageComponent, 0)
		for _, hook := range componentHooks {
			var component = hook(req, AdminSite)
			if component != nil {
				components = append(components, &componentWrapper{component})
			}
		}
		components = sortComponents(components)

		context.SetPage(PageOptions{
			TitleFn:     getFuncTyped[string](pageTitle, req, nil),
			SubtitleFn:  getFuncTyped[string](pageSubtitle, req, nil),
			BreadCrumbs: breadCrumbs,
			Actions:     actions,
			MediaFn: func() media.Media {
				for _, component := range components {
					var media = component.Media()
					if media != nil {
						homeMedia = homeMedia.Merge(media)
					}
				}
				return homeMedia
			},
		})

		context.Set("Components", components)

		if logoPath != "" {
			context.Set("LogoPath", logoPath)
		}

		return context, nil
	},
}

var LoginHandler = &views.FormView[LoginForm]{
	BaseView: views.BaseView{
		AllowedMethods:  []string{http.MethodGet, http.MethodPost},
		BaseTemplateKey: "admin",
		TemplateName:    "admin/views/auth/login.tmpl",
		GetContextFn: func(req *http.Request) (ctx.Context, error) {
			var context = ctx.RequestContext(req)
			// context.Set("next", req.URL.Query().Get("next"))
			var loginURL = django.Reverse("admin:login")
			var nextURL = req.URL.Query().Get("next")
			if nextURL != "" {
				var u, err = url.Parse(loginURL)
				if err != nil {
					goto returnContext
				}

				q := u.Query()
				q.Set("next", nextURL)
				u.RawQuery = q.Encode()
				loginURL = u.String()
			}

		returnContext:
			context.Set("LoginURL", loginURL)
			return context, nil
		},
	},
	GetFormFn: func(req *http.Request) LoginForm {
		var loginForm = AdminSite.AuthLoginForm(
			req,
		)
		return loginForm
	},
	InvalidFn: func(req *http.Request, form LoginForm) error {
		core.SIGNAL_LOGIN_FAILED.Send(req)
		return nil
	},
	ValidFn: func(req *http.Request, form LoginForm) error {
		form.SetRequest(req)
		return form.Login()
	},
	SuccessFn: func(w http.ResponseWriter, req *http.Request, form LoginForm) {
		var nextURL = req.URL.Query().Get("next")
		if nextURL == "" {
			nextURL = django.Reverse("admin:home")
		}

		http.Redirect(w, req, nextURL, http.StatusSeeOther)
	},
}

var ModelAddHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition) {

	if !permissions.HasObjectPermission(r, model.NewInstance(), "admin:add") {
		ReLogin(w, r, r.URL.Path)
		return
	}

	if model.DisallowCreate {
		messages.Error(r, trans.T(r.Context(), "This model does not allow creation"))
		autherrors.Fail(
			http.StatusForbidden,
			trans.T(r.Context(), "This model does not allow creation"),
			django.Reverse("admin:apps:model", app.Name, model.GetName()),
		)
		return
	}

	var instance = model.NewInstance()
	if model.AddView.GetHandler != nil {
		var err = views.Invoke(model.AddView.GetHandler(adminSite, app, model, instance), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var addView = newInstanceView("add", instance, model.AddView, app, model, r, &PageOptions{
		TitleFn: trans.S("Add %s", model.Label(r.Context())),
	})
	views.Invoke(addView, w, r)

}

var ModelBulkDeleteHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition) {

	var pkList = r.URL.Query()["pk_list"]
	if len(pkList) == 0 {
		except.Fail(
			http.StatusBadRequest,
			trans.T(r.Context(), "No primary keys provided for bulk delete"),
		)
		return
	}

	var meta = attrs.GetModelMeta(model.Model)
	var defs = meta.Definitions()
	var prim = defs.Primary()
	var instanceRows, err = queries.GetQuerySetWithContext(r.Context(), model.NewInstance()).
		Filter(fmt.Sprintf("%s__in", prim.Name()), pkList).
		SelectRelated(model.ListView.Prefetch.SelectRelated...).
		Preload(model.ListView.Prefetch.PrefetchRelated...).
		All()

	if err != nil {
		except.Fail(
			http.StatusInternalServerError,
			trans.T(r.Context(),
				"Failed to retrieve instances for bulk delete: %v",
				err,
			),
		)
		return
	}

	var instances = slices.Collect(instanceRows.Objects())
	if model.DeleteView.GetHandler != nil {
		var err = views.Invoke(model.DeleteView.GetHandler(adminSite, app, model, instances), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var deleteView = &AdminDeleteView{
		BaseView: views.BaseView{
			AllowedMethods:  []string{http.MethodGet, http.MethodPost},
			BaseTemplateKey: BASE_KEY,
			TemplateName:    "admin/views/models/delete.tmpl",
		},
		Permissions: []string{"admin:delete"},
		Writer:      w,
		Request:     r,
		AdminSite:   adminSite,
		App:         app,
		Model:       model,
		Instances:   instances,
	}

	err = views.Invoke(deleteView, w, r)
	except.AssertNil(err, 500, err)
}

var ModelDeleteHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition, instance attrs.Definer) {
	if model.DeleteView.GetHandler != nil {
		var err = views.Invoke(model.DeleteView.GetHandler(adminSite, app, model, []attrs.Definer{instance}), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var deleteView = &AdminDeleteView{
		BaseView: views.BaseView{
			AllowedMethods:  []string{http.MethodGet, http.MethodPost},
			BaseTemplateKey: BASE_KEY,
			TemplateName:    "admin/views/models/delete.tmpl",
		},
		Permissions: []string{"admin:delete"},
		Writer:      w,
		Request:     r,
		AdminSite:   adminSite,
		App:         app,
		Model:       model,
		Instances:   []attrs.Definer{instance},
	}

	var err = views.Invoke(deleteView, w, r)
	except.AssertNil(err, 500, err)
}

var ModelEditHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition, instance attrs.Definer) {
	if !permissions.HasObjectPermission(r, instance, "admin:edit") {
		ReLogin(w, r, r.URL.Path)
		return
	}

	if model.DisallowEdit {
		messages.Error(r, trans.T(r.Context(), "This model does not allow editing"))
		autherrors.Fail(
			http.StatusForbidden,
			trans.T(r.Context(), "This model does not allow editing"),
			django.Reverse("admin:apps:model", app.Name, model.GetName()),
		)
		return
	}

	if model.EditView.GetHandler != nil {
		var err = views.Invoke(model.EditView.GetHandler(adminSite, app, model, instance), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var editView = newInstanceView("edit", instance, model.EditView, app, model, r, &PageOptions{
		TitleFn: trans.S("Edit %s", model.Label(r.Context())),
	})
	views.Invoke(editView, w, r)

}

var ModelListHandler = func(w http.ResponseWriter, r *http.Request, adminSite *AdminApplication, app *AppDefinition, model *ModelDefinition) {

	if !permissions.HasObjectPermission(r, model.NewInstance(), "admin:view_list") {
		ReLogin(w, r, r.URL.Path)
		return
	}

	if model.DisallowList {
		messages.Error(r, trans.T(r.Context(), "This model does not allow listing"))
		autherrors.Fail(
			http.StatusForbidden,
			trans.T(r.Context(), "This model does not allow listing"),
			django.Reverse("admin:home"),
		)
		return
	}

	var actions = make(map[string]BulkAction)

	var hasBulkActionsPerm = permissions.HasPermission(r, "admin:bulk_actions")
	if len(model.ListView.BulkActions) > 0 && hasBulkActionsPerm {
		for _, action := range model.ListView.BulkActions {
			if !action.HasPermission(r, model) {
				continue
			}

			actions[action.Name()] = action
		}
	}

	if model.ListView.GetHandler != nil {
		var err = views.Invoke(model.ListView.GetHandler(adminSite, app, model), w, r)
		except.AssertNil(err, 500, err)
		return
	}

	var listCols = make([]list.ListColumn[attrs.Definer], len(model.ListView.Fields))
	var sortBuilder = columns.NewSortableColumnBuilder(model.Model)
	for i, field := range model.ListView.Fields {
		listCols[i] = sortBuilder.AddColumn(model.GetColumn(
			r.Context(), model.ListView, field,
		))
	}

	var amount = model.ListView.PerPage
	if amount == 0 {
		amount = 25
	}

	var qs *queries.QuerySet[attrs.Definer]
	if model.ListView.GetQuerySet != nil {
		qs = model.ListView.GetQuerySet(adminSite, app, model)
	} else {
		qs = queries.GetQuerySet(model.NewInstance())
	}
	if len(model.ListView.Prefetch.SelectRelated) > 0 {
		qs = qs.SelectRelated(model.ListView.Prefetch.SelectRelated...)
	}
	if len(model.ListView.Prefetch.PrefetchRelated) > 0 {
		qs = qs.Preload(model.ListView.Prefetch.PrefetchRelated...)
	}
	if len(model.ListView.Ordering) > 0 {
		qs = qs.OrderBy(model.ListView.Ordering...)
	}

	if !model.DisallowEdit && permissions.HasPermission(r, "admin:edit") {
		r = r.WithContext(list.SetAllowListEdit(r.Context(), true))
	}

	if len(actions) > 0 && hasBulkActionsPerm {
		r = r.WithContext(list.SetAllowListRowSelect(r.Context(), true))

		if r.Method == http.MethodPost {
			r.ParseForm()

			var listSelected = r.PostForm["list__row_select"]
			var actionName = r.PostFormValue("list_action")

			if len(listSelected) > 0 {
				var meta = attrs.GetModelMeta(model.Model)
				var defs = meta.Definitions()
				var primaryField = defs.Primary()

				qs = qs.Filter(
					fmt.Sprintf("%s__in", primaryField.Name()),
					listSelected,
				)
			}

			if actionName == "" {
				goto continueView
			}

			var action, ok = actions[actionName]
			if !ok {
				except.Fail(
					http.StatusBadRequest,
					trans.T(r.Context(), "Invalid list action"),
				)
				return
			}

			var changed, err = action.Execute(w, r, model, qs)
			if err != nil {
				logger.Errorf(
					"Failed to execute bulk action %s: %v",
					action.Name(), err,
				)
				except.Fail(
					http.StatusInternalServerError,
					trans.T(r.Context(), "Failed to apply list action"),
				)
				return
			}

			switch {
			case changed == 1:
				messages.Success(r, trans.T(r.Context(), "List action applied successfully to one object"))
				http.Redirect(w, r, django.Reverse("admin:apps:model", app.Name, model.GetName()), http.StatusSeeOther)
			case changed > 1:
				messages.Success(r, trans.T(r.Context(), "List action applied successfully to multiple objects"))
				http.Redirect(w, r, django.Reverse("admin:apps:model", app.Name, model.GetName()), http.StatusSeeOther)
			}

			return
		}
	}

continueView:
	var filterForm *filters.Filters[attrs.Definer]
	if len(model.ListView.Filters) > 0 {
		filterForm = filters.NewFilters[attrs.Definer](r.Context(), "filters")
		for _, f := range model.ListView.Filters {
			filterForm.Add(f)
		}

		var err error
		qs, err = filterForm.Filter(r, r.URL.Query(), qs)
		if err != nil {
			except.AssertNil(err, 500, err)
			return
		}
	}

	qs = sortBuilder.Sort(qs, r.URL.Query()["sort"])

	var view = &list.View[attrs.Definer]{
		Model:           model.NewInstance(),
		ListColumns:     listCols,
		DefaultAmount:   int(amount),
		AllowedMethods:  []string{http.MethodGet, http.MethodPost},
		BaseTemplateKey: BASE_KEY,
		TemplateName:    "admin/views/models/list.tmpl",
		Mixins: func(r *http.Request, v *list.View[attrs.Definer]) []views.View {
			if !permissions.HasObjectPermission(r, model.NewInstance(), "admin:export") {
				return nil
			}

			return []views.View{
				&list.ListExportMixin[attrs.Definer]{
					Model:  model.NewInstance(),
					Export: list.ExportText[attrs.Definer],
				},
			}
		},
		List: func(r *http.Request, po pagination.PageObject[attrs.Definer], lc []list.ListColumn[attrs.Definer], ctx ctx.Context) (list.StringRenderer, error) {
			if model.ListView.GetList != nil {
				return model.ListView.GetList(r, adminSite, app, model, po.Results())
			}
			return nil, nil

		},
		ChangeContextFn: func(req *http.Request, qs *queries.QuerySet[attrs.Definer], baseCtx ctx.Context) (ctx.Context, error) {
			var paginator = list.PaginatorFromContext[attrs.Definer](req.Context())
			var count, err = paginator.Count()
			if err != nil {
				return nil, err
			}

			var buttons = []components.ShowableComponent{
				components.NewShowableComponent(
					req, func(r *http.Request) bool {
						return count > 0 && baseCtx.Get("view_list_form") != nil && !model.DisallowEdit && permissions.HasObjectPermission(r, model.NewInstance(), "admin:edit")
					},
					BulkActionButton(
						trans.S("Change"),
						components.ClassTypeWarning|components.ClassTypeHollow,
						"",
						len(actions) > 0,
					),
				),
			}

			if count > 0 && len(model.ListView.BulkActions) > 0 && hasBulkActionsPerm {
				for _, action := range model.ListView.BulkActions {
					if !action.HasPermission(r, model) {
						continue
					}

					buttons = append(buttons, components.NewShowableComponent(
						r,
						func(r *http.Request) bool { return action.HasPermission(r, model) },
						action.Button(),
					))
				}
			}

			var actions = make([]Action, 0)
			if permissions.HasObjectPermission(req, model.NewInstance(), "admin:export") {
				var query = req.URL.Query()
				query.Set("_export", "1")
				var downloadURL = fmt.Sprintf("%s?%s",
					django.Reverse("admin:apps:model", app.Name, model.GetName()),
					query.Encode(),
				)
				actions = append(actions, Action{
					Icon:  "icon-download",
					Title: trans.T(r.Context(), "Export %s", model.PluralLabel(r.Context())),
					URL:   downloadURL,
				})
			}

			var context = NewContext(req, adminSite, baseCtx)
			context.SetPage(PageOptions{
				TitleFn: trans.S(
					"%s List (%d)",
					model.Label(r.Context()),
					count,
				),
				HeaderActions: append(
					[]components.ShowableComponent{
						components.NewShowableComponent(
							req, func(r *http.Request) bool {
								return !model.DisallowCreate && permissions.HasObjectPermission(r, model.NewInstance(), "admin:add")
							},
							components.Link(components.ButtonConfig{
								Text: trans.S("Add"),
								Type: components.ClassTypeSecondary,
							}, func() string {
								return django.Reverse("admin:apps:model:add", app.Name, model.GetName())
							}),
						),
					},
					buttons...,
				),
				Actions: actions,
				SidePanels: &menu.SidePanels{
					Panels: []menu.SidePanel{
						SidePanelFilters(
							r, filterForm, list.PageFromContext[attrs.Definer](req.Context()), func(p *menu.BaseSidePanel, r *http.Request) bool {
								return len(model.ListView.Filters) == 0
							},
						),
					},
				},
			})
			context.Set("app", app)
			context.Set("model", model)
			context.Set("actions", actions)
			if filterForm != nil {
				context.Set("filter", filterForm)
			}
			return context, nil
		},
		QuerySet: func(r *http.Request) *queries.QuerySet[attrs.Definer] {
			return qs
		},
		TitleFieldColumn: func(lc list.ListColumn[attrs.Definer]) list.ListColumn[attrs.Definer] {
			var col = list.TitleFieldColumn(lc, func(r *http.Request, defs attrs.Definitions, instance attrs.Definer) string {
				var primaryField = defs.Primary()
				if primaryField == nil {
					return ""
				}

				if !permissions.HasObjectPermission(r, instance, "admin:edit") || model.DisallowEdit {
					return ""
				}

				return django.Reverse("admin:apps:model:edit", app.Name, model.GetName(), primaryField.GetValue())
			})

			col = list.RowSelectColumn(
				"list__row_select",
				nil,
				nil,
				col,
				map[string]any{
					"data-bulk-actions-target": "selectAll",
				},
				map[string]any{
					"data-bulk-actions-target": "checkbox",
				},
			)

			return col
		},
	}

	views.Invoke(view, w, r)
}

var (
	// Register a custom component for an app registered to the admin.
	// The app name is used to identify the app.
	// It should be formatted as "admin:<app_name>:register_admin_page_component"
	// This will then return a string which can be used to register the component to the app.
	RegisterAdminPageComponentHook = func(appname string) string {
		return fmt.Sprintf("admin:%s:register_component", appname)
	}
)