repositories {
    mavenCentral()
    maven("https://kotlin.bintray.com/kotlinx")
    maven("https://maven.pkg.jetbrains.space/public/p/space/maven")
}
dependencies {
    implementation(kotlin("stdlib"))
    // Space api sdk
    // https://www.jetbrains.com/help/space/space-sdk.html
    val space_version = "61400-beta"
    implementation("org.jetbrains:space-sdk-jvm:$space_version")
    // Ktor (http client)
    // https://github.com/ktorio/ktor
    val ktor_version = "1.4.3"
    implementation("io.ktor:ktor-client-core:$ktor_version")
    implementation("io.ktor:ktor-client-core-jvm:$ktor_version")
    implementation("io.ktor:ktor-client-cio:$ktor_version")
}

private const val spaceInstanceUrl = "https://makentoshe.jetbrains.space"
val spaceClient = SpaceHttpClient(HttpClient(CIO)).withServiceAccountTokenSource(
    ClientCredentialsFlow.clientId, ClientCredentialsFlow.clientSecret, spaceInstanceUrl
)
object ClientCredentialsFlow {
    const val clientId: String = TODO(“Put your client_id here”)
    const val clientSecret: String = TODO(“Put your client_secret here”)
}

// There are some examples of retrieving several data from the Space instance.
// We can process this info as we want - create analytics, office dashboards, and so on.
fun main() = runBlocking {
    val channels = spaceClient.chats.channels.listAllChannels("").data
    println("Channels: ${channels.map { "${it.name}(${it.channelId})" }}")
    // View application rights allows to see all applications
    // If rights were not accepted - the application can see only itself.
    val applications = spaceClient.applications.getAllApplications("")
    println("Applications: ${applications.map { "${it.name}(${it.id})" }}")
    // Works only with View member profile rights
    val profiles = spaceClient.teamDirectory.profiles.getAllProfiles().data
    println("Profiles: ${profiles.map { "${it.username}(${it.id})" }}")
    // Works only with View project parameters rights
    // These rights can be managed for selected projects or for whole projects at one time.
    val projects = spaceClient.projects.getAllProjects().data
    println("Projects: ${projects.map { "${it.name}(${it.id})" }}")
    // Works only with Project Issues: View issues rights
    val issues = projects.firstOrNull()?.let { getProjectIssues(it) }
    println("Issues: ${issues?.map { "${it.title}(${it.id})" }} ")
}
private suspend fun getProjectIssues(project: PR_Project): List<Issue> {
    return spaceClient.projects.planning.issues.getAllIssues(
        project = ProjectIdentifier.Id(project.id),
        assigneeId = emptyList(),
        statuses = emptyList(),
        sorting = IssuesSorting.CREATED,
        descending = true
    ).data
}

Channels: [Booruchan(4UHs4I3yyno1), general(10xDLp0yqy4w), Habrachan(4HyHLw3SnO9Y), Sipichan(15A2hA1RpAsp)]
Applications: [client(2czEkY3AIaV0), chatbot(d3Q8Z0UeVCF)]
Profiles: [Makentoshe(2iqI4p3gzufl)]
Projects: [Booruchan(qN0K31awqo6), Habrachan(1tJHqn2A76Yf), Sipichan(35BreB35gvdA)]
Issues: [Add custom Run Configuration and support ngrok startup(3S09oT4JHvpC), Add Client template for Space plugin with Gradle (atQRe1SIklB), Add Blank template for Space application plugin support for Gradle(4REln04HAo5k)]

// localtunnel
npx localtunnel --port 8080 --subdomain makentoshe
// ngrok
ngrok http 8080

{
  "className": "ListCommandsPayload",
  "accessToken": "",
  "verificationToken": "d415ca5965b37f4f0cac59fd33de7b94e396284e897d0fb8a070d0a5e1b7f2d3",
  "userId": "2kawvQ4F6GM6"
}

POST /api/chatbot HTTP/1.1
Host: 12345abcdef.ngrok.io
User-Agent: Space (61355) Ktor http-client
Content-Length: 163
Accept: */*
Accept-Charset: UTF-8
Content-Type: application/json
X-Forwarded-For: 123.456.123.456
X-Forwarded-Proto: https
X-Space-Signature: 2aa8cba6217a28686de0ca8dcfe2a1d0795e343d744a0c5307308e43777593a5
X-Space-Timestamp: 1607623492912
Accept-Encoding: gzip
{"className":"ListCommandsPayload","accessToken":"","verificationToken":"d415ca5965b37f4f0cac59fd33de7b94e396284e897d0fb8a070d0a5e1b7f2d3","userId":"2kawvQ4F6GM6"}

object Endpoint {
    const val verificationToken: String = TODO("Place your verification_token")
    const val signingKey: String = TODO("Place your signing_key")
    fun verify(payload: ApplicationPayload): Boolean {
        return payload.verifyWithToken(verificationToken)
    }
    fun verify(timestamp: String, signature: String, body: String): Boolean {
        val hmacSha256 = Mac.getInstance("HmacSHA256")
        hmacSha256.init(SecretKeySpec(signingKey.toByteArray(), "HmacSHA256"))
        val hash = hmacSha256.doFinal("$timestamp:$body".toByteArray()).toHexString()
        return hash == signature
    }
    private fun ByteArray.toHexString() = joinToString("") { (0xFF and it.toInt()).toString(16).padStart(2, '0') }
}

@Suppress("unused") // Referenced in application.conf
@kotlin.jvm.JvmOverloads
fun Application.module(testing: Boolean = false) {
    install(Routing) {
        chatbot()
    }
}
fun Routing.chatbot() {
    post("api/chatbot") {
        val receiveBody = call.receiveText()
        val timestamp = call.request.headers["x-space-timestamp"]
            ?: return@post call.respond(HttpStatusCode.BadRequest)
        val signature = call.request.headers["x-space-signature"]
            ?: return@post call.respond(HttpStatusCode.BadRequest)
        if (!Endpoint.verify(timestamp, signature, receiveBody)) {
            return@post call.respond(HttpStatusCode.Unauthorized)
        }
        val payload = readPayload(receiveBody)
        if (!Endpoint.verify(payload)) {
            return@post call.respond(HttpStatusCode.Unauthorized)
        }
        try {
            processChatbotPayload(payload)
        } catch (unknownCommand: IllegalStateException) {
            LoggerFactory.getLogger("Chatbot").error(unknownCommand.message)
        }
    }
}

private suspend fun PipelineContext<*, ApplicationCall>.processChatbotPayload(payload: ApplicationPayload) {
    when (payload) {
        is MessagePayload -> {
            processChatbotMessagePayload(payload)
        }
        is MessageActionPayload -> {
            processChatbotMessageActionPayload(payload)
        }
        is ListCommandsPayload -> {
            processChatbotListCommandsPayload(payload)
        }
    }
}

data class Command(
    val name: String,
    val info: String,
    val action: suspend (payload: MessagePayload) -> Unit
) {
       fun toCommandDetail() = CommandDetail(name, info)
}

object Commands {
    val help = Command(
        "help",
        "Show this help",
    ) { payload ->
        val context = HelpContext.from(payload)
        printToChat(context, message {
            section {
                text(
                    """Help message:
                    name - Show this help
                    ${echo.name} - ${echo.info}
                    ${interactive.name} - ${interactive.info}
                    """.trimIndent()
                )
            }
        })
    }
    val echo = Command(
        "echo",
        "Echoing the input string",
    ) { payload ->
        val context = EchoContext.from(payload)
        val body = context.message.body
        printToChat(context, message = if (body is ChatMessage.Text) {
            message { section { text(body.text) } }
        } else {
            message { section { text("Skip the Block body") } }
        })
    }
    val interactive = Command(
        "interactive",
        "Displaying available message interactive elements"
    ) { payload ->
       // TODO finish later
    }
    val list = listOf(help, echo, interactive)
    val commands: Commands
        get() = Commands(list.map { it.toCommandDetail() })
}

interface UserContext {
    val userId: String
}
fun userContext(applicationPayload: ApplicationPayload) = object: UserContext {
    override val userId = applicationPayload.userId ?: throw IllegalArgumentException("Payload does not contains user id")
}
data class EchoContext(override val userId: String, val message: MessageContext) : UserContext {
    companion object {
        fun from(payload: ApplicationPayload): EchoContext? = when (payload) {
            is MessagePayload -> from(payload)
            else -> null
        }
        fun from(payload: MessagePayload): EchoContext {
            return EchoContext(payload.userId, payload.message)
        }
    }
}
data class HelpContext(override val userId: String): UserContext {
    companion object {
        fun from(payload: ApplicationPayload): HelpContext {
            return HelpContext(payload.userId!!)
        }
    }
}
data class InteractiveContext(override val userId: String): UserContext {
    companion object {
        fun from(payload: ApplicationPayload): InteractiveContext {
            return InteractiveContext(payload.userId!!)
        }
    }
}

suspend fun printToChat(context: UserContext, message: ChatMessage) {
    val member = ProfileIdentifier.Id(context.userId)
    spaceClient.chats.messages.sendMessage(MessageRecipient.Member(member), message)
}

ChatMessage.Text(
  """
  **bold**
  `code`
  *italic*
  @{2iqI4p3gzufl, Maksim Hvostov}
  @{2iqI4p3gzufl, Makentoshe}
  @{2iqI4p3gzufl, any string may be replaced with my name}
  [\#general](im/group/10xDLp0yqy4w)
  >quote
  """.trimIndent()
)

message {
  this.outline = MessageOutline(null, "Outline text")
  this.style = MessageStyle.PRIMARY
  section {
    this.text("Primary message")
  }
}

message {
    this.outline = MessageOutline(null, "Outline text")
    this.style = MessageStyle.PRIMARY
    section {
        this.header = "Section header"
        this.footer = "Section footer"
        this.text("Plain text")
    }
    divider()
    section {
        header = "This tag may indicate something not good"
        this.textWithTag("Text with tag", "error tag", MessageStyle.ERROR)
    }
    section {
        this.text("Plain text just to fill some space.")
        this.textWithImage("Text with image", "https://www.jetbrains.com/space/img/feedback-section/video-preview.png")
    }
    section {
        this.textWithIcon("Text with icon", "", MessageStyle.WARNING)
    }
    section {
        header = "Fields"
        this.fields {
            this.field("field1", "value1")
            this.field("field2", "value2")
            this.field("field3", "value3")
            this.field("field4", "value4")
        }
        this.controls {
            this.button("Disabled button without any action", PostMessageAction("", ""), disabled = true)
        }
    }
}

val interactive = Command(
        "interactive",
        "Displaying available message interactive elements"
    ) { payload ->
        val context = InteractiveContext.from(payload)
        val arguments = payload.commandArguments()
        if (arguments == null || arguments.isBlank()) {
            return@Command printToChat(context, message {
                section {
                    text("Specify one of the selected ui elements:\nbutton")
                }
            })
        }
        printToChat(context, message {
            section {
                header = "Available message interactive elements"
                controls {
                    when (arguments) {
                        "button" -> {
                            val primaryAction = PostMessageAction("ButtonPrimaryActionId", "InteractiveButtonPayloadPrimary")
                            button("Primary", primaryAction, MessageButtonStyle.PRIMARY)
                            val secondaryAction = PostMessageAction("ButtonSecondaryActionId", "InteractiveButtonPayloadSecondary")
                            button("Secondary", secondaryAction, MessageButtonStyle.SECONDARY)
                            val regularAction = PostMessageAction("ButtonRegularActionId", "InteractiveButtonPayloadRegular")
                            button("Regular", regularAction, MessageButtonStyle.REGULAR)
                            val dangerAction = PostMessageAction("ButtonDangerActionId", "InteractiveButtonPayloadDanger")
                            button("Danger", dangerAction, MessageButtonStyle.DANGER)
                        }
                    }
                }
            }
        })
    }

private suspend fun PipelineContext<*, ApplicationCall>.processChatbotMessagePayload(payload: MessagePayload) {
    Commands.list.find { it.name == payload.command() }?.action?.invoke(payload)
        ?: return call.respond(HttpStatusCode.NotFound)
    call.respond(HttpStatusCode.OK)
}

private suspend fun PipelineContext<*, ApplicationCall>.processChatbotListCommandsPayload(payload: ListCommandsPayload) {
    call.respondText(ObjectMapper().writeValueAsString(Commands.commands), ContentType.Application.Json)
}

private suspend fun PipelineContext<*, ApplicationCall>.processChatbotMessageActionPayload(payload: MessageActionPayload) {
    printToChat(userContext(payload), message { section { text(payload.actionId) } })
    call.respond(HttpStatusCode.OK)
}