func printResources(ctx *app.Context) {
	// TODO: Define an interface in package vfs, so this fails
	// if the interface is changed or renamed.
	type rooter interface {
		Root() string
	}
	var assets string
	var templates string
	if mgr := ctx.App().AssetsManager(); mgr != nil {
		if r, ok := mgr.VFS().(rooter); ok {
			assets = r.Root()
		}
	}
	if r, ok := ctx.App().TemplatesFS().(rooter); ok {
		templates = r.Root()
	}
	resources := map[string]string{
		"assets":    assets,
		"templates": templates,
	}
	data, err := json.Marshal(resources)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(data))
}

func ListHandler(ctx *app.Context) {
	var groups []*packageGroup
	dctx := getEnvironment(ctx)
	for _, gr := range appDocGroups(ctx) {
		var groupPackages []*doc.Package
		for _, v := range gr.Packages {
			pkgs, err := dctx.ImportPackages(packageDir(dctx, v))
			if err != nil {
				log.Errorf("error importing %s: %s", v, err)
				continue
			}
			groupPackages = append(groupPackages, pkgs...)
		}
		if len(groupPackages) > 0 {
			groups = append(groups, &packageGroup{
				Title:    gr.Title,
				Packages: groupPackages,
			})
		}
	}
	if len(groups) == 0 {
		ctx.NotFound("no packages to list")
		return
	}
	title := "Package Index"
	data := map[string]interface{}{
		"Header": title,
		"Title":  title,
		"Groups": groups,
	}
	ctx.MustExecute(PackagesTemplateName, data)
}

func afterTask(ctx *app.Context, task *Task, started time.Time, terr *error) {
	name := task.Name()
	if err := recover(); err != nil {
		skip, stackSkip, _, _ := runtimeutil.GetPanic()
		var buf bytes.Buffer
		fmt.Fprintf(&buf, "Panic executing task %s: %v\n", name, err)
		stack := runtimeutil.FormatStack(stackSkip)
		location, code := runtimeutil.FormatCaller(skip, 5, true, true)
		if location != "" {
			buf.WriteString("\n At ")
			buf.WriteString(location)
			if code != "" {
				buf.WriteByte('\n')
				buf.WriteString(code)
				buf.WriteByte('\n')
			}
		}
		if stack != "" {
			buf.WriteString("\nStack:\n")
			buf.WriteString(stack)
		}
		*terr = errors.New(buf.String())
	}
	end := time.Now()
	running.Lock()
	defer running.Unlock()
	c := running.tasks[task] - 1
	if c > 0 {
		running.tasks[task] = c
	} else {
		delete(running.tasks, task)
	}
	ctx.Logger().Infof("Finished task %s (%d instances now running) at %v (took %v)", name, c, end, end.Sub(started))
}

func redirectToFrom(ctx *app.Context) {
	from := ctx.FormValue(app.SignInFromParameterName)
	if from == "" {
		from = "/"
	}
	ctx.Redirect(from, false)
}

func testing2(ctx app.Context) {
	ctx.T("Testing even more translations")
	var t1 i18n.String = "Var inside function"
	/// This is a var string declared via cast
	t2 := i18n.String("Testing var string")
	fmt.Println(t1, t2)
}

func StdListHandler(ctx *app.Context) {
	dctx := getEnvironment(ctx)
	allPkgs, err := dctx.ImportPackages(dctx.Join(dctx.Context.GOROOT, "src"))
	if err != nil {
		panic(err)
	}
	var pkgs []*doc.Package
	var cmds []*doc.Package
	for _, v := range allPkgs {
		if dctx.Base(v.Dir()) == "cmd" {
			cmds = append(cmds, v)
		} else {
			pkgs = append(pkgs, v)
		}
	}
	title := "Go Standard Library"
	groups := []packageGroup{
		{Title: "Go Standard Library", Packages: pkgs},
		{Title: "Go Commands", Packages: cmds},
	}
	data := map[string]interface{}{
		"Header": title,
		"Title":  title,
		"Groups": groups,
	}
	ctx.MustExecute(PackagesTemplateName, data)
}

func decodeResetPayload(ctx *app.Context, payload string) (reflect.Value, error) {
	se, err := ctx.App().EncryptSigner(Salt)
	if err != nil {
		return reflect.Value{}, err
	}
	value, err := se.UnsignDecrypt(payload)
	if err != nil {
		return reflect.Value{}, err
	}
	qs, err := url.ParseQuery(string(value))
	if err != nil {
		return reflect.Value{}, err
	}
	userId, err := strconv.ParseInt(qs.Get("u"), 36, 64)
	if err != nil {
		return reflect.Value{}, err
	}
	ts, err := strconv.ParseInt(qs.Get("t"), 36, 64)
	if err != nil {
		return reflect.Value{}, err
	}
	if time.Since(time.Unix(ts, 0)) > PasswordResetExpiry {
		return reflect.Value{}, errResetExpired
	}
	user, userVal := newEmptyUser(ctx)
	ok := ctx.Orm().MustOne(orm.Eq("User.UserId", userId), userVal)
	if !ok {
		return reflect.Value{}, errNoSuchUser
	}
	return user, nil
}

func ArticleListHandler(ctx *app.Context) {
	data := map[string]interface{}{
		"Articles": getArticles(ctx),
		"Title":    ctx.App().Name(),
	}
	ctx.MustExecute("list.html", data)
}

func signInFacebookTokenHandler(ctx *app.Context, client *oauth2.Client, token *oauth2.Token) {
	user, err := userFromFacebookToken(ctx, token)
	if err != nil {
		panic(err)
	}
	ctx.MustSignIn(asGondolaUser(user))
	redirectToFrom(ctx)
}

func signInGoogleTokenHandler(ctx *app.Context, client *oauth2.Client, token *oauth2.Token) {
	d := data(ctx)
	googleApp := d.opts.GoogleApp.Clone(ctx)
	user, err := userFromGoogleToken(ctx, googleApp, token)
	if err != nil {
		panic(err)
	}
	ctx.MustSignIn(asGondolaUser(user))
	redirectToFrom(ctx)
}

func validateNewUsername(ctx *app.Context, username string) error {
	userType := getUserType(ctx)
	found, err := ctx.Orm().Exists(ctx.Orm().TypeTable(userType), ByUsername(username))
	if err != nil {
		return err
	}
	if found {
		return i18n.Errorf("username %q is already in use", username)
	}
	return nil
}

func (m *SimpleMediator) Skip(ctx *app.Context) bool {
	if m := ctx.R.Method; m != "GET" && m != "HEAD" {
		return true
	}
	c := ctx.Cookies()
	for _, v := range m.SkipCookies {
		if c.Has(v) {
			return true
		}
	}
	return false
}

func executeTask(ctx *app.Context, task *Task) (ran bool, err error) {
	var n int
	if n, err = numberOfInstances(task); err != nil {
		return
	}
	started := time.Now()
	ctx.Logger().Infof("Starting task %s (%d instances now running) at %v", task.Name(), n, started)
	ran = true
	defer afterTask(ctx, task, started, &err)
	task.Handler(ctx)
	return
}

func FormErrors(ctx *app.Context, frm *form.Form) {
	errors := make(map[string]string)
	for _, v := range frm.Fields() {
		if ferr := v.Err(); ferr != nil {
			errors[v.HTMLName] = ferr.Error()
		}
	}
	data := map[string]interface{}{
		"errors": errors,
	}
	ctx.WriteJSON(data)
}

func serveFile(ctx *app.Context, path string) {
	f, err := os.Open(path)
	if err != nil {
		ctx.NotFound("")
		return
	}
	defer f.Close()
	var modtime time.Time
	if fi, err := f.Stat(); err == nil {
		modtime = fi.ModTime()
	}
	http.ServeContent(ctx, ctx.R, filepath.Base(path), modtime, f)
}

func listUsers(ctx *app.Context) {
	userVal, ptr := newEmptyUser(ctx)
	iter := ctx.Orm().All().Iter()
	w := tabwriter.NewWriter(os.Stdout, 0, 8, 2, '\t', tabwriter.Debug)
	fmt.Fprint(w, "ID\tUsername\tEmail\tAdmin?\n")
	for iter.Next(ptr) {
		val := userVal.Elem().FieldByName("User").Interface().(User)
		fmt.Fprintf(w, "%d\t%s\t%s\t%v\n", val.UserId, val.Username, val.Email, val.Admin)
	}
	if err := w.Flush(); err != nil {
		panic(err)
	}
}

func windowCallbackHandler(ctx *app.Context, user reflect.Value, callback string) {
	inWindow := ctx.FormValue("window") != ""
	if user.IsValid() {
		ctx.MustSignIn(asGondolaUser(user))
	}
	if inWindow {
		var payload []byte
		if user.IsValid() {
			var err error
			payload, err = JSONEncode(ctx, user.Interface())
			if err != nil {
				panic(err)
			}
		}
		ctx.MustExecute("js-callback.html", map[string]interface{}{
			"Callback": callback,
			"Payload":  payload,
		})
	} else {
		if user.IsValid() {
			redirectToFrom(ctx)
		} else {
			ctx.MustRedirectReverse(false, app.SignInHandlerName)
		}
	}
}

func validateNewEmail(ctx *app.Context, email string) (string, error) {
	addr, err := mail.Validate(email, true)
	if err != nil {
		return "", i18n.Errorf("this does not look like a valid email address")
	}
	userType := getUserType(ctx)
	found, err := ctx.Orm().Exists(ctx.Orm().TypeTable(userType), ByEmail(addr))
	if err != nil {
		return "", err
	}
	if found {
		return "", i18n.Errorf("email %q is already in use", addr)
	}
	return addr, nil
}

func jsSignUpHandler(ctx *app.Context) {
	d := data(ctx)
	if !d.allowRegistration() {
		ctx.NotFound("")
		return
	}
	user, _ := newEmptyUser(ctx)
	form := SignUpForm(ctx, user)
	if form.Submitted() && form.IsValid() {
		saveNewUser(ctx, user)
		writeJSONEncoded(ctx, user)
		return
	}
	FormErrors(ctx, form)
}

// Implementation of the help command for Gondola apps
func help(ctx *app.Context) {
	var cmd string
	ctx.ParseIndexValue(0, &cmd)
	if cmd != "" {
		c := strings.ToLower(cmd)
		if _, ok := commands[c]; ok {
			fmt.Fprintf(os.Stderr, "Help for command %s:\n", c)
			commandHelp(c, -1, os.Stderr)
		} else {
			fmt.Fprintf(os.Stderr, "No such command %q\n", cmd)
		}
	} else {
		fmt.Fprintf(os.Stderr, "Commands:\n")
		commandsHelp(os.Stderr)
	}
}