//Delete a page.  Returns the revision, if successful
func (pm *PageManager) Delete(wiki string, pageId string,
	pageRev string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	//Load the page
	thePage := wikit.Page{}
	if _, err := theWiki.ReadPage(pageId, &thePage); err != nil {
		return "", err
	} else if thePage.OwningPage != pageId {
		//Thou shalt not delete historical revisions
		return "", BadRequestError()
	}
	//check if this is a 'home page'
	wm := WikiManager{}
	wr := WikiRecord{}
	if wRev, err := wm.Read(wiki, &wr, curUser); err != nil {
		return "", err
	} else if wr.HomePageId == pageId {
		//This is a home page, so clear the Wiki Record's home page Id
		wr.HomePageId = ""
		_, err = wm.Update(wiki, wRev, &wr, curUser)
		if err != nil {
			return "", err
		}
	}
	return theWiki.DeletePage(pageId, pageRev)
}

//Saves a File Record (not the attachment)
func (fm *FileManager) SaveFileRecord(wiki string, file *wikit.File,
	id string, rev string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	uploadedBy := curUser.User.UserName
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.SaveFileRecord(file, id, rev, uploadedBy)
}

//Gets a list of all comments for a page
func (pm *PageManager) GetComments(wiki string, pageId string,
	pageNum int, numPerPage int,
	curUser *CurrentUserInfo) (*wikit.CommentIndexViewResponse, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.GetCommentsForPage(pageId, pageNum, numPerPage)
}

//Deletes a File Record
func (fm *FileManager) DeleteFile(wiki string,
	id string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	theFile := wikit.File{}
	if rev, err := theWiki.GetFileRecord(id, &theFile); err != nil {
		return "", err
	} else {
		return theWiki.DeleteFileRecord(id, rev)
	}
}

//Creates or Updates a page
//Returns the revision number, if successful
func (pm *PageManager) Save(wiki string, page *wikit.Page,
	pageId string, pageRev string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theUser := curUser.User
	//Read the content from the page
	//parse the markdown to Html
	out := make(chan string)
	//Convert (Sanitized) Markdown to HTML
	go processMarkdown(page.Content.Raw, out)
	page.Content.Formatted = <-out
	//Store the thing, if you have the auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.SavePage(page, pageId, pageRev, theUser.UserName)
}

//Delete a comment.  Returns the revision if successful
func (pm *PageManager) DeleteComment(wiki string, commentId string,
	curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	if pm.allowedToUpdateComment(wiki, commentId, curUser) {
		comment := wikit.Comment{}
		commentRev, err := pm.ReadComment(wiki, commentId, &comment, curUser)
		if err != nil {
			return "", err
		}
		return theWiki.DeleteComment(commentId, commentRev)
	} else {
		return "", errors.New("[Error]:403: Not Authorized")
	}
}

//Creates or updates a comment
func (pm *PageManager) SaveComment(wiki string, pageId string, comment *wikit.Comment,
	commentId string, commentRev string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theUser := curUser.User
	//First, if this is an update, check if this user can update the comment
	if commentRev != "" {
		if cu := pm.allowedToUpdateComment(wiki, commentId, curUser); cu == false {
			return "", errors.New("[Error]:403: Not Authorized")
		}
	}
	//Read the content from the comment
	//parse the markdown to Html
	out := make(chan string)
	//Convert (Sanitized) Markdown to HTML
	go processMarkdown(comment.Content.Raw, out)
	comment.Content.Formatted = <-out
	//Store it
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.SaveComment(comment, commentId, commentRev, pageId, theUser.UserName)
}

//Gets a list of breadcrumbs for the current page
func (pm *PageManager) GetBreadcrumbs(wiki string, pageId string,
	curUser *CurrentUserInfo) ([]Breadcrumb, error) {
	thePage := wikit.Page{}
	if _, err := pm.Read(wiki, pageId, &thePage, curUser); err == nil {
		crumbs := []Breadcrumb{}
		response := wikit.MultiPageResponse{}
		theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), curUser.Auth)
		if szLineage := len(thePage.Lineage); szLineage > 1 {
			lineage := thePage.Lineage[0 : szLineage-1]
			if err = theWiki.ReadMultiplePages(lineage, &response); err != nil {
				return nil, err
			}
		}
		//Add the current page to the end of the list
		currentPageRow := wikit.MultiPageRow{
			Id:  pageId,
			Doc: thePage,
		}
		rows := append(response.Rows, currentPageRow)
		for _, row := range rows {
			theDoc := row.Doc
			parent := ""
			if len(theDoc.Lineage) >= 2 {
				parent = theDoc.Lineage[len(theDoc.Lineage)-2]
			}
			crumb := Breadcrumb{
				Name:   theDoc.Title,
				PageId: row.Id,
				WikiId: wiki,
				Parent: parent,
			}
			crumbs = append(crumbs, crumb)
		}
		return crumbs, nil
	} else {
		return nil, err
	}

}

// Read a page by its slug.
// Assume the wiki Id passed in is a slug also
// Returns the WikiId, the Page Rev, and an error
func (pm *PageManager) ReadBySlug(wikiSlug string, pageSlug string,
	page *wikit.Page, curUser *CurrentUserInfo) (string, string, error) {
	// Need to get the true wiki Id from the slug
	auth := curUser.Auth
	mainDbName := MainDbName()
	mainDb := Connection.SelectDB(mainDbName, auth)
	response := WikiSlugViewResponse{}
	err := mainDb.GetView("wiki_query",
		"getWikiBySlug",
		&response,
		wikit.SetKey(wikiSlug))
	if err != nil {
		return "", "", err
	}
	if len(response.Rows) > 0 {
		wikiId := response.Rows[0].Id
		theWiki := wikit.SelectWiki(Connection, wikiDbString(wikiId), auth)
		pageRev, err := theWiki.ReadPageBySlug(pageSlug, page)
		return wikiId, pageRev, err
	} else {
		return "", "", NotFoundError()
	}
}

func (pm *PageManager) allowedToUpdateComment(wiki string, commentId string,
	curUser *CurrentUserInfo) bool {
	userName := curUser.User.UserName
	userRoles := curUser.User.Roles
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	//First, we need to read the comment record
	comment := wikit.Comment{}
	_, err := theWiki.ReadComment(commentId, &comment)
	if err != nil {
		return false
	}
	//Only admins and the original comment author may update/delete
	isAdmin := util.HasRole(userRoles, AdminRole(wiki)) ||
		util.HasRole(userRoles, AdminRole(MainDbName())) ||
		util.HasRole(userRoles, MasterRole())
	if comment.Author == userName || isAdmin {
		return true
	} else {
		return false
	}

}

//Get file attachment
func (fm *FileManager) GetFileAttachment(wiki, id, rev,
	attType, attName string, curUser *CurrentUserInfo) (io.ReadCloser, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.GetFileAttachment(id, rev, attType, attName)
}

//Saves a File's Attachment
func (fm *FileManager) SaveFileAttachment(wiki, id, rev, attName, attType string,
	attContent io.Reader, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.SaveFileAttachment(id, rev, attName, attType, attContent)
}

//Reads a File Record (but not the attachment)
func (fm *FileManager) ReadFileRecord(wiki string,
	file *wikit.File, id string, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.GetFileRecord(id, file)
}

//Gets a list of all 'files' in a wiki
func (fm *FileManager) Index(wiki string, fileType string, pageNum int, numPerPage int,
	curUser *CurrentUserInfo) (*wikit.FileIndexViewResponse, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.GetFileIndex(fileType, pageNum, numPerPage)
}

//Gets a list of child pages for a given document
func (pm *PageManager) ChildIndex(wiki string, pageId string,
	curUser *CurrentUserInfo) (wikit.PageIndex, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.GetChildPageIndex(pageId)
}

//Read a page
//Pass an empty page to hold the data. returns the revision
func (pm *PageManager) Read(wiki string, pageId string,
	page *wikit.Page, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.ReadPage(pageId, page)
}

//Read a comment
func (pm *PageManager) ReadComment(wiki string, commentId string,
	comment *wikit.Comment, curUser *CurrentUserInfo) (string, error) {
	auth := curUser.Auth
	theWiki := wikit.SelectWiki(Connection, wikiDbString(wiki), auth)
	return theWiki.ReadComment(commentId, comment)
}