src/main/kotlin/de/uapcore/lightpit/servlet/ProjectServlet.kt

/*
 * Copyright 2021 Mike Becker. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

package de.uapcore.lightpit.servlet

import de.uapcore.lightpit.*
import de.uapcore.lightpit.dao.DataAccessObject
import de.uapcore.lightpit.entities.*
import de.uapcore.lightpit.types.*
import de.uapcore.lightpit.viewmodel.*
import jakarta.servlet.annotation.WebServlet
import java.sql.Date

@WebServlet(urlPatterns = ["/projects/*"])
class ProjectServlet : AbstractServlet() {

    init {
        get("/", this::projects)
        get("/%project", this::project)
        get("/%project/issues/%version/%component/", this::project)
        get("/%project/edit", this::projectForm)
        get("/-/create", this::projectForm)
        post("/-/commit", this::projectCommit)
        post("/%project/vcs/analyze", this::vcsAnalyze)

        get("/%project/versions/", this::versions)
        get("/%project/versions/%version/edit", this::versionForm)
        get("/%project/versions/-/create", this::versionForm)
        post("/%project/versions/-/commit", this::versionCommit)

        get("/%project/components/", this::components)
        get("/%project/components/%component/edit", this::componentForm)
        get("/%project/components/-/create", this::componentForm)
        post("/%project/components/-/commit", this::componentCommit)

        get("/%project/issues/%version/%component/%issue", this::issue)
        get("/%project/issues/%version/%component/%issue/edit", this::issueForm)
        post("/%project/issues/%version/%component/%issue/comment", this::issueComment)
        post("/%project/issues/%version/%component/%issue/relation", this::issueRelation)
        get("/%project/issues/%version/%component/%issue/removeRelation", this::issueRemoveRelation)
        get("/%project/issues/%version/%component/-/create", this::issueForm)
        post("/%project/issues/%version/%component/-/commit", this::issueCommit)
    }

    private fun projects(http: HttpRequest, dao: DataAccessObject) {
        val projects = dao.listProjects()
        val projectInfos = projects.map {
            ProjectInfo(
                project = it,
                versions = dao.listVersions(it),
                components = emptyList(), // not required in this view
                issueSummary = dao.collectIssueSummary(it)
            )
        }

        with(http) {
            view = ProjectsView(projectInfos)
            navigationMenu = projectNavMenu(projects)
            styleSheets = listOf("projects")
            render("projects")
        }
    }

    private fun sanitizeNode(name: String): String {
        val san = name.replace(Regex("[/\\\\]"), "-")
        return if (san.startsWith(".")) {
            "v$san"
        } else {
            san
        }
    }

    private fun feedPath(project: Project) = "feed/${project.node}/issues.rss"

    private fun project(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let {path ->
            val project = path.projectInfo.project

            val filter = IssueFilter(http)

            val needRelationsMap = filter.onlyBlocker

            val relationsMap = if (needRelationsMap) dao.getIssueRelationMap(project, filter.includeDone) else emptyMap()

            val specificVersion = path.versionInfo !is OptionalPathInfo.All
            val version = if (path.versionInfo is OptionalPathInfo.Specific) path.versionInfo.elem else null
            val specificComponent = path.componentInfo !is OptionalPathInfo.All
            val component = if (path.componentInfo is OptionalPathInfo.Specific) path.componentInfo.elem else null

            val issues = dao.listIssues(project, filter.includeDone, specificVersion, version, specificComponent, component)
                .sortedWith(IssueSorter(filter.sortPrimary, filter.sortSecondary, filter.sortTertiary))
                .filter {
                    (!filter.onlyMine || (it.assignee?.username ?: "") == (http.remoteUser ?: "<Anonymous>")) &&
                    (!filter.onlyBlocker || (relationsMap[it.id]?.any { (_,type) -> type.blocking }?:false)) &&
                    (filter.status.isEmpty() || filter.status.contains(it.status)) &&
                    (filter.category.isEmpty() || filter.category.contains(it.category))
                }

            with(http) {
                pageTitle = project.name
                view = ProjectDetails(path, issues, filter)
                feedPath = feedPath(project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                javascript = "project-details"
                render("project-details")
            }
        }
    }

    private fun projectForm(http: HttpRequest, dao: DataAccessObject) {
        http.styleSheets = listOf("projects")
        if (!http.pathParams.containsKey("project")) {
            http.view = ProjectEditView(Project(-1), dao.listUsers())
            http.navigationMenu = projectNavMenu(dao.listProjects())
            http.render("project-form")
        } else {
            withPathInfo(http, dao)?.let { path ->
                http.view = ProjectEditView(path.projectInfo.project, dao.listUsers())
                http.navigationMenu = projectNavMenu(dao.listProjects(), path)
                http.render("project-form")
            }
        }
    }

    private fun projectCommit(http: HttpRequest, dao: DataAccessObject) {
        val project = Project(http.param("id")?.toIntOrNull() ?: -1).apply {
            name = http.param("name") ?: ""
            node = http.param("node") ?: ""
            description = http.param("description") ?: ""
            ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
            repoUrl = http.param("repoUrl") ?: ""
            vcs = VcsType.valueOf(http.param("vcs") ?: "None")
            owner = (http.param("owner")?.toIntOrNull() ?: -1).let {
                if (it < 0) null else dao.findUser(it)
            }
            // intentional defaults
            if (node.isBlank()) node = name
            // sanitizing
            node = sanitizeNode(node)
        }

        if (project.id < 0) {
            dao.insertProject(project)
        } else {
            dao.updateProject(project)
        }

        http.renderCommit("projects/${project.node}")
    }

    private fun vcsAnalyze(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            // if analysis is not configured, reject the request
            if (path.projectInfo.project.vcs == VcsType.None) {
                http.response.sendError(404)
                return
            }

            // obtain the list of issues for this project to filter cross-project references
            val knownIds = dao.listIssues(path.projectInfo.project, true).map { it.id }

            // read the provided commit log and merge only the refs that relate issues from the current project
            dao.mergeCommitRefs(parseCommitRefs(http.body).filter { knownIds.contains(it.issueId) })
        }
    }

    private fun versions(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            with(http) {
                pageTitle = "${path.projectInfo.project.name} - ${i18n("navmenu.versions")}"
                view = VersionsView(
                    path.projectInfo,
                    dao.listVersionSummaries(path.projectInfo.project)
                )
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                javascript = "project-details"
                render("versions")
            }
        }
    }

    private fun versionForm(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            val version = if (path.versionInfo is OptionalPathInfo.Specific)
                path.versionInfo.elem else Version(-1, path.projectInfo.project.id)

            with(http) {
                view = VersionEditView(path.projectInfo, version)
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                render("version-form")
            }
        }
    }

    private fun obtainIdAndProject(http: HttpRequest, dao: DataAccessObject): Pair<Int, Project>? {
        val id = http.param("id")?.toIntOrNull()
        val projectid = http.param("projectid")?.toIntOrNull() ?: -1
        val project = dao.findProject(projectid)
        return if (id == null || project == null) {
            http.response.sendError(400)
            null
        } else {
            Pair(id, project)
        }
    }

    private fun versionCommit(http: HttpRequest, dao: DataAccessObject) {
        val idParams = obtainIdAndProject(http, dao) ?: return
        val (id, project) = idParams

        val version = Version(id, project.id).apply {
            name = http.param("name") ?: ""
            node = http.param("node") ?: ""
            ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
            status = http.param("status")?.let(VersionStatus::valueOf) ?: VersionStatus.Future
            // TODO: process error messages
            eol = http.param("eol", ::dateOptValidator, null, mutableListOf())
            release = http.param("release", ::dateOptValidator, null, mutableListOf())
            // intentional defaults
            if (node.isBlank()) node = name
            // sanitizing
            node = sanitizeNode(node)
        }

        // sanitize eol and release date
        if (version.status.isEndOfLife) {
            if (version.eol == null) version.eol = Date(System.currentTimeMillis())
        } else if (version.status.isReleased) {
            if (version.release == null) version.release = Date(System.currentTimeMillis())
        }

        if (id < 0) {
            dao.insertVersion(version)
        } else {
            dao.updateVersion(version)
        }

        http.renderCommit("projects/${project.node}/versions/")
    }

    private fun components(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            with(http) {
                pageTitle = "${path.projectInfo.project.name} - ${i18n("navmenu.components")}"
                view = ComponentsView(
                    path.projectInfo,
                    dao.listComponentSummaries(path.projectInfo.project)
                )
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                javascript = "project-details"
                render("components")
            }
        }
    }

    private fun componentForm(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            val component = if (path.componentInfo is OptionalPathInfo.Specific)
                path.componentInfo.elem else Component(-1, path.projectInfo.project.id)

            with(http) {
                view = ComponentEditView(path.projectInfo, component, dao.listUsers())
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                render("component-form")
            }
        }
    }

    private fun componentCommit(http: HttpRequest, dao: DataAccessObject) {
        val idParams = obtainIdAndProject(http, dao) ?: return
        val (id, project) = idParams

        val component = Component(id, project.id).apply {
            name = http.param("name") ?: ""
            node = http.param("node") ?: ""
            ordinal = http.param("ordinal")?.toIntOrNull() ?: 0
            color = WebColor(http.param("color") ?: "#000000")
            description = http.param("description")
            // TODO: process error message
            active = http.param("active", ::boolValidator, true, mutableListOf())
            lead = (http.param("lead")?.toIntOrNull() ?: -1).let {
                if (it < 0) null else dao.findUser(it)
            }
            // intentional defaults
            if (node.isBlank()) node = name
            // sanitizing
            node = sanitizeNode(node)
        }

        if (id < 0) {
            dao.insertComponent(component)
        } else {
            dao.updateComponent(component)
        }

        http.renderCommit("projects/${project.node}/components/")
    }

    private fun issue(http: HttpRequest, dao: DataAccessObject) {
        val issue = http.pathParams["issue"]?.toIntOrNull()?.let(dao::findIssue)
        if (issue == null) {
            http.response.sendError(404)
            return
        }
        renderIssueView(http, dao, issue)
    }

    private fun renderIssueView(
        http: HttpRequest,
        dao: DataAccessObject,
        issue: Issue,
        relationError: String? = null
    ) {
        withPathInfo(http, dao)?.let {path ->
            val comments = dao.listComments(issue)

            with(http) {
                pageTitle = "#${issue.id} ${issue.subject} (${path.projectInfo.project.name})"
                view = IssueDetailView(
                    path,
                    issue,
                    comments,
                    path.projectInfo.project,
                    dao.listIssues(path.projectInfo.project, true),
                    dao.listIssueRelations(issue),
                    relationError,
                    dao.listCommitRefs(issue)
                )
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                javascript = "issue-editor"
                render("issue-view")
            }
        }
    }

    private fun issueForm(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.let { path ->
            val issue = http.pathParams["issue"]?.toIntOrNull()?.let(dao::findIssue) ?: Issue(
                -1,
                path.projectInfo.project,
            )

            // for new issues set some defaults
            if (issue.id < 0) {
                // pre-select component, if available in the path info
                if (path.componentInfo is OptionalPathInfo.Specific) {
                    issue.component = path.componentInfo.elem
                }

                // pre-select version, if available in the path info
                if (path.versionInfo is OptionalPathInfo.Specific) {
                    if (path.versionInfo.elem.status.isReleased) {
                        issue.affected = path.versionInfo.elem
                    } else {
                        issue.resolved = path.versionInfo.elem
                    }
                }
            }

            with(http) {
                view = IssueEditView(
                    issue,
                    path.projectInfo.versions,
                    path.projectInfo.components,
                    dao.listUsers(),
                    path.projectInfo.project,
                    path
                )
                feedPath = feedPath(path.projectInfo.project)
                navigationMenu = projectNavMenu(dao.listProjects(), path)
                styleSheets = listOf("projects")
                javascript = "issue-editor"
                render("issue-form")
            }
        }
    }

    private fun issueComment(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.run {
            val issue = http.pathParams["issue"]?.toIntOrNull()?.let(dao::findIssue)
            if (issue == null) {
                http.response.sendError(404)
                return
            }

            val commentId = http.param("commentid")?.toIntOrNull() ?: -1
            if (commentId > 0) {
                val comment = dao.findComment(commentId)
                if (comment == null) {
                    http.response.sendError(404)
                    return
                }
                val originalAuthor = comment.author?.username
                if (originalAuthor != null && originalAuthor == http.remoteUser) {
                    val newComment = http.param("comment")
                    if (!newComment.isNullOrBlank()) {
                        comment.comment = newComment
                        dao.updateComment(comment)
                        dao.insertHistoryEvent(issue, comment)
                    } else {
                        logger.debug("Not updating comment ${comment.id} because nothing changed.")
                    }
                } else {
                    http.response.sendError(403)
                    return
                }
            } else {
                val comment = IssueComment(-1, issue.id).apply {
                    author = http.remoteUser?.let { dao.findUserByName(it) }
                    comment = http.param("comment") ?: ""
                }
                val newId = dao.insertComment(comment)
                dao.insertHistoryEvent(issue, comment, newId)
            }

            http.renderCommit("${issuesHref}${issue.id}")
        }
    }

    private fun issueCommit(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.run {
            val issue = Issue(
                http.param("id")?.toIntOrNull() ?: -1,
                projectInfo.project
            ).apply {
                component = dao.findComponent(http.param("component")?.toIntOrNull() ?: -1)
                category = IssueCategory.valueOf(http.param("category") ?: "")
                status = IssueStatus.valueOf(http.param("status") ?: "")
                subject = http.param("subject") ?: ""
                description = http.param("description") ?: ""
                assignee = http.param("assignee")?.toIntOrNull()?.let {
                    when (it) {
                        -1 -> null
                        -2 -> component?.lead
                        else -> dao.findUser(it)
                    }
                }
                // TODO: process error messages
                eta = http.param("eta", ::dateOptValidator, null, mutableListOf())

                affected = http.param("affected")?.toIntOrNull()?.takeIf { it > 0 }?.let { Version(it, project.id) }
                resolved = http.param("resolved")?.toIntOrNull()?.takeIf { it > 0 }?.let { Version(it, project.id) }
            }

            val openId = if (issue.id < 0) {
                val id = dao.insertIssue(issue)
                dao.insertHistoryEvent(issue, id)
                id
            } else {
                val reference = dao.findIssue(issue.id)
                if (reference == null) {
                    http.response.sendError(404)
                    return
                }

                if (issue.hasChanged(reference)) {
                    dao.updateIssue(issue)
                    dao.insertHistoryEvent(issue)
                } else {
                    logger.debug("Not updating issue ${issue.id} because nothing changed.")
                }

                val newComment = http.param("comment")
                if (!newComment.isNullOrBlank()) {
                    val comment = IssueComment(-1, issue.id).apply {
                        author = http.remoteUser?.let { dao.findUserByName(it) }
                        comment = newComment
                    }
                    val commentid = dao.insertComment(comment)
                    dao.insertHistoryEvent(issue, comment, commentid)
                }
                issue.id
            }

            if (http.param("more") != null) {
                http.renderCommit("${issuesHref}-/create")
            } else {
                http.renderCommit("${issuesHref}${openId}")
            }
        }
    }

    private fun issueRelation(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.run {
            val issue = http.pathParams["issue"]?.toIntOrNull()?.let(dao::findIssue)
            if (issue == null) {
                http.response.sendError(404)
                return
            }
            
            // determine the relation type
            val type: Pair<RelationType, Boolean>? = http.param("type")?.let {
                try {
                    if (it.startsWith("!")) {
                        Pair(RelationType.valueOf(it.substring(1)), true)
                    } else {
                        Pair(RelationType.valueOf(it), false)
                    }
                } catch (_: IllegalArgumentException) {
                    null
                }
            }
            
            // if the relation type was invalid, send HTTP 500
            if (type == null) {
                http.response.sendError(500)
                return
            }
            
            // determine the target issue
            val targetIssue: Issue? = http.param("issue")?.let {
                if (it.startsWith("#") && it.length > 1) {
                    it.substring(1).split(" ", limit = 2)[0].toIntOrNull()
                        ?.let(dao::findIssue)
                        ?.takeIf { target -> target.project.id == issue.project.id }
                } else {
                    null
                }
            }

            // check if the target issue is valid
            if (targetIssue == null) {
                renderIssueView(http, dao, issue, "issue.relations.target.invalid")
                return
            }
            
            // commit the result
            dao.insertIssueRelation(IssueRelation(issue, targetIssue, type.first, type.second))
            http.renderCommit("${issuesHref}${issue.id}")
        }
    }

    private fun issueRemoveRelation(http: HttpRequest, dao: DataAccessObject) {
        withPathInfo(http, dao)?.run {
            val issue = http.pathParams["issue"]?.toIntOrNull()?.let(dao::findIssue)
            if (issue == null) {
                http.response.sendError(404)
                return
            }

            // determine relation
            val type = http.param("type")?.let {
                try {RelationType.valueOf(it)}
                catch (_:IllegalArgumentException) {null}
            }
            if (type == null) {
                http.response.sendError(500)
                return
            }
            val rel = http.param("to")?.toIntOrNull()?.let(dao::findIssue)?.let {
                IssueRelation(
                    issue,
                    it,
                    type,
                    http.param("reverse")?.toBoolean() ?: false
                )
            }

            // execute removal, if there is something to remove
            rel?.run(dao::deleteIssueRelation)

            // always pretend that the operation was successful - if there was nothing to remove, it's okay
            http.renderCommit("${issuesHref}${issue.id}")
        }
    }
}