func getCover(ctx *web.Context, album string) string {
	dir := musicDir + "/" + album
	cover := "static/image/missing.png"
	if exists(dir + "/cover.jpg") {
		cover = dir + "/cover.jpg"
	} else if exists(dir + "/cover.png") {
		cover = dir + "/cover.png"
	}
	//Open the file
	f, err := os.Open(cover)
	if err != nil {
		return "Error reading file!\n"
	}

	//Get MIME
	r, err := ioutil.ReadAll(f)
	if err != nil {
		return "Error reading file!\n"
	}
	mime := http.DetectContentType(r)

	_, err = f.Seek(0, 0)
	if err != nil {
		return "Error reading the file\n"
	}
	//This is weird - ServeContent supposedly handles MIME setting
	//But the Webgo content setter needs to be used too
	//In addition, ServeFile doesn't work, ServeContent has to be used
	ctx.ContentType(mime)
	http.ServeContent(ctx.ResponseWriter, ctx.Request, cover, time.Now(), f)
	return ""
}

func Remove(ctx *web.Context, val string) string {
	id, err := strconv.Atoi(val)
	if err != nil {
		return "Invalid or malformed id"
	}

	db := util.GetDb()

	_, submit_exists := ctx.Params["doit"]
	if submit_exists {
		db.Exec("DELETE FROM entries WHERE id=$1", id)
		ctx.Redirect(302, "/manage/existing")
		return "Redirect"
	}

	// Get the post
	row := db.QueryRow("SELECT title FROM entries WHERE id=$1", id)
	entry := new(util.Entry)
	row.Scan(&entry.Title)

	send := map[string]interface{}{
		"Title": entry.Title,
	}

	return util.RenderTemplate("remove.mustache", send)
}

func logout(ctx *web.Context) string {
	session, _ := CookieStore.Get(ctx.Request, "monet-session")
	session.Values["authenticated"] = false
	session.Save(ctx.Request, ctx.ResponseWriter)
	ctx.Redirect(302, "/admin/login/")
	return ""
}

func (c *Controller) Publish(ctx *web.Context) {
	if !c.sessionManager.LoggedIn(ctx) {
		ctx.Redirect(303, "/login")
		return
	}
	ctx.WriteString(c.Page("publish.html"))
}

func getSong(ctx *web.Context, song string) string {
	//Open the file
	f, err := os.Open("static/queue/" + song)
	if err != nil {
		return "Error reading file!\n"
	}

	//Get MIME
	r, err := ioutil.ReadAll(f)
	if err != nil {
		return "Error reading file!\n"
	}
	mime := http.DetectContentType(r)

	_, err = f.Seek(0, 0)
	if err != nil {
		return "Error reading the file\n"
	}
	//This is weird - ServeContent supposedly handles MIME setting
	//But the Webgo content setter needs to be used too
	//In addition, ServeFile doesn't work, ServeContent has to be used
	ctx.ContentType(mime)
	http.ServeContent(ctx.ResponseWriter, ctx.Request, "static/queue/"+song, time.Now(), f)
	return ""
}

func fragmentShaderHandler(ctx *web.Context, path string) {
	file, err := os.Open(path)
	check(err)
	ctx.ContentType("x-shader/x-fragment")
	_, err = io.Copy(ctx, file)
	check(err)
}

func api(ctx *web.Context, username string) string {
	user, err := getUser(username)
	ctx.SetHeader("Content-Type", "application/prs.kevinburke.snapchat-v1+json", true)
	if err != nil {
		checkError(err)
		ctx.NotFound("User not found")
		return ""
	}
	friends, err := getFriendsById(user.Id)
	checkError(err)
	var links Links
	var users []User
	users = append(users, *user)
	for i := 0; i < len(friends.Friends); i++ {
		friend := friends.Friends[i]
		link := Link{friend.UserId, friend.FriendId, friend.Index}
		links.Links = append(links.Links, link)
		user, err := getUserById(friend.UserId)
		checkError(err)
		users = append(users, *user)
	}
	response := Response{links.Links, users}
	bytes, err := json.Marshal(response)
	checkError(err)
	return string(bytes)
}

func handleEntry(ctx *web.Context, hash string) {
	type entry struct {
		ChainID string
		Content string
		ExtIDs  []string
	}

	e := new(entry)
	if entry, err := factomapi.EntryByHash(hash); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		e.ChainID = entry.ChainID.String()
		e.Content = hex.EncodeToString(entry.Content)
		for _, v := range entry.ExtIDs {
			e.ExtIDs = append(e.ExtIDs, hex.EncodeToString(v))
		}
	}

	if p, err := json.Marshal(e); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		ctx.Write(p)
	}
}

func handleDirectoryBlockHead(ctx *web.Context) {
	type dbhead struct {
		KeyMR string
	}

	h := new(dbhead)
	if block, err := factomapi.DBlockHead(); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		h.KeyMR = block.KeyMR.String()
	}

	if p, err := json.Marshal(h); err != nil {
		wsLog.Error(err)
		ctx.WriteHeader(httpBad)
		ctx.Write([]byte(err.Error()))
		return
	} else {
		ctx.Write(p)
	}

	//	ctx.WriteHeader(httpOK)
}

func handleEntryCreditBalance(ctx *web.Context, eckey string) {
	type ecbal struct {
		Response string
		Success  bool
	}
	var b ecbal
	adr, err := hex.DecodeString(eckey)
	if err == nil && len(adr) != common.HASH_LENGTH {
		b = ecbal{Response: "Invalid Address", Success: false}
	}
	if err == nil {
		if bal, err := factomapi.ECBalance(eckey); err != nil {
			wsLog.Error(err)
			return
		} else {
			str := fmt.Sprintf("%d", bal)
			b = ecbal{Response: str, Success: true}
		}
	} else {
		b = ecbal{Response: err.Error(), Success: false}
	}

	if p, err := json.Marshal(b); err != nil {
		wsLog.Error(err)
		return
	} else {
		ctx.Write(p)
	}

}

/*
	serve a link with extras (a path relative to the short-link and/or GET parameters)
	Parameters:
		ctx:	the context of the http request
		hash:	the short-hash of the link
		extras:	the extra path component
*/
func serveLinkWithExtras(ctx *web.Context, hash string, extras string) {
	//make the hash all uppercase
	upperHash := strings.ToUpper(hash)

	//Check to see if a link exists for the given hash
	link, numReports, exists, err := db_linkForHash(upperHash)
	if err != nil {
		//There was an error in the database
		internalError(ctx, errors.New("Database Error: "+err.Error()))
	} else if exists {
		//Check to see if the link has been flagged for review
		if numReports >= NUM_REPORTS_TO_FLAG {

			redir := link

			//If there were any path extras passed to us, append them to the redir link
			if extras != "" {
				redir += "/" + extras
			}

			//If there are any GET parameters being passed to us, append them to the redir link
			if len(ctx.Params) > 0 {
				params := "?"
				for k, v := range ctx.Params {
					params += k + "=" + v + "&"
				}
				//remove the trailing ampersand and append to the redir link
				redir += strings.TrimSuffix(params, "&")
			}

			flaggedLink(ctx, hash, redir)
			return

		} else {
			//The hash=>link exists
			redir := link

			//If there were any path extras passed to us, append them to the redir link
			if extras != "" {
				redir += "/" + extras
			}

			//If there are any GET parameters being passed to us, append them to the redir link
			if len(ctx.Params) > 0 {
				params := "?"
				for k, v := range ctx.Params {
					params += k + "=" + v + "&"
				}
				//remove the trailing ampersand and append to the redir link
				redir += strings.TrimSuffix(params, "&")
			}

			//if the hash exists in the link table, issue a '302 Found' to the client with the link URL
			ctx.Redirect(302, redir)
		}
	} else {
		//No link exists for the hash, so serve a '404 Not Found' error page
		error404(ctx, hash)
	}
}

func handleFactoidBalance(ctx *web.Context, eckey string) {
	type fbal struct {
		Response string
		Success  bool
	}
	var b fbal
	adr, err := hex.DecodeString(eckey)
	if err == nil && len(adr) != common.HASH_LENGTH {
		b = fbal{Response: "Invalid Address", Success: false}
	}
	if err == nil {
		v := int64(common.FactoidState.GetBalance(fct.NewAddress(adr)))
		str := fmt.Sprintf("%d", v)
		b = fbal{Response: str, Success: true}
	} else {
		b = fbal{Response: err.Error(), Success: false}
	}

	if p, err := json.Marshal(b); err != nil {
		wsLog.Error(err)
		return
	} else {
		ctx.Write(p)
	}

}

func (server *Server) PostPaths(ctx *web.Context) string {
	var input struct {
		Paths        []geotypes.NodeEdge
		Country      string
		SpeedProfile int
	}

	var (
		computed []geotypes.Path
	)

	if err := json.NewDecoder(ctx.Request.Body).Decode(&input); err != nil {
		content, _ := ioutil.ReadAll(ctx.Request.Body)
		ctx.Abort(400, "Couldn't parse JSON: "+err.Error()+" in '"+string(content)+"'")
		return ""
	} else {
		var err error
		computed, err = server.Via.CalculatePaths(input.Paths, input.Country, input.SpeedProfile)
		if err != nil {
			ctx.Abort(422, "Couldn't resolve addresses: "+err.Error())
			return ""
		}
	}

	res, err := json.Marshal(computed)
	if err != nil {
		ctx.Abort(500, "Couldn't serialize paths: "+err.Error())
		return ""
	}

	ctx.Header().Set("Access-Control-Allow-Origin", "*")
	ctx.ContentType("application/json")
	return string(res)
}

//Handles file retrieval. It uses getURL to send a hash to the urlHandler, and listens on
//sendURL for the proper filename.
func getFile(ctx *web.Context, file string) string {
	dir := file[0:3]
	fname := file[3:]
	path := "files/" + dir + "/" + fname
	//Open the file
	f, err := os.Open(path)
	if err != nil {
		return "Error reading file!\n"
	}

	//Get MIME
	r, err := ioutil.ReadAll(f)
	if err != nil {
		return "Error reading file!\n"
	}
	mime := http.DetectContentType(r)

	_, err = f.Seek(0, 0)
	if err != nil {
		return "Error reading the file\n"
	}
	//This is weird - ServeContent supposedly handles MIME setting
	//But the Webgo content setter needs to be used too
	//In addition, ServeFile doesn't work, ServeContent has to be used
	ctx.ContentType(mime)
	http.ServeContent(ctx.ResponseWriter, ctx.Request, path, time.Now(), f)
	return ""
}

func (h *RestQueueHandler) Put(ctx *web.Context, val string) {
	queue := redisq.NewRedisQueue(h.redis, val)
	if !queue.Exists() {
		h.logger.Printf("Queue [%s] didn't existst, will be ceated.", val)
	}
	if mesg, ok := ctx.Params["value"]; ok {
		var i interface{}
		err := json.Unmarshal([]byte(mesg), &i)
		if err != nil {
			writeError(ctx, 400, JsonDecodeError)
			return
		}
		err = queue.Put(i)
		if err != nil {
			writeError(ctx, 500, PostError)
			if Settings.Debug {
				debug := fmt.Sprintf("Debug: %s", err)
				ctx.WriteString(debug)
			}
			h.logger.Printf("Put message into [%s] Error:%s", val, err)
			return
		}
		h.logger.Printf("Put message into queue [%s]", val)

	} else {
		writeError(ctx, 400, LackPostValue)

	}

}

func vnstat(ctx *web.Context, iface string, debug string) string {
	app := "vnstat"

	arg0 := "-i"
	arg2 := "--xml"

	ctx.SetHeader("Content-Type", "application/json", true)

	rawxml := runcmd(app, arg0, iface, arg2)

	var q Vnstat
	xml.Unmarshal([]byte(rawxml), &q)

	var jsondata []byte
	var err error

	if debug == "debug" {
		jsondata, err = json.MarshalIndent(q, "", "  ")
	} else {
		jsondata, err = json.Marshal(q)
	}

	if err != nil {
		return "Error"
	}
	return string(jsondata)
}

func pngHandler(ctx *web.Context, path string) {
	file, err := os.Open(path)
	check(err)
	ctx.ContentType("png")
	_, err = io.Copy(ctx, file)
	check(err)
}

func Render(ctx *web.Context, tmpl string, config *Config, name string, data interface{}) {
	tmpl = filepath.Join(config.Get("datadir"), tmpl)
	ctx.WriteString(mustache.RenderFile(tmpl,
		map[string]interface{}{
			"config": config,
			name:     data}))
}

func gamePageHandler(ctx *web.Context) {
	gamePage, err := os.Open("index.html")
	check(err)
	ctx.ContentType("html")
	_, err = io.Copy(ctx, gamePage)
	check(err)
}

func checkGodLevel(ctx *web.Context) bool {
	godlevel, _ := ctx.GetSecureCookie("godlevel")
	godlevel = godHash(godlevel)
	if godlevel == admin_pass {
		return true
	}
	return false
}