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.entities.*
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
    }

    data class Criteria(val field: Field, val asc: Boolean = true)

    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++
        }
    }
}

class IssueDetailView(
    val issue: Issue,
    val comments: List<IssueComment>,
    val project: Project,
    val version: Version?,
    val component: Component?,
    projectIssues: List<Issue>,
    val currentRelations: List<IssueRelation>,
    /**
     * Optional resource key to an error message for the relation editor.
     */
    val relationError: String?
) : View() {
    val relationTypes = RelationType.values()
    val linkableIssues = projectIssues.filterNot { it.id == issue.id }

    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)
        }
    }

    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, // TODO: allow null values to create issues from the IssuesServlet
    val version: Version? = null,
    val component: Component? = null
) : EditView() {

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

    val issueStatus = IssueStatus.values()
    val issueCategory = IssueCategory.values()

    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()
    }
}