package com.example.sqs

class MessageData {
    var id: String? = null
    var body: String? = null
    var name: String? = null
}

package com.example.sqs

import kotlinx.coroutines.runBlocking
import org.springframework.boot.autoconfigure.SpringBootApplication
import org.springframework.boot.runApplication
import org.springframework.web.bind.annotation.CrossOrigin
import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.web.bind.annotation.RestController
import java.util.UUID
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse


@SpringBootApplication
open class App

    fun main(args: Array<String>) {
        runApplication<App>(*args)
    }

    @CrossOrigin(origins = ["*"])
    @RestController
    @RequestMapping("chat/")
    class MessageResource {

        // Get messages from the FIFO queue.
        @GetMapping("msgs")
        fun getItems(request: HttpServletRequest?, response: HttpServletResponse?): List<MessageData?>? = runBlocking {
            val msgService = SendReceiveMessages()
            return@runBlocking msgService.getMessages()
        }

        //  Purge the queue.
        @GetMapping("purge")
        fun purgeMessages(request: HttpServletRequest?, response: HttpServletResponse?): String? = runBlocking {
            val msgService = SendReceiveMessages()
            msgService.purgeMyQueue()
            return@runBlocking "Queue is purged"
        }

        // Add a new message to the FIFO queue.
        @PostMapping("add")
        fun addItems(request: HttpServletRequest, response: HttpServletResponse?): List<MessageData?>? = runBlocking {
            val user = request.getParameter("user")
            val message = request.getParameter("message")
            val msgService = SendReceiveMessages()

            // Generate the ID.
            val uuid = UUID.randomUUID()
            val msgId = uuid.toString()
            val messageOb = MessageData()
            messageOb.id = msgId
            messageOb.name = user
            messageOb.body = message
            msgService.processMessage(messageOb)
            return@runBlocking msgService.getMessages()
        }
    }

package com.example.sqs

import aws.sdk.kotlin.services.comprehend.ComprehendClient
import aws.sdk.kotlin.services.comprehend.model.DetectDominantLanguageRequest
import aws.sdk.kotlin.services.sqs.SqsClient
import aws.sdk.kotlin.services.sqs.model.GetQueueUrlRequest
import aws.sdk.kotlin.services.sqs.model.MessageAttributeValue
import aws.sdk.kotlin.services.sqs.model.PurgeQueueRequest
import aws.sdk.kotlin.services.sqs.model.ReceiveMessageRequest
import aws.sdk.kotlin.services.sqs.model.SendMessageRequest
import org.springframework.stereotype.Component

@Component
class SendReceiveMessages {
    private val queueNameVal = "Message.fifo"

    // Purge the queue.
    suspend fun purgeMyQueue() {
        var queueUrlVal: String
        val getQueueRequest = GetQueueUrlRequest {
            queueName = queueNameVal
        }
        SqsClient { region = "us-west-2" }.use { sqsClient ->
            queueUrlVal = sqsClient.getQueueUrl(getQueueRequest).queueUrl.toString()
            val queueRequest = PurgeQueueRequest {
                queueUrl = queueUrlVal
            }
            sqsClient.purgeQueue(queueRequest)
        }
    }

    // Retrieve messages from the FIFO queue.
    suspend fun getMessages(): List<MessageData>? {
        val attr: MutableList<String> = ArrayList()
        attr.add("Name")

        val getQueueRequest = GetQueueUrlRequest {
            queueName = queueNameVal
        }

        SqsClient { region = "us-west-2" }.use { sqsClient ->
            val queueUrlVal = sqsClient.getQueueUrl(getQueueRequest).queueUrl

            val receiveRequest = ReceiveMessageRequest {
                queueUrl = queueUrlVal
                maxNumberOfMessages = 10
                waitTimeSeconds = 20
                messageAttributeNames = attr
            }

            val messages = sqsClient.receiveMessage(receiveRequest).messages
            var myMessage: MessageData
            val allMessages = mutableListOf<MessageData>()

            // Push the messages to a list.
            if (messages != null) {
                for (m in messages) {
                    myMessage = MessageData()
                    myMessage.body = m.body
                    myMessage.id = m.messageId
                    val map = m.messageAttributes
                    val `val` = map?.get("Name")
                    if (`val` != null) {
                        myMessage.name = `val`.stringValue
                    }
                    allMessages.add(myMessage)
                }
            }
            return allMessages
        }
    }

    // Add a new message to the FIFO queue.
    suspend fun processMessage(msg: MessageData) {
        val attributeValue = MessageAttributeValue {
            stringValue = msg.name
            dataType = "String"
        }

        val myMap: MutableMap<String, MessageAttributeValue> = HashMap()
        myMap["Name"] = attributeValue

        val getQueueRequest = GetQueueUrlRequest {
            queueName = queueNameVal
        }

        // Get the language code of the incoming message.
        var lanCode = ""
        val request = DetectDominantLanguageRequest {
            text = msg.body
        }

        ComprehendClient { region = "us-west-2" }.use { comClient ->
            val resp = comClient.detectDominantLanguage(request)
            val allLanList = resp.languages
            if (allLanList != null) {
                for (lang in allLanList) {
                    println("Language is " + lang.languageCode)
                    lanCode = lang.languageCode.toString()
                }
            }
        }

        // Send the message to the FIFO queue.
        SqsClient { region = "us-west-2" }.use { sqsClient ->
            val queueUrlVal: String? = sqsClient.getQueueUrl(getQueueRequest).queueUrl
            val sendMsgRequest = SendMessageRequest {
                queueUrl = queueUrlVal
                messageAttributes = myMap
                messageGroupId = "GroupA_$lanCode"
                messageDeduplicationId = msg.id
                messageBody = msg.body
            }
            sqsClient.sendMessage(sendMsgRequest)
        }
      }
   }