package routes

import (
	"crypto/sha256"
	"database/sql"
	"encoding/hex"
	"encoding/json"
	"errors"
	"io"

	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"log"
	"net/http"
	"os"
	"regexp"
	"strconv"
	"strings"

	"golang.org/x/image/tiff"

	c "git.tuxpa.in/a/gosora/common"
	co "git.tuxpa.in/a/gosora/common/counters"
	p "git.tuxpa.in/a/gosora/common/phrases"
	qgen "git.tuxpa.in/a/gosora/query_gen"
)

type TopicStmts struct {
    getLikedTopic *sql.Stmt
}

var topicStmts TopicStmts

// TODO: Move these DbInits into a TopicList abstraction
func init() {
    c.DbInits.Add(func(acc *qgen.Accumulator) error {
        topicStmts = TopicStmts{
            getLikedTopic: acc.Select("likes").Columns("targetItem").Where("sentBy=? && targetItem=? && targetType='topics'").Prepare(),
        }
        return acc.FirstError()
    })
}

func ViewTopic(w http.ResponseWriter, r *http.Request, user *c.User, h *c.Header, urlBit string) c.RouteError {
    page, _ := strconv.Atoi(r.FormValue("page"))
    _, tid, err := ParseSEOURL(urlBit)
    if err != nil {
        return c.SimpleError(p.GetErrorPhrase("url_id_must_be_integer"), w, r, h)
    }

    // Get the topic...
    topic, err := c.GetTopicUser(user, tid)
    if err == sql.ErrNoRows {
        return c.NotFound(w, r, nil) // TODO: Can we add a simplified invocation of header here? This is likely to be an extremely common NotFound
    } else if err != nil {
        return c.InternalError(err, w, r)
    }

    ferr := c.ForumUserCheck(h, w, r, user, topic.ParentID)
    if ferr != nil {
        return ferr
    }
    if !user.Perms.ViewTopic {
        return c.NoPermissions(w, r, user)
    }
    h.Title = topic.Title
    h.Path = topic.Link
    //h.Path = c.BuildTopicURL(c.NameToSlug(topic.Title), topic.ID)

    postGroup, err := c.Groups.Get(topic.Group)
    if err != nil {
        return c.InternalError(err, w, r)
    }

    topic.ContentLines = strings.Count(topic.Content, "\n")
    if !user.Loggedin && user.LastAgent != c.SimpleBots[0] && user.LastAgent != c.SimpleBots[1] {
        if len(topic.Content) > 200 {
            h.OGDesc = topic.Content[:197] + "..."
        } else {
            h.OGDesc = topic.Content
        }
        h.OGDesc = c.H_topic_ogdesc_assign_hook(h.Hooks, h.OGDesc)
    }

    var parseSettings *c.ParseSettings
    if (c.Config.NoEmbed || !postGroup.Perms.AutoEmbed) && (user.ParseSettings == nil || !user.ParseSettings.NoEmbed) {
        parseSettings = c.DefaultParseSettings.CopyPtr()
        parseSettings.NoEmbed = true
    } else {
        parseSettings = user.ParseSettings
    }

    // TODO: Cache ContentHTML when possible?
    topic.ContentHTML, h.ExternalMedia = c.ParseMessage2(topic.Content, topic.ParentID, "forums", parseSettings, user)
    // TODO: Do this more efficiently by avoiding the allocations entirely in ParseMessage, if there's nothing to do.
    if topic.ContentHTML == topic.Content {
        topic.ContentHTML = topic.Content
    }

    topic.Tag = postGroup.Tag
    if postGroup.IsMod {
        topic.ClassName = c.Config.StaffCSS
    }
    topic.Deletable = user.Perms.DeleteTopic || topic.CreatedBy == user.ID

    forum, err := c.Forums.Get(topic.ParentID)
    if err != nil {
        return c.InternalError(err, w, r)
    }

    var poll *c.Poll
    if topic.Poll != 0 {
        pPoll, err := c.Polls.Get(topic.Poll)
        if err != nil {
            log.Print("Couldn't find the attached poll for topic " + strconv.Itoa(topic.ID))
            return c.InternalError(err, w, r)
        }
        poll = new(c.Poll)
        *poll = pPoll.Copy()
    }

    if topic.LikeCount > 0 && user.Liked > 0 {
        var disp int // Discard this value
        err = topicStmts.getLikedTopic.QueryRow(user.ID, topic.ID).Scan(&disp)
        if err == nil {
            topic.Liked = true
        } else if err != nil && err != sql.ErrNoRows {
            return c.InternalError(err, w, r)
        }
    }

    if topic.AttachCount > 0 {
        attachs, err := c.Attachments.MiniGetList("topics", topic.ID)
        if err != nil && err != sql.ErrNoRows {
            // TODO: We might want to be a little permissive here in-case of a desync?
            return c.InternalError(err, w, r)
        }
        topic.Attachments = attachs
    }

    // Calculate the offset
    offset, page, lastPage := c.PageOffset(topic.PostCount, page, c.Config.ItemsPerPage)
    pageList := c.Paginate(page, lastPage, 5)
    tpage := c.TopicPage{h, nil, topic, forum, poll, c.Paginator{pageList, page, lastPage}}

    // Get the replies if we have any...
    if topic.PostCount > 0 {
        /*var pFrag int
        if strings.HasPrefix(r.URL.Fragment, "post-") {
            pFrag, _ = strconv.Atoi(strings.TrimPrefix(r.URL.Fragment, "post-"))
        }*/
        rlist, externalHead, err := topic.Replies(offset /* pFrag,*/, user)
        if err == sql.ErrNoRows {
            return c.LocalError("Bad Page. Some of the posts may have been deleted or you got here by directly typing in the page number.", w, r, user)
        } else if err != nil {
            return c.InternalError(err, w, r)
        }
        //fmt.Printf("rlist: %+v\n",rlist)
        tpage.ItemList = rlist
        if externalHead {
            h.ExternalMedia = true
        }
    }

    h.Zone = "view_topic"
    h.ZoneID = topic.ID
    h.ZoneData = topic

    var rerr c.RouteError
    tmpl := forum.Tmpl
    if r.FormValue("i") == "1" {
        if tpage.Poll != nil {
            h.AddXRes("chartist/chartist.min.css", "chartist/chartist.min.js")
        }
        if tmpl == "" {
            rerr = renderTemplate("topic_mini", w, r, h, tpage)
        } else {
            tmpl = "topic_mini" + tmpl
            err = renderTemplate3(tmpl, tmpl, w, r, h, tpage)
            if err != nil {
                rerr = renderTemplate("topic_mini", w, r, h, tpage)
            }
        }
    } else {
        if tpage.Poll != nil {
            h.AddSheet("chartist/chartist.min.css")
            h.AddScript("chartist/chartist.min.js")
        }
        if tmpl == "" {
            rerr = renderTemplate("topic", w, r, h, tpage)
        } else {
            tmpl = "topic_" + tmpl
            err = renderTemplate3(tmpl, tmpl, w, r, h, tpage)
            if err != nil {
                rerr = renderTemplate("topic", w, r, h, tpage)
            }
        }
    }
    co.TopicViewCounter.Bump(topic.ID) // TODO: Move this into the router?
    co.ForumViewCounter.Bump(topic.ParentID)
    return rerr
}

func AttachTopicActCommon(w http.ResponseWriter, r *http.Request, u *c.User, stid string) (t *c.Topic, ferr c.RouteError) {
    tid, e := strconv.Atoi(stid)
    if e != nil {
        return t, c.LocalErrorJS(p.GetErrorPhrase("id_must_be_integer"), w, r)
    }
    t, e = c.Topics.Get(tid)
    if e != nil {
        return t, c.NotFoundJS(w, r)
    }
    _, ferr = c.SimpleForumUserCheck(w, r, u, t.ParentID)
    if ferr != nil {
        return t, ferr
    }
    if t.IsClosed && !u.Perms.CloseTopic {
        return t, c.NoPermissionsJS(w, r, u)
    }
    return t, nil
}

// TODO: Avoid uploading this again if the attachment already exists? They'll resolve to the same hash either way, but we could save on some IO / bandwidth here
// TODO: Enforce the max request limit on all of this topic's attachments
// TODO: Test this route
func AddAttachToTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    topic, ferr := AttachTopicActCommon(w, r, u, stid)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.EditTopic || !u.Perms.UploadFiles {
        return c.NoPermissionsJS(w, r, u)
    }

    // Handle the file attachments
    pathMap, rerr := uploadAttachment(w, r, u, topic.ParentID, "forums", topic.ID, "topics", "")
    if rerr != nil {
        // TODO: This needs to be a JS error...
        return rerr
    }
    if len(pathMap) == 0 {
        return c.InternalErrorJS(errors.New("no paths for attachment add"), w, r)
    }

    var elemStr string
    for path, aids := range pathMap {
        elemStr += "\"" + path + "\":\"" + aids + "\","
    }
    if len(elemStr) > 1 {
        elemStr = elemStr[:len(elemStr)-1]
    }

    w.Write([]byte(`{"success":1,"elems":[{` + elemStr + `}]}`))
    return nil
}

func RemoveAttachFromTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    _, ferr := AttachTopicActCommon(w, r, u, stid)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.EditTopic {
        return c.NoPermissionsJS(w, r, u)
    }

    for _, said := range strings.Split(r.PostFormValue("aids"), ",") {
        aid, err := strconv.Atoi(said)
        if err != nil {
            return c.LocalErrorJS(p.GetErrorPhrase("id_must_be_integer"), w, r)
        }
        rerr := deleteAttachment(w, r, u, aid, true)
        if rerr != nil {
            // TODO: This needs to be a JS error...
            return rerr
        }
    }

    w.Write(successJSONBytes)
    return nil
}

// ? - Should we add a new permission or permission zone (like per-forum permissions) specifically for profile comment creation
// ? - Should we allow banned users to make reports? How should we handle report abuse?
// TODO: Add a permission to stop certain users from using custom avatars
// ? - Log username changes and put restrictions on this?
// TODO: Test this
// TODO: Revamp this route
func CreateTopic(w http.ResponseWriter, r *http.Request, u *c.User, h *c.Header, sfid string) c.RouteError {
    var fid int
    var err error
    if sfid != "" {
        fid, err = strconv.Atoi(sfid)
        if err != nil {
            return c.LocalError(p.GetErrorPhrase("url_id_must_be_integer"), w, r, u)
        }
    }
    if fid == 0 {
        fid = c.Config.DefaultForum
    }

    ferr := c.ForumUserCheck(h, w, r, u, fid)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.CreateTopic {
        return c.NoPermissions(w, r, u)
    }
    // TODO: Add a phrase for this
    h.Title = p.GetTitlePhrase("create_topic")
    h.Zone = "create_topic"

    // Lock this to the forum being linked?
    // Should we always put it in strictmode when it's linked from another forum? Well, the user might end up changing their mind on what forum they want to post in and it would be a hassle, if they had to switch pages, even if it is a single click for many (exc. mobile)
    var strict bool
    h.Hooks.VhookNoRet("topic_create_pre_loop", w, r, fid, h, u, &strict)

    // TODO: Re-add support for plugin_guilds
    var forumList []c.Forum
    var canSee []int
    if u.IsSuperAdmin {
        canSee, err = c.Forums.GetAllVisibleIDs()
        if err != nil {
            return c.InternalError(err, w, r)
        }
    } else {
        group, err := c.Groups.Get(u.Group)
        if err != nil {
            // TODO: Refactor this
            c.LocalError("Something weird happened behind the scenes", w, r, u)
            log.Printf("Group #%d doesn't exist, but it's set on c.User #%d", u.Group, u.ID)
            return nil
        }
        canSee = group.CanSee
    }

    // TODO: plugin_superadmin needs to be able to override this loop. Skip flag on topic_create_pre_loop?
    for _, ffid := range canSee {
        // TODO: Surely, there's a better way of doing this. I've added it in for now to support plugin_guilds, but we really need to clean this up
        if strict && ffid != fid {
            continue
        }

        // Do a bulk forum fetch, just in case it's the SqlForumStore?
        f := c.Forums.DirtyGet(ffid)
        if f.Name != "" && f.Active {
            fcopy := f.Copy()
            // TODO: Abstract this
            //if h.Hooks.HookSkip("topic_create_frow_assign", &fcopy) {
            if c.H_topic_create_frow_assign_hook(h.Hooks, &fcopy) {
                continue
            }
            forumList = append(forumList, fcopy)
        }
    }

    return renderTemplate("create_topic", w, r, h, c.CreateTopicPage{h, forumList, fid})
}

func CreateTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User) c.RouteError {
    fid, err := strconv.Atoi(r.PostFormValue("board"))
    if err != nil {
        return c.LocalError(p.GetErrorPhrase("id_must_be_integer"), w, r, u)
    }
    // TODO: Add hooks to make use of headerLite
    lite, ferr := c.SimpleForumUserCheck(w, r, u, fid)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.CreateTopic {
        return c.NoPermissions(w, r, u)
    }

    name := c.SanitiseSingleLine(r.PostFormValue("name"))
    content := c.PreparseMessage(r.PostFormValue("content"))
    // TODO: Fully parse the post and store it in the parsed column
    tid, err := c.Topics.Create(fid, name, content, u.ID, u.GetIP())
    if err != nil {
        switch err {
        case c.ErrNoRows:
            return c.LocalError("Something went wrong, perhaps the forum got deleted?", w, r, u)
        case c.ErrNoTitle:
            return c.LocalError("This topic doesn't have a title", w, r, u)
        case c.ErrLongTitle:
            return c.LocalError("The length of the title is too long, max: "+strconv.Itoa(c.Config.MaxTopicTitleLength), w, r, u)
        case c.ErrNoBody:
            return c.LocalError("This topic doesn't have a body", w, r, u)
        }
        return c.InternalError(err, w, r)
    }

    topic, err := c.Topics.Get(tid)
    if err != nil {
        return c.LocalError("Unable to load the topic", w, r, u)
    }
    if r.PostFormValue("has_poll") == "1" {
        maxPollOptions := 10
        pollInputItems := make(map[int]string)
        for key, values := range r.Form {
            if !strings.HasPrefix(key, "pollinputitem[") {
                continue
            }
            halves := strings.Split(key, "[")
            if len(halves) != 2 {
                return c.LocalError("Malformed pollinputitem", w, r, u)
            }
            halves[1] = strings.TrimSuffix(halves[1], "]")

            index, err := strconv.Atoi(halves[1])
            if err != nil {
                return c.LocalError("Malformed pollinputitem", w, r, u)
            }
            for _, value := range values {
                // If there are duplicates, then something has gone horribly wrong, so let's ignore them, this'll likely happen during an attack
                _, exists := pollInputItems[index]
                // TODO: Should we use SanitiseBody instead to keep the newlines?
                if !exists && len(c.SanitiseSingleLine(value)) != 0 {
                    pollInputItems[index] = c.SanitiseSingleLine(value)
                    if len(pollInputItems) >= maxPollOptions {
                        break
                    }
                }
            }
        }

        if len(pollInputItems) > 0 {
            // Make sure the indices are sequential to avoid out of bounds issues
            seqPollInputItems := make(map[int]string)
            for i := 0; i < len(pollInputItems); i++ {
                seqPollInputItems[i] = pollInputItems[i]
            }

            pollType := 0 // Basic single choice
            _, err := c.Polls.Create(topic, pollType, seqPollInputItems)
            if err != nil {
                return c.LocalError("Failed to add poll to topic", w, r, u) // TODO: Might need to be an internal error as it could leave phantom polls?
            }
        }
    }

    err = c.Subscriptions.Add(u.ID, tid, "topic")
    if err != nil {
        return c.InternalError(err, w, r)
    }
    err = u.IncreasePostStats(c.WordCount(content), true)
    if err != nil {
        return c.InternalError(err, w, r)
    }

    // Handle the file attachments
    if u.Perms.UploadFiles {
        _, rerr := uploadAttachment(w, r, u, fid, "forums", tid, "topics", "")
        if rerr != nil {
            return rerr
        }
    }

    co.PostCounter.Bump()
    co.TopicCounter.Bump()
    // TODO: Pass more data to this hook?
    skip, rerr := lite.Hooks.VhookSkippable("action_end_create_topic", tid, u)
    if skip || rerr != nil {
        return rerr
    }
    http.Redirect(w, r, "/topic/"+strconv.Itoa(tid), http.StatusSeeOther)
    return nil
}

// TODO: Move this function
func uploadFilesWithHash(w http.ResponseWriter, r *http.Request, u *c.User, dir string) (filenames []string, rerr c.RouteError) {
    files, ok := r.MultipartForm.File["upload_files"]
    if !ok {
        return nil, nil
    }
    if len(files) > 5 {
        return nil, c.LocalError("You can't attach more than five files", w, r, u)
    }
    disableEncode := r.PostFormValue("ko") == "1"

    for _, file := range files {
        if file.Filename == "" {
            continue
        }
        //c.DebugLog("file.Filename ", file.Filename)

        extarr := strings.Split(file.Filename, ".")
        if len(extarr) < 2 {
            return nil, c.LocalError("Bad file", w, r, u)
        }
        ext := extarr[len(extarr)-1]

        // TODO: Can we do this without a regex?
        reg, err := regexp.Compile("[^A-Za-z0-9]+")
        if err != nil {
            return nil, c.LocalError("Bad file extension", w, r, u)
        }
        ext = strings.ToLower(reg.ReplaceAllString(ext, ""))
        if !c.AllowedFileExts.Contains(ext) {
            return nil, c.LocalError("You're not allowed to upload files with this extension", w, r, u)
        }

        inFile, err := file.Open()
        if err != nil {
            return nil, c.LocalError("Upload failed", w, r, u)
        }
        defer inFile.Close()

        hasher := sha256.New()
        _, err = io.Copy(hasher, inFile)
        if err != nil {
            return nil, c.LocalError("Upload failed [Hashing Failed]", w, r, u)
        }
        inFile.Close()

        checksum := hex.EncodeToString(hasher.Sum(nil))
        filename := checksum + "." + ext

        inFile, err = file.Open()
        if err != nil {
            return nil, c.LocalError("Upload failed", w, r, u)
        }
        defer inFile.Close()

        outFile, err := os.Create(dir + filename)
        if err != nil {
            return nil, c.LocalError("Upload failed [File Creation Failed]", w, r, u)
        }
        defer outFile.Close()

        if disableEncode || (ext != "jpg" && ext != "jpeg" && ext != "png" && ext != "gif" && ext != "tiff" && ext != "tif") {
            _, err = io.Copy(outFile, inFile)
            if err != nil {
                return nil, c.LocalError("Upload failed [Copy Failed]", w, r, u)
            }
        } else {
            img, _, err := image.Decode(inFile)
            if err != nil {
                return nil, c.LocalError("Upload failed [Image Decoding Failed]", w, r, u)
            }

            switch ext {
            case "gif":
                err = gif.Encode(outFile, img, nil)
            case "png":
                err = png.Encode(outFile, img)
            case "tiff", "tif":
                err = tiff.Encode(outFile, img, nil)
            default:
                err = jpeg.Encode(outFile, img, nil)
            }
            if err != nil {
                return nil, c.LocalError("Upload failed [Image Encoding Failed]", w, r, u)
            }
        }

        filenames = append(filenames, filename)
    }

    return filenames, nil
}

// TODO: Update the stats after edits so that we don't under or over decrement stats during deletes
// TODO: Disable stat updates in posts handled by plugin_guilds
func EditTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    js := (r.PostFormValue("js") == "1")
    tid, err := strconv.Atoi(stid)
    if err != nil {
        return c.PreErrorJSQ(p.GetErrorPhrase("id_must_be_integer"), w, r, js)
    }
    topic, err := c.Topics.Get(tid)
    if err == sql.ErrNoRows {
        return c.PreErrorJSQ("The topic you tried to edit doesn't exist.", w, r, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // TODO: Add hooks to make use of headerLite
    lite, ferr := c.SimpleForumUserCheck(w, r, u, topic.ParentID)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.EditTopic {
        return c.NoPermissionsJSQ(w, r, u, js)
    }
    if topic.IsClosed && !u.Perms.CloseTopic {
        return c.NoPermissionsJSQ(w, r, u, js)
    }

    err = topic.Update(r.PostFormValue("name"), r.PostFormValue("content"))
    // TODO: Avoid duplicating this across this route and the topic creation route
    if err != nil {
        switch err {
        case c.ErrNoTitle:
            return c.LocalErrorJSQ("This topic doesn't have a title", w, r, u, js)
        case c.ErrLongTitle:
            return c.LocalErrorJSQ("The length of the title is too long, max: "+strconv.Itoa(c.Config.MaxTopicTitleLength), w, r, u, js)
        case c.ErrNoBody:
            return c.LocalErrorJSQ("This topic doesn't have a body", w, r, u, js)
        }
        return c.InternalErrorJSQ(err, w, r, js)
    }

    err = c.Forums.UpdateLastTopic(topic.ID, u.ID, topic.ParentID)
    if err != nil && err != sql.ErrNoRows {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // TODO: Avoid the load to get this faster?
    topic, err = c.Topics.Get(topic.ID)
    if err == sql.ErrNoRows {
        return c.PreErrorJSQ("The updated topic doesn't exist.", w, r, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    skip, rerr := lite.Hooks.VhookSkippable("action_end_edit_topic", topic.ID, u)
    if skip || rerr != nil {
        return rerr
    }

    if !js {
        http.Redirect(w, r, "/topic/"+strconv.Itoa(tid), http.StatusSeeOther)
    } else {
        outBytes, err := json.Marshal(JsonReply{c.ParseMessage(topic.Content, topic.ParentID, "forums", u.ParseSettings, u)})
        if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }
        w.Write(outBytes)
    }
    return nil
}

// TODO: Add support for soft-deletion and add a permission for hard delete in addition to the usual
// TODO: Disable stat updates in posts handled by plugin_guilds
func DeleteTopicSubmit(w http.ResponseWriter, r *http.Request, user *c.User) c.RouteError {
    // TODO: Move this to some sort of middleware
    var tids []int
    js := c.ReqIsJson(r)
    if js {
        if r.Body == nil {
            return c.PreErrorJS("No request body", w, r)
        }
        err := json.NewDecoder(r.Body).Decode(&tids)
        if err != nil {
            return c.PreErrorJS("We weren't able to parse your data", w, r)
        }
    } else {
        tid, err := strconv.Atoi(r.URL.Path[len("/topic/delete/submit/"):])
        if err != nil {
            return c.PreError("The provided TopicID is not a valid number.", w, r)
        }
        tids = []int{tid}
    }
    if len(tids) == 0 {
        return c.LocalErrorJSQ("You haven't provided any IDs", w, r, user, js)
    }

    for _, tid := range tids {
        topic, err := c.Topics.Get(tid)
        if err == sql.ErrNoRows {
            return c.PreErrorJSQ("The topic you tried to delete doesn't exist.", w, r, js)
        } else if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }

        // TODO: Add hooks to make use of headerLite
        lite, ferr := c.SimpleForumUserCheck(w, r, user, topic.ParentID)
        if ferr != nil {
            return ferr
        }
        if topic.CreatedBy != user.ID {
            if !user.Perms.ViewTopic || !user.Perms.DeleteTopic {
                return c.NoPermissionsJSQ(w, r, user, js)
            }
        }

        // We might be able to handle this err better
        err = topic.Delete()
        if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }
        err = c.ModLogs.Create("delete", tid, "topic", user.GetIP(), user.ID)
        if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }

        // ? - We might need to add soft-delete before we can do an action reply for this
        /*_, err = stmts.createActionReply.Exec(tid,"delete",ip,user.ID)
        if err != nil {
            return c.InternalErrorJSQ(err,w,r,js)
        }*/

        // TODO: Do a bulk delete action hook?
        skip, rerr := lite.Hooks.VhookSkippable("action_end_delete_topic", topic.ID, user)
        if skip || rerr != nil {
            return rerr
        }

        log.Printf("Topic #%d was deleted by UserID #%d", tid, user.ID)
    }
    http.Redirect(w, r, "/", http.StatusSeeOther)
    return nil
}

func StickTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    topic, lite, rerr := topicActionPre(stid, "pin", w, r, u)
    if rerr != nil {
        return rerr
    }
    if !u.Perms.ViewTopic || !u.Perms.PinTopic {
        return c.NoPermissions(w, r, u)
    }
    return topicActionPost(topic.Stick(), "stick", w, r, lite, topic, u)
}

//
//
// mark
//
//
func topicActionPre(stid, action string, w http.ResponseWriter, r *http.Request, u *c.User) (*c.Topic, *c.HeaderLite, c.RouteError) {
    tid, err := strconv.Atoi(stid)
    if err != nil {
        return nil, nil, c.PreError(p.GetErrorPhrase("id_must_be_integer"), w, r)
    }
    t, err := c.Topics.Get(tid)
    if err == sql.ErrNoRows {
        return nil, nil, c.PreError("The topic you tried to "+action+" doesn't exist.", w, r)
    } else if err != nil {
        return nil, nil, c.InternalError(err, w, r)
    }

    // TODO: Add hooks to make use of headerLite
    lite, ferr := c.SimpleForumUserCheck(w, r, u, t.ParentID)
    if ferr != nil {
        return nil, nil, ferr
    }
    return t, lite, nil
}

func topicActionPost(err error, action string, w http.ResponseWriter, r *http.Request, lite *c.HeaderLite, topic *c.Topic, u *c.User) c.RouteError {
    if err != nil {
        return c.InternalError(err, w, r)
    }
    err = addTopicAction(action, topic, u)
    if err != nil {
        return c.InternalError(err, w, r)
    }
    skip, rerr := lite.Hooks.VhookSkippable("action_end_"+action+"_topic", topic.ID, u)
    if skip || rerr != nil {
        return rerr
    }
    http.Redirect(w, r, "/topic/"+strconv.Itoa(topic.ID), http.StatusSeeOther)
    return nil
}

func UnstickTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    t, lite, rerr := topicActionPre(stid, "unpin", w, r, u)
    if rerr != nil {
        return rerr
    }
    if !u.Perms.ViewTopic || !u.Perms.PinTopic {
        return c.NoPermissions(w, r, u)
    }
    return topicActionPost(t.Unstick(), "unstick", w, r, lite, t, u)
}

func LockTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User) c.RouteError {
    // TODO: Move this to some sort of middleware
    var tids []int
    js := c.ReqIsJson(r)
    if js {
        if r.Body == nil {
            return c.PreErrorJS("No request body", w, r)
        }
        err := json.NewDecoder(r.Body).Decode(&tids)
        if err != nil {
            return c.PreErrorJS("We weren't able to parse your data", w, r)
        }
    } else {
        tid, err := strconv.Atoi(r.URL.Path[len("/topic/lock/submit/"):])
        if err != nil {
            return c.PreError("The provided TopicID is not a valid number.", w, r)
        }
        tids = append(tids, tid)
    }
    if len(tids) == 0 {
        return c.LocalErrorJSQ("You haven't provided any IDs", w, r, u, js)
    }

    for _, tid := range tids {
        topic, err := c.Topics.Get(tid)
        if err == sql.ErrNoRows {
            return c.PreErrorJSQ("The topic you tried to lock doesn't exist.", w, r, js)
        } else if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }

        // TODO: Add hooks to make use of headerLite
        lite, ferr := c.SimpleForumUserCheck(w, r, u, topic.ParentID)
        if ferr != nil {
            return ferr
        }
        if !u.Perms.ViewTopic || !u.Perms.CloseTopic {
            return c.NoPermissionsJSQ(w, r, u, js)
        }

        err = topic.Lock()
        if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }

        err = addTopicAction("lock", topic, u)
        if err != nil {
            return c.InternalErrorJSQ(err, w, r, js)
        }

        // TODO: Do a bulk lock action hook?
        skip, rerr := lite.Hooks.VhookSkippable("action_end_lock_topic", topic.ID, u)
        if skip || rerr != nil {
            return rerr
        }
    }

    if len(tids) == 1 {
        http.Redirect(w, r, "/topic/"+strconv.Itoa(tids[0]), http.StatusSeeOther)
    }
    return nil
}

func UnlockTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    t, lite, rerr := topicActionPre(stid, "unlock", w, r, u)
    if rerr != nil {
        return rerr
    }
    if !u.Perms.ViewTopic || !u.Perms.CloseTopic {
        return c.NoPermissions(w, r, u)
    }
    return topicActionPost(t.Unlock(), "unlock", w, r, lite, t, u)
}

// ! JS only route
// TODO: Figure a way to get this route to work without JS
func MoveTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, sfid string) c.RouteError {
    fid, err := strconv.Atoi(sfid)
    if err != nil {
        return c.PreErrorJS(p.GetErrorPhrase("id_must_be_integer"), w, r)
    }
    // TODO: Move this to some sort of middleware
    var tids []int
    if r.Body == nil {
        return c.PreErrorJS("No request body", w, r)
    }
    err = json.NewDecoder(r.Body).Decode(&tids)
    if err != nil {
        return c.PreErrorJS("We weren't able to parse your data", w, r)
    }
    if len(tids) == 0 {
        return c.LocalErrorJS("You haven't provided any IDs", w, r)
    }

    for _, tid := range tids {
        topic, err := c.Topics.Get(tid)
        if err == sql.ErrNoRows {
            return c.PreErrorJS("The topic you tried to move doesn't exist.", w, r)
        } else if err != nil {
            return c.InternalErrorJS(err, w, r)
        }

        // TODO: Add hooks to make use of headerLite
        _, ferr := c.SimpleForumUserCheck(w, r, u, topic.ParentID)
        if ferr != nil {
            return ferr
        }
        if !u.Perms.ViewTopic || !u.Perms.MoveTopic {
            return c.NoPermissionsJS(w, r, u)
        }
        lite, ferr := c.SimpleForumUserCheck(w, r, u, fid)
        if ferr != nil {
            return ferr
        }
        if !u.Perms.ViewTopic || !u.Perms.MoveTopic {
            return c.NoPermissionsJS(w, r, u)
        }

        err = topic.MoveTo(fid)
        if err != nil {
            return c.InternalErrorJS(err, w, r)
        }
        // ? - Is there a better way of doing this?
        err = addTopicAction("move-"+strconv.Itoa(fid), topic, u)
        if err != nil {
            return c.InternalErrorJS(err, w, r)
        }

        // TODO: Do a bulk move action hook?
        skip, rerr := lite.Hooks.VhookSkippable("action_end_move_topic", topic.ID, u)
        if skip || rerr != nil {
            return rerr
        }
    }

    if len(tids) == 1 {
        http.Redirect(w, r, "/topic/"+strconv.Itoa(tids[0]), http.StatusSeeOther)
    }
    return nil
}

func addTopicAction(action string, t *c.Topic, u *c.User) error {
    err := c.ModLogs.Create(action, t.ID, "topic", u.GetIP(), u.ID)
    if err != nil {
        return err
    }
    return t.CreateActionReply(action, u.GetIP(), u.ID)
}

// TODO: Refactor this
func LikeTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    js := r.PostFormValue("js") == "1"
    tid, err := strconv.Atoi(stid)
    if err != nil {
        return c.PreErrorJSQ(p.GetErrorPhrase("id_must_be_integer"), w, r, js)
    }
    topic, err := c.Topics.Get(tid)
    if err == sql.ErrNoRows {
        return c.PreErrorJSQ("The requested topic doesn't exist.", w, r, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // TODO: Add hooks to make use of headerLite
    lite, ferr := c.SimpleForumUserCheck(w, r, u, topic.ParentID)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.LikeItem {
        return c.NoPermissionsJSQ(w, r, u, js)
    }
    if topic.CreatedBy == u.ID {
        return c.LocalErrorJSQ("You can't like your own topics", w, r, u, js)
    }

    _, err = c.Users.Get(topic.CreatedBy)
    if err != nil && err == sql.ErrNoRows {
        return c.LocalErrorJSQ("The target user doesn't exist", w, r, u, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    score := 1
    err = topic.Like(score, u.ID)
    if err == c.ErrAlreadyLiked {
        return c.LocalErrorJSQ("You already liked this", w, r, u, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // ! Be careful about leaking per-route permission state with user ptr
    alert := c.Alert{ActorID: u.ID, TargetUserID: topic.CreatedBy, Event: "like", ElementType: "topic", ElementID: tid, Actor: u}
    err = c.AddActivityAndNotifyTarget(alert)
    if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    skip, rerr := lite.Hooks.VhookSkippable("action_end_like_topic", topic.ID, u)
    if skip || rerr != nil {
        return rerr
    }
    return actionSuccess(w, r, "/topic/"+strconv.Itoa(tid), js)
}
func UnlikeTopicSubmit(w http.ResponseWriter, r *http.Request, u *c.User, stid string) c.RouteError {
    js := r.PostFormValue("js") == "1"
    tid, err := strconv.Atoi(stid)
    if err != nil {
        return c.PreErrorJSQ(p.GetErrorPhrase("id_must_be_integer"), w, r, js)
    }
    topic, err := c.Topics.Get(tid)
    if err == sql.ErrNoRows {
        return c.PreErrorJSQ("The requested topic doesn't exist.", w, r, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // TODO: Add hooks to make use of headerLite
    lite, ferr := c.SimpleForumUserCheck(w, r, u, topic.ParentID)
    if ferr != nil {
        return ferr
    }
    if !u.Perms.ViewTopic || !u.Perms.LikeItem {
        return c.NoPermissionsJSQ(w, r, u, js)
    }

    _, err = c.Users.Get(topic.CreatedBy)
    if err != nil && err == sql.ErrNoRows {
        return c.LocalErrorJSQ("The target user doesn't exist", w, r, u, js)
    } else if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }
    err = topic.Unlike(u.ID)
    if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    // TODO: Better coupling between the two params queries
    aids, err := c.Activity.AidsByParams("like", topic.ID, "topic")
    if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }
    for _, aid := range aids {
        c.DismissAlert(topic.CreatedBy, aid)
    }
    err = c.Activity.DeleteByParams("like", topic.ID, "topic")
    if err != nil {
        return c.InternalErrorJSQ(err, w, r, js)
    }

    skip, rerr := lite.Hooks.VhookSkippable("action_end_unlike_topic", topic.ID, u)
    if skip || rerr != nil {
        return rerr
    }
    return actionSuccess(w, r, "/topic/"+strconv.Itoa(tid), js)
}