src/main/kotlin/de/uapcore/lightpit/viewmodel/Issues.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.viewmodel

import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
import com.vladsch.flexmark.ext.tables.TablesExtension
import com.vladsch.flexmark.html.HtmlRenderer
import com.vladsch.flexmark.parser.Parser
import com.vladsch.flexmark.util.data.MutableDataSet
import com.vladsch.flexmark.util.data.SharedDataKeys
import de.uapcore.lightpit.HttpRequest
import de.uapcore.lightpit.dao.DataAccessObject
import de.uapcore.lightpit.entities.*
import de.uapcore.lightpit.logic.compareEtaTo
import de.uapcore.lightpit.types.*
import kotlin.math.roundToInt

class IssueSorter(private vararg val criteria: Criteria) : Comparator<Issue> {
    enum class Field {
        DONE, PHASE, STATUS, CATEGORY, ETA, UPDATED, CREATED;

        val resourceKey: String by lazy {
            if (this == DONE) "issue.filter.sort.done"
            else if (this == PHASE) "issue.filter.sort.phase"
            else "issue.${this.name.lowercase()}"
        }
    }

    data class Criteria(val field: Field, val asc: Boolean = true) {
        override fun toString(): String {
            return "$field.$asc"
        }
    }

    override fun compare(left: Issue, right: Issue): Int {
        if (left == right) {
            return 0
        }
        for (c in criteria) {
            val result = when (c.field) {
                Field.PHASE -> left.status.phase.compareTo(right.status.phase)
                Field.DONE -> (left.status.phase == IssueStatusPhase.Done).compareTo(right.status.phase == IssueStatusPhase.Done)
                Field.STATUS -> left.status.compareTo(right.status)
                Field.CATEGORY -> left.category.compareTo(right.category)
                Field.ETA -> left.compareEtaTo(right.eta)
                Field.UPDATED -> left.updated.compareTo(right.updated)
                Field.CREATED -> left.created.compareTo(right.created)
            }
            if (result != 0) {
                return if (c.asc) result else -result
            }
        }
        return 0
    }
}

class IssueSummary {
    var open = 0
    var active = 0
    var done = 0

    val total get() = open + active + done

    val openPercent get() = 100 - activePercent - donePercent
    val activePercent get() = if (total > 0) (100f * active / total).roundToInt() else 0
    val donePercent get() = if (total > 0) (100f * done / total).roundToInt() else 100

    /**
     * Adds the specified issue to the summary by incrementing the respective counter.
     * @param issue the issue
     */
    fun add(issue: Issue) {
        when (issue.status.phase) {
            IssueStatusPhase.Open -> open++
            IssueStatusPhase.WorkInProgress -> active++
            IssueStatusPhase.Done -> done++
        }
    }
}

data class CommitLink(val url: String, val hash: String, val message: String)

class IssueOverview(
    val issues: List<Issue>,
    val filter: IssueFilter
) : View() {
    val issueSummary = IssueSummary()

    init {
        feedHref = "feed/-/issues.rss"
        issues.forEach(issueSummary::add)
    }
}

class IssueDetailView(
    val issue: Issue,
    val comments: List<IssueComment>,
    projectIssues: List<Issue>,
    val currentRelations: List<IssueRelation>,
    commitRefs: List<CommitRef>,
    /**
     * Optional resource key to an error message for the relation editor.
     */
    val relationError: String? = null,
    val pathInfos: PathInfos? = null
) : View() {
    val relationTypes = RelationType.entries
    val linkableIssues = projectIssues.filterNot { it.id == issue.id }
    val commitLinks: List<CommitLink>

    private val parser: Parser
    private val renderer: HtmlRenderer

    init {
        val options = MutableDataSet()
            .set(SharedDataKeys.EXTENSIONS, listOf(TablesExtension.create(), StrikethroughExtension.create()))
        parser = Parser.builder(options).build()
        renderer = HtmlRenderer.builder(
            options
                .set(HtmlRenderer.ESCAPE_HTML, true)
        ).build()

        issue.description = formatMarkdown(issue.description ?: "")
        for (comment in comments) {
            comment.commentFormatted = formatMarkdown(comment.comment)
        }

        val commitBaseUrl = issue.project.repoUrl
        commitLinks = (if (commitBaseUrl == null || issue.project.vcs == VcsType.None) emptyList() else commitRefs.map {
            CommitLink(buildCommitUrl(commitBaseUrl, issue.project.vcs, it.hash), it.hash, it.message)
        })
    }

    private fun buildCommitUrl(baseUrl: String, vcs: VcsType, hash: String): String =
        with (StringBuilder(baseUrl)) {
            if (!endsWith("/")) append('/')
            when (vcs) {
                VcsType.Mercurial -> append("rev/")
                else -> append("commit/")
            }
            append(hash)
            toString()
        }

    private fun formatEmojis(text: String) = text
        .replace("(/)", "&#9989;")
        .replace("(x)", "&#10060;")
        .replace("(!)", "&#9889;")

    private fun formatMarkdown(text: String) =
        renderer.render(parser.parse(formatEmojis(text)))
}

class IssueEditView(
    val issue: Issue,
    val versions: List<Version>,
    val components: List<Component>,
    val users: List<User>,
    val project: Project,
    val pathInfos: PathInfos? = null
) : EditView() {

    val versionsUpcoming: List<Version>
    val versionsRecent: List<Version>

    val issueStatus = IssueStatus.entries
    val issueCategory = IssueCategory.entries

    init {
        val recent = mutableListOf<Version>()
        issue.affected?.let { recent.add(it) }
        val upcoming = mutableListOf<Version>()
        issue.resolved?.let { upcoming.add(it) }

        for (v in versions) {
            if (v.status.isReleased) {
                if (v.status != VersionStatus.Deprecated) recent.add(v)
            } else {
                upcoming.add(v)
            }
        }
        versionsRecent = recent.distinct()
        versionsUpcoming = upcoming.distinct()
    }
}

class IssueFilter(http: HttpRequest, dao: DataAccessObject) {

    val issueStatus = IssueStatus.entries
    val issueCategory = IssueCategory.entries
    val users = dao.listUsers().sortedBy(User::shortDisplayname)
    val sortCriteria = IssueSorter.Field.entries.flatMap { listOf(IssueSorter.Criteria(it, true), IssueSorter.Criteria(it, false)) }
    val flagIncludeDone = "f.0"
    val flagMine = "f.1"
    val flagBlocker = "f.2"

    val includeDone: Boolean = evalFlag(http, flagIncludeDone)
    val onlyMine: Boolean = evalFlag(http, flagMine)
    val onlyBlocker: Boolean = evalFlag(http, flagBlocker)
    val status: List<IssueStatus> = evalEnum(http, "s") { issueStatusOf(IssueStatusPhase(it)) }
    val category: List<IssueCategory> = evalEnum(http, "c")
    val assignee: List<Int> = evalInts(http, "u")

    val sortPrimary: IssueSorter.Criteria = evalSort(http, "primary", IssueSorter.Criteria(IssueSorter.Field.DONE))
    val sortSecondary: IssueSorter.Criteria = evalSort(http, "secondary", IssueSorter.Criteria(IssueSorter.Field.ETA))
    val sortTertiary: IssueSorter.Criteria = evalSort(http, "tertiary", IssueSorter.Criteria(IssueSorter.Field.UPDATED, false))

    fun containsAssignee(user: User?): Boolean = assignee.contains(user?.id?:-1)

    private fun evalSort(http: HttpRequest, prio: String, defaultValue: IssueSorter.Criteria): IssueSorter.Criteria {
        val param = http.param("sort_$prio")
        if (param != null) {
            http.session.removeAttribute("sort_$prio")
            val p = param.split(".")
            if (p.size > 1) {
                try {
                    http.session.setAttribute("sort_$prio", IssueSorter.Criteria(enumValueOf(p[0]), p[1].toBoolean()))
                } catch (_:IllegalArgumentException) {
                    // ignore malfored values
                }
            }
        }
        return http.session.getAttribute("sort_$prio") as IssueSorter.Criteria? ?: defaultValue
    }

    private fun evalFlag(http: HttpRequest, name: String): Boolean {
        val param = http.paramArray("filter")
        if (param.isNotEmpty()) {
            if (param.contains(name)) {
                http.session.setAttribute(name, true)
            } else {
                http.session.removeAttribute(name)
            }
        }
        return http.session.getAttribute(name) != null
    }

    private inline fun <reified T : Enum<T>> evalEnum(
        http: HttpRequest,
        prefix: String,
        categorizer: ((Int) -> List<T>) = { emptyList() }
    ): List<T> {
        val sattr = "f.${prefix}"
        val param = http.paramArray("filter")
        if (param.isNotEmpty()) {
            val list = param.filter { it.startsWith("${prefix}.") }
                .map { it.substring(prefix.length + 1) }
                .flatMap {
                    // try resolving as category
                    val cat = it.toIntOrNull()
                    if (cat != null) {
                        categorizer(cat)
                    } else {
                        try {
                            // quick and very dirty validation
                            listOf(enumValueOf<T>(it))
                        } catch (_: IllegalArgumentException) {
                            // simply skip bogus enums
                            emptyList()
                        }
                    }
                }
            if (list.isEmpty()) {
                http.session.removeAttribute(sattr)
            } else {
                http.session.setAttribute(sattr, list.joinToString(","))
            }
        }

        return http.session.getAttribute(sattr)
            ?.toString()
            ?.split(",")
            ?.map { enumValueOf(it) }
            ?: emptyList()
    }

    private fun evalInts(http: HttpRequest, prefix: String): List<Int> {
        val sattr = "f.${prefix}"
        val param = http.paramArray("filter")
        if (param.isNotEmpty()) {
            val list = param.filter { it.startsWith("${prefix}.") }
                .map { it.substring(prefix.length + 1) }
                .mapNotNull(String::toIntOrNull)
            if (list.isEmpty()) {
                http.session.removeAttribute(sattr)
            } else {
                http.session.setAttribute(sattr, list.joinToString(","))
            }
        }

        return http.session.getAttribute(sattr)
            ?.toString()
            ?.split(",")
            ?.map(String::toInt)
            ?: emptyList()
    }
}

fun issueFilterFunction(
    filter: IssueFilter,
    relationsMap: IssueRelationMap,
    currentUserName: String
): (issue: Issue) -> Boolean =
    {
        (!filter.onlyMine || (it.assignee?.username ?: "") == currentUserName) &&
                (!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)) &&
                (filter.onlyMine || filter.assignee.isEmpty() || filter.assignee.contains(it.assignee?.id ?: -1))
    }