func ImageHandler(ctx wombat.Context, a *articles.Article, path, filename string) {
	ctx.Response.Header().Set("Content-Type", "application/json")

	// Save the image
	img, err := web.SaveImage(ctx.Request, ctx.Response, path, filename)
	if err != nil {
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
		return
	}

	s := img.Bounds().Size()
	exists := false
	// Add or Update the image
	for _, v := range a.Imgs {
		if v.Src == filename {
			v.W, v.H = s.X, s.Y
			exists = true
		}
	}
	if !exists {
		a.Imgs = append(a.Imgs, articles.Img{filename, "", s.X, s.Y})
	}

	// Update the article's images
	if err = a.SetImgs(a.Imgs); err != nil {
		log.Println("Failed to persit new image: ", filename, " for article: ", a.TitlePath)
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
	} else {
		j := fmt.Sprintf(`{"image":"%s", "w":%d,"h":%d}`, filename, s.X, s.Y)
		ctx.Response.Write([]byte(j))
	}
}

func ThumbHandler(ctx wombat.Context, a *articles.Article, path, filename string) {
	ctx.Response.Header().Set("Content-Type", "application/json")

	// Save & resize the image to a thumbnail
	img, err := web.SaveImage(ctx.Request, ctx.Response, path, filename)
	if err == nil {
		// Resize the image and save it
		if img, err = imagery.ResizeWidth(img, 200); err == nil {
			err = imagery.WriteTo(web.ImageType(ctx.Request), img, path, filename)
		}
	}
	if err != nil {
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
		return
	}

	oldThumb := filepath.Join(path, a.TitlePath, a.Img.Src)
	s := img.Bounds().Size()

	// Update the article's thumbnail
	if err = a.SetImg(articles.Img{filename, filename, s.X, s.Y}); err != nil {
		log.Println("Failed to persit new thumbnail: ", filename, " for article: ", a.TitlePath)
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
	} else {
		os.Remove(oldThumb)
		j := fmt.Sprintf(`{"thumb":"%s", "w":%d,"h":%d}`, filename, s.X, s.Y)
		ctx.Response.Write([]byte(j))
	}
}

func JSONHandler(ctx wombat.Context, a *articles.Article, imagePath string, data []byte) {
	// Get the JSONMessage from the request
	var msg JSONMessage
	err := json.Unmarshal(data, &msg)
	if err != nil {
		ctx.HttpError(http.StatusBadRequest, GetError(ctx.Request, err))
		return
	}

	// Perform the given action
	switch msg.Action {
	default:
		// Invalid/missing action
		err = errors.New("Invalid Action")
	case "setSynopsis":
		err = a.SetSynopsis(msg.Data)
	case "setContent":
		err = a.SetContent(msg.Data)
	case "setActive":
		// Toggle
		err = a.Publish(!a.IsPublished)
	case "deleteImage":
		err = RemoveImage(a, msg.Data, imagePath)
	}

	// Report if the action resulted in an error
	if err != nil {
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
	}
}

func (h Handler) DeleteArticle(ctx wombat.Context, titlePath string) {
	ctx.Response.Header().Set("Content-Type", "application/json")

	o, ok := h.Article(titlePath, true)
	if !ok {
		ctx.HttpError(http.StatusNotFound)
		return
	}

	a := h.ItoArticle(o)
	if err := a.Delete(); err != nil {
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
	}
}

func (h Handler) PostArticles(ctx wombat.Context) {
	title := ctx.FormValue("title")
	if request.IsApplicationJson(ctx.Request) {
		ctx.Response.Header().Set("Content-Type", "application/json")
		defer ctx.Body.Close()
		if b, err := ioutil.ReadAll(ctx.Body); err != nil {
			m := make(map[string]interface{})
			json.Unmarshal(b, &m)
			title, _ = m["title"].(string)
		}
	}

	if title == "" {
		// Missing title
		ctx.HttpError(http.StatusBadRequest, GetErrorStr(ctx.Request, "Missing title"))
		return
	}

	t, err := CreateArticle(ctx, title)
	if err != nil {
		ctx.HttpError(http.StatusInternalServerError, GetError(ctx.Request, err))
		return
	}

	// When not a JSON request issue redirect to new article
	if !request.IsApplicationJson(ctx.Request) {
		ctx.Redirect(fmt.Sprintf("%s/%s?view=edit", h.BasePath, t))
	}
}

func ImagesHandler(ctx wombat.Context, a *articles.Article, imagePath string) {
	// Get the name of the image, or random name if missing/empty
	filename := ctx.FormValue("name")
	if filename == "" {
		filename = web.RandName(5)
	}

	// Save the thumbnail, or image
	path := filepath.Join(imagePath, a.TitlePath)
	if t := ctx.FormValue("type"); t == "thumb" {
		ThumbHandler(ctx, a, path, "thumb."+filename)
	} else {
		ImageHandler(ctx, a, path, filename)
	}
}

/*----------Article-----------*/
func (h Handler) GetArticle(ctx wombat.Context, titlePath string) {
	isAdmin := ctx.User.IsAdmin()
	o, ok := h.Article(titlePath, isAdmin)
	if !ok {
		ctx.HttpError(http.StatusNotFound)
		return
	}

	tmpl := "view"
	if isAdmin && ctx.FormValue("view") == "edit" {
		tmpl = "edit"
	}

	// Handle HTTP/JSON response
	articleResponse(ctx, &h, o, tmpl, titlePath)
}

/*----------Articles----------*/
func (h Handler) GetArticles(ctx wombat.Context) {
	var tmpl string
	var o interface{}

	switch view := ctx.FormValue("view"); {
	default:
		tmpl = "list"
		page, err := strconv.Atoi(ctx.FormValue("page"))
		if err != nil {
			page = 0
		}
		o, _ = h.articles.Recent(h.PageCount, page, ctx.User.IsAdmin())
	case view == "create" && ctx.User.IsAdmin():
		tmpl = "create"
	}

	// Handle HTTP/JSON response
	articleResponse(ctx, &h, o, tmpl, "")
}

func (h Handler) PutArticle(ctx wombat.Context, titlePath string) {
	ctx.Response.Header().Set("Content-Type", "application/json")

	o, ok := h.Article(titlePath, true)
	if !ok {
		ctx.HttpError(http.StatusNotFound)
		return
	}
	a := h.ItoArticle(o)

	// JSON message
	if request.IsApplicationJson(ctx.Request) {
		// Get the bytes for JSON processing
		defer ctx.Body.Close()
		if data, err := ioutil.ReadAll(ctx.Body); err != nil {
			ctx.HttpError(http.StatusBadRequest, GetError(ctx.Request, err))
		} else {
			JSONHandler(ctx, a, h.ImagePath, data)
		}
	} else if IsImageRequest(ctx) {
		ImagesHandler(ctx, a, h.ImagePath)
	} else {
		// Nothing could be done for the given request
		ctx.HttpError(http.StatusBadRequest)
	}
}