package com.example.photo.handlers

import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.RequestHandler
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
import com.example.photo.WorkCount
import com.example.photo.services.DynamoDBService
import com.google.gson.Gson
import kotlinx.coroutines.runBlocking
import java.util.TreeMap

class GetHandler : RequestHandler<APIGatewayProxyRequestEvent?, APIGatewayProxyResponseEvent?> {
    val CORS_HEADER_MAP: Map<String, String> = java.util.Map.of(
        "Access-Control-Allow-Origin", "*"
    )

    fun toJson(src: Any?): String? {
        val gson = Gson()
        return gson.toJson(src)
    }

    override fun handleRequest(input: APIGatewayProxyRequestEvent?, context: Context): APIGatewayProxyResponseEvent = runBlocking {
        context.getLogger().log("In Labels handler")
        val dbService = DynamoDBService()
        val map: Map<String, WorkCount> = dbService.scanPhotoTable()
        context.getLogger().log("Retrieved photos: " + map.size)
        val data: MutableMap<String, Map<String, WorkCount>> = TreeMap()
        data["labels"] = map
        return@runBlocking makeResponse(data)
    }

    fun makeResponse(src: Any?): APIGatewayProxyResponseEvent {
        return APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withHeaders(CORS_HEADER_MAP)
            .withBody(toJson(src))
            .withIsBase64Encoded(false)
    }
}

package com.example.photo.handlers

import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.RequestHandler
import com.example.photo.endpoints.DownloadEndpoint
import com.google.gson.Gson
import kotlinx.coroutines.runBlocking
import org.json.JSONException
import org.json.JSONObject
import java.util.stream.Collectors

class RestoreHandler : RequestHandler<MutableMap<String, Any>, String> {
    fun toJson(src: Any?): String? {
        val gson = Gson()
        return gson.toJson(src)
    }

    override fun handleRequest(input: MutableMap<String, Any>?, context: Context?): String = runBlocking {
        try {
            if (context != null) {
                context.getLogger().log("***** RestoreHandler handleRequest" + toJson(input))
                val body = JSONObject(input)
                context.logger.log(body.toString())

                val labels = body.getJSONArray("labels")
                    .toList()
                    .stream()
                    .filter { o: Any? -> String::class.java.isInstance(o) }
                    .map { obj: Any? -> String::class.java.cast(obj) }
                    .collect(Collectors.toList())

                context.logger.log("Restoring labels " + toJson(labels))
                val downloadEndpoint = DownloadEndpoint()
                val url: String = downloadEndpoint.downloadFiles(labels)
                return@runBlocking "Labels archived to URL $url"
            }
        } catch (e: JSONException) {
            if (context != null) {
                context.logger.log(e.message)
            }
        }
        return@runBlocking ""
    }
}

 package com.example.photo.handlers

import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.RequestHandler
import com.amazonaws.services.lambda.runtime.events.S3Event
import com.example.photo.PhotoApplicationResources
import com.example.photo.services.AnalyzePhotos
import com.example.photo.services.DynamoDBService
import kotlinx.coroutines.runBlocking

class S3Handler : RequestHandler<S3Event, String> {

    override fun handleRequest(event: S3Event, context: Context): String? = runBlocking {
        // Get the S3 bucket and object key from the Amazon S3 event.
        val bucketName = event.records[0].s3.bucket.name
        val objectKey = event.records[0].s3.getObject().key

        // Log the S3 bucket and object key in the log file.
        context.logger.log("S3 object name: s3://$bucketName/$objectKey")
        val photos = AnalyzePhotos()
        val dbService = DynamoDBService()

        // Tag the file.
        val labels = photos.detectLabels(PhotoApplicationResources.STORAGE_BUCKET, objectKey)
        dbService.putRecord(labels)
        context.logger.log("Tagged image")
        return@runBlocking "OK"
    }
}

package com.example.photo.handlers

import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.RequestHandler
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent
import com.example.photo.services.S3Service
import com.google.gson.Gson
import kotlinx.coroutines.runBlocking
import java.util.UUID

class UploadHandler : RequestHandler<APIGatewayProxyRequestEvent?, APIGatewayProxyResponseEvent?> {
    val CORS_HEADER_MAP: Map<String, String> = java.util.Map.of(
        "Access-Control-Allow-Origin", "*"
    )

    fun toJson(src: Any?): String? {
        val gson = Gson()
        return gson.toJson(src)
    }

    override fun handleRequest(input: APIGatewayProxyRequestEvent?, context: Context): APIGatewayProxyResponseEvent = runBlocking {
        context.getLogger().log("In UploadHandler handler")
        val body: org.json.JSONObject = org.json.JSONObject(input!!.body)
        context.logger.log("Got body: $body")
        val fileName = body.getString("file_name")
        context.logger.log("Building URL for $fileName")

        if (fileName == null || fileName == "") {
            return@runBlocking APIGatewayProxyResponseEvent()
                .withStatusCode(400)
                .withHeaders(CORS_HEADER_MAP)
                .withBody("{\"error\":\"Missing filename\"}")
                .withIsBase64Encoded(false)
        }

        val uuid = UUID.randomUUID()
        val uniqueFileName = "$uuid-$fileName"
        val s3Service = S3Service()
        val signedURL = s3Service.signObjectToUpload(uniqueFileName)
        val data = UploadResponse.from(signedURL)
        return@runBlocking makeResponse(data)
    }

    fun makeResponse(src: Any?): APIGatewayProxyResponseEvent {
        return APIGatewayProxyResponseEvent()
            .withStatusCode(200)
            .withHeaders(CORS_HEADER_MAP)
            .withBody(toJson(src))
            .withIsBase64Encoded(false)
    }
}

internal class UploadResponse private constructor(val uRL: String) {
    companion object {
        fun from(url: String): UploadResponse {
            return UploadResponse(url)
        }
    }
}

package com.example.photo.services

import aws.sdk.kotlin.services.rekognition.RekognitionClient
import aws.sdk.kotlin.services.rekognition.model.DetectLabelsRequest
import aws.sdk.kotlin.services.rekognition.model.Image
import aws.sdk.kotlin.services.rekognition.model.S3Object
import com.example.photo.LabelCount

class AnalyzePhotos {
    suspend fun detectLabels(bucketName: String?, key: String?): ArrayList<LabelCount> {
        val s3Ob = S3Object {
            bucket = bucketName
            name = key
        }

        val souImage = Image {
            s3Object = s3Ob
        }

        val detectLabelsRequest = DetectLabelsRequest {
            image = souImage
            maxLabels = 10
        }

        RekognitionClient { region = "us-east-1" }.use { rekClient ->
            val labelsResponse = rekClient.detectLabels(detectLabelsRequest)
            val labels = labelsResponse.labels
            println("Detected labels for the given photo")
            val list = ArrayList<LabelCount>()
            var item: LabelCount
            if (labels != null) {
                for (label in labels) {
                    item = LabelCount()
                    item.setKey(key)
                    item.setName(label.name)
                    list.add(item)
                }
            }
            return list
        }
    }
}

  package com.example.photo.services

import aws.sdk.kotlin.services.dynamodb.DynamoDbClient
import aws.sdk.kotlin.services.dynamodb.model.AttributeValue
import aws.sdk.kotlin.services.dynamodb.model.PutItemRequest
import aws.sdk.kotlin.services.dynamodb.model.QueryRequest
import aws.sdk.kotlin.services.dynamodb.model.QueryResponse
import aws.sdk.kotlin.services.dynamodb.model.ScanRequest
import aws.sdk.kotlin.services.dynamodb.model.UpdateItemRequest
import com.example.photo.LabelCount
import com.example.photo.PhotoApplicationResources
import com.example.photo.WorkCount
import java.util.Collections

class DynamoDBService {
    // Put the tags in the given list into an Amazon DynamoDB table.
    suspend fun putRecord(list: ArrayList<LabelCount>) {
        for (count in list) {
            val label = count.getName()
            val key = count.getKey()
            if ((label != null) && (key != null)) {
                addSingleRecord(label, key)
            }
        }
    }

    suspend fun addSingleRecord(label: String, keyVal: String) {
        // Check to see if the label exists in the Amazon DynamoDB table.
        val scanResult = scanLabelTable(PhotoApplicationResources.LABELS_TABLE)
        if (scanResult == 0) {
            // There are no records in the table.
            addNewLabel(PhotoApplicationResources.LABELS_TABLE, label)
            updateCount(PhotoApplicationResources.LABELS_TABLE, label)
            updateTableList(PhotoApplicationResources.LABELS_TABLE, label, keyVal)
        } else {
            // There are records. Check to see if Label exists.
            val labelCount = checkTagExists(label)
            if (labelCount > 0) {
                // The Label exists in the table.
                updateCount(PhotoApplicationResources.LABELS_TABLE, label)
                updateTableList(PhotoApplicationResources.LABELS_TABLE, label, keyVal)
            } else {
                // The Label doesn't exist in the table.
                addNewLabel(PhotoApplicationResources.LABELS_TABLE, label)
                updateCount(PhotoApplicationResources.LABELS_TABLE, label)
                updateTableList(PhotoApplicationResources.LABELS_TABLE, label, keyVal)
            }
        }
        println("All Data added to the Amazon DynamoDB table")
    }

    // Scan table before looking for Labels.
    suspend fun scanLabelTable(tableNameVal: String): Int {
        val request = ScanRequest {
            tableName = tableNameVal
        }

        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            val response = ddb.scan(request)
            println("${response.count}")
            return response.count
        }
    }

    suspend fun checkTagExists(tag: String): Int {
        val tableNameVal = PhotoApplicationResources.LABELS_TABLE
        val partitionKeyName = "Label"
        val partitionKeyVal = tag
        val partitionAlias = "#a"

        val attrNameAlias = mutableMapOf<String, String>()
        attrNameAlias[partitionAlias] = partitionKeyName

        // Set up mapping of the partition name with the value.
        val attrValues = mutableMapOf<String, AttributeValue>()
        attrValues[":$partitionKeyName"] = AttributeValue.S(partitionKeyVal)

        val request = QueryRequest {
            tableName = tableNameVal
            keyConditionExpression = "$partitionAlias = :$partitionKeyName"
            expressionAttributeNames = attrNameAlias
            this.expressionAttributeValues = attrValues
        }

        var count: Int
        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            val response = ddb.query(request)
            count = response.count
            println("$count")
        }
        return count
    }

    suspend fun updateCount(tableNameVal: String, label: String) {
        // Specify the item key.
        val keyMap: MutableMap<String, AttributeValue> = HashMap()
        keyMap["Label"] = AttributeValue.S(label)

        // Create a map to hold the update expression attributes.
        val expressionAttributeValuesMap: MutableMap<String, AttributeValue> = HashMap()
        expressionAttributeValuesMap[":countval"] = AttributeValue.N("1")

        // Specify the update item request with an expression.
        val request = UpdateItemRequest {
            tableName = tableNameVal
            key = keyMap
            updateExpression = "ADD #count :countval"
            expressionAttributeNames = Collections.singletonMap("#count", "count")
            expressionAttributeValues = expressionAttributeValuesMap
        }

        // Update the item in the table.
        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            ddb.updateItem(request)
            println("Item in $tableNameVal was updated")
        }
    }

    suspend fun updateTableList(tableNameVal: String, keyVal: String, updateVal: String) {
        // Build the item key for the DynamoDB update request.
        val itemKey: MutableMap<String, AttributeValue> = java.util.HashMap()
        itemKey["Label"] = AttributeValue.S(keyVal)

        // Build the updated values for the "images" column.
        val updatedValues = mutableMapOf<String, AttributeValue>()
        val myFileList = ArrayList<AttributeValue>()
        myFileList.add(AttributeValue.S(updateVal))
        updatedValues["images"] = AttributeValue.L(myFileList)

        val expressionAttValues = mutableMapOf<String, AttributeValue>()
        expressionAttValues[":val"] = AttributeValue.L(myFileList)

        // Build the update request and execute it by using the DynamoDB client.
        val updateItemRequest = UpdateItemRequest {
            tableName = tableNameVal
            key = itemKey
            updateExpression = "SET images = list_append(images, :val)"
            expressionAttributeValues = expressionAttValues
        }

        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            ddb.updateItem(updateItemRequest)
            println("Item in $tableNameVal was updated")
        }
    }

    suspend fun addNewLabel(tableNameVal: String, keyName: String) {
        val itemValues = mutableMapOf<String, AttributeValue>()

        // Add all content to the table.
        val emptyList = ArrayList<AttributeValue>()
        itemValues["Label"] = AttributeValue.S(keyName)
        itemValues["images"] = AttributeValue.L(emptyList)

        val request = PutItemRequest {
            tableName = tableNameVal
            item = itemValues
        }

        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            ddb.putItem(request)
            println(" A new item was placed into $tableNameVal.")
        }
    }

    suspend fun scanPhotoTable(): HashMap<String, WorkCount> {
        val myMap = HashMap<String, WorkCount>()
        val request = ScanRequest {
            tableName = PhotoApplicationResources.LABELS_TABLE
        }

        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            val response = ddb.scan(request)
            response.items?.forEach { item ->
                val wc = WorkCount()
                var labelName = ""
                var myCount: String
                item.keys.forEach { key ->
                    if (key.compareTo("Label") == 0) {
                        val inputString = item[key].toString()
                        val regex = Regex("=(.*?)\\)")
                        val matchResult = regex.find(inputString)
                        if (matchResult != null) {
                            labelName = matchResult.groupValues[1]
                            println(labelName)
                        }
                    }

                    if (key.compareTo("count") == 0) {
                        val inputString = item[key].toString()
                        val regex = Regex("=(.*?)\\)")
                        val matchResult = regex.find(inputString)
                        if (matchResult != null) {
                            myCount = matchResult.groupValues[1]
                            println("The value of count is $myCount")
                            val countInt = myCount.toInt()
                            wc.setCount(countInt)
                        }
                    }
                }
                myMap[labelName] = wc
            }
        }
        return myMap
    }

    suspend fun getImagesByLabel(partitionKeyVal: String): List<String> {
        val partitionAlias = "#a"
        val partitionKeyName = "Label"
        val attrNameAlias = mutableMapOf<String, String>()
        attrNameAlias[partitionAlias] = partitionKeyName

        // Set up mapping of the partition name with the value.
        val attrValues = mutableMapOf<String, AttributeValue>()
        attrValues[":$partitionKeyName"] = AttributeValue.S(partitionKeyVal)

        val request = QueryRequest {
            tableName = PhotoApplicationResources.LABELS_TABLE
            keyConditionExpression = "$partitionAlias = :$partitionKeyName"
            expressionAttributeNames = attrNameAlias
            expressionAttributeValues = attrValues
        }

        DynamoDbClient { region = "us-east-1" }.use { ddb ->
            val response = ddb.query(request)
            return processItems(response)
        }
    }

    fun processItems(queryRes: QueryResponse): List<String> {
        val allImages = queryRes.items?.get(0)
        val fileString = allImages.toString()
        val imagesValue = fileString.substringAfter("images=L(value=[").substringBefore("]),")
        return extractJpgFiles(imagesValue)
    }

    private fun extractJpgFiles(input: String): List<String> {
        val pattern =
            "S\\(value=([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}-[a-zA-Z0-9]+\\.jpg)".toRegex()
        val matchResults = pattern.findAll(input)
        return matchResults.map { it.groupValues[1] }.toList()
    }
}

package com.example.photo.services

import aws.sdk.kotlin.services.s3.S3Client
import aws.sdk.kotlin.services.s3.model.GetObjectRequest
import aws.sdk.kotlin.services.s3.model.PutObjectRequest
import aws.sdk.kotlin.services.s3.presigners.presignGetObject
import aws.sdk.kotlin.services.s3.presigners.presignPutObject
import aws.smithy.kotlin.runtime.content.ByteStream
import aws.smithy.kotlin.runtime.content.toByteArray
import com.example.photo.PhotoApplicationResources
import java.io.ByteArrayOutputStream
import java.net.URL
import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.minutes

class S3Service {
    // Place the upload image into an Amazon S3 bucket
    suspend fun putObject(data: ByteArray, objectKey: String) {
        val request = PutObjectRequest {
            bucket = PhotoApplicationResources.STORAGE_BUCKET
            key = objectKey
            body = ByteStream.fromBytes(data)
        }

        S3Client { region = "us-east-1" }.use { s3Client ->
            s3Client.putObject(request)
        }
    }

    // Place the upload image into an Amazon S3 bucket.
    suspend fun putZIP(data: ByteArray, objectKey: String) {
        val request = PutObjectRequest {
            bucket = PhotoApplicationResources.WORKING_BUCKET
            key = objectKey
            body = ByteStream.fromBytes(data)
        }

        S3Client { region = "us-east-1" }.use { s3Client ->
            s3Client.putObject(request)
        }
    }

    suspend fun getObjectBytes(bucketName: String?, keyName: String?): ByteArray? {
        var myBytes: ByteArray? = null
        val objectRequest = GetObjectRequest {
            key = keyName
            bucket = bucketName
        }

        S3Client { region = "us-east-1" }.use { s3Client ->
            s3Client.getObject(objectRequest) { resp ->
                myBytes = resp.body?.toByteArray()
            }
            return myBytes
        }
    }

    // Pass a map and get back a byte[] that represents a ZIP of all images.
    fun createZipFile(files: HashMap<String, ByteArray>): ByteArray {
        val byteArrayOutputStream = ByteArrayOutputStream()
        val zipOutputStream = ZipOutputStream(byteArrayOutputStream)
        for ((fileName, fileData) in files) {
            if (fileName == null) {
                continue
            }
            val entry = ZipEntry(fileName)
            zipOutputStream.putNextEntry(entry)
            zipOutputStream.write(fileData)
            zipOutputStream.closeEntry()
        }
        zipOutputStream.close()
        return byteArrayOutputStream.toByteArray()
    }

    suspend fun signObjectToDownload(keyName: String?): String? {
        S3Client { region = "us-east-1" }.use { s3Client ->
            val unsignedRequest = GetObjectRequest {
                bucket = PhotoApplicationResources.WORKING_BUCKET
                key = keyName
            }

            // Presign the GetObject request.
            val presignedRequest = s3Client.presignGetObject(unsignedRequest, 1.hours)
            val presignedUrl = URL(presignedRequest.url.toString()).readText()
            println(presignedUrl)
            return presignedUrl
        }
    }

    suspend fun signObjectToUpload(keyName: String?): String {
        S3Client { region = "us-east-1" }.use { s3Client ->
            val presignedUrl = PutObjectRequest {
                bucket = PhotoApplicationResources.WORKING_BUCKET
                key = keyName
                contentType = "image/jpeg"
            }

            val presignedRequest = s3Client.presignPutObject(presignedUrl, 5L.minutes)
            println(presignedRequest.url.toString())
            return presignedRequest.url.toString()
        }
    }
}

 package com.example.photo.services

import aws.sdk.kotlin.services.sns.SnsClient
import aws.sdk.kotlin.services.sns.model.PublishRequest
import com.example.photo.PhotoApplicationResources

class SnsService {
    suspend fun pubTopic(messageVal: String?) {
        val request = PublishRequest {
            message = messageVal
            topicArn = PhotoApplicationResources.TOPIC_ARN
        }
        SnsClient { region = "us-east-1" }.use { snsClient ->
            snsClient.publish(request)
        }
    }
}

 package com.example.photo.endpoints

import com.example.photo.PhotoApplicationResources
import com.example.photo.services.DynamoDBService
import com.example.photo.services.S3Service
import com.example.photo.services.SnsService
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.asFlow
import kotlinx.coroutines.flow.flatMapConcat
import kotlinx.coroutines.flow.toSet
import kotlinx.coroutines.withContext
import java.util.UUID

class DownloadEndpoint {
    suspend fun downloadFiles(labels: List<String>): String {
        println("We have the tags")
        val dbService = DynamoDBService()
        val s3Service = S3Service()
        val snsService = SnsService()
        val imageMap: HashMap<String, ByteArray> = HashMap()

        // Now that there's an image list, place the images into a ZIP and presign it.
        val images = labels.asFlow()
            .flatMapConcat { label ->
                withContext(Dispatchers.IO) {
                    dbService.getImagesByLabel(label)
                }.asFlow()
            }
            .toSet()

        val uuid = UUID.randomUUID().toString()
        val zipName = "$uuid.zip"
        // Populate a Kotlin Collection with the byte[].
        for (image in images) {
            val imageBytes = s3Service.getObjectBytes(PhotoApplicationResources.STORAGE_BUCKET, image)
            if (imageBytes != null) {
                imageMap.put(image, imageBytes)
                println("Added $image to the map")
            }
        }

        // Place the ZIP file into the working bucket and get back a presigned URL.
        val myZipStream = s3Service.createZipFile(imageMap)
        s3Service.putZIP(myZipStream, zipName)
        val presignUrl = s3Service.signObjectToDownload(zipName)
        val message = "Find your Archived images here $presignUrl"
        snsService.pubTopic(message)
        return presignUrl.toString()
    }
}

package com.example.photo.endpoints

import com.example.photo.PhotoApplicationResources
import com.example.photo.services.AnalyzePhotos
import com.example.photo.services.DynamoDBService
import com.example.photo.services.S3Service

class UploadEndpoint {
    suspend fun upload(bytes: ByteArray, name: String) {
        // Put the file into the bucket.
        val s3Service = S3Service()
        val analyzePhotos = AnalyzePhotos()
        val dbService = DynamoDBService()

        s3Service?.putObject(bytes, name)
        val labels = analyzePhotos.detectLabels(PhotoApplicationResources.STORAGE_BUCKET, name)
        dbService.putRecord(labels)
    }
}

package com.example.photo

class LabelCount {
    private var key: String? = null
    private var name: String? = null
    private var count = 0

    fun setKey(key: String?) {
        this.key = key
    }

    fun getKey(): String? {
        return key
    }

    fun setName(name: String?) {
        this.name = name
    }

    fun getName(): String? {
        return name
    }

    fun getCount(): Int {
        return count
    }

    fun setCount(count: Int) {
        this.count = count
    }
}

package com.example.photo

import com.google.gson.Gson
import java.util.Map

class PhotoApplicationResources {

    companion object {
        //val REGION = Region.of(System.getenv("AWS_REGION"))
        val STORAGE_BUCKET = System.getenv("STORAGE_BUCKET_NAME")
        val WORKING_BUCKET = System.getenv("WORKING_BUCKET_NAME")
        val LABELS_TABLE = System.getenv("LABELS_TABLE_NAME")
        val JOBS_TABLE = System.getenv("JOBS_TABLE_NAME")
        val TOPIC_ARN = System.getenv("NOTIFICATION_TOPIC")

        val CORS_HEADER_MAP = Map.of(
            "Access-Control-Allow-Origin", "*"
        )
        val gson = Gson()
    }
}

package com.example.photo

class WorkCount {
    private var count = 0

    fun getCount(): Int {
        return count
    }

    fun setCount(count: Int) {
        this.count = count
    }
}

package com.pam

import aws.sdk.kotlin.services.lambda.LambdaClient
import aws.sdk.kotlin.services.lambda.model.UpdateFunctionCodeRequest
import aws.sdk.kotlin.services.lambda.waiters.waitUntilFunctionUpdated

suspend fun main() {
    val key = "PhotoAssetRestKotlin-1.0-SNAPSHOT-all.jar"
    val bucketName = "<Update value>"
    val functionNamesLabels = "<Update value>"
    val uploadFunction = "<Update value>"
    val downloadFunction = "<Update value>"
    val s3Handle = "<Update value>"

    // Replace all four AWS Lambda functions.
    updateFunctionCode(functionNamesLabels, bucketName, key)
    updateFunctionCode( uploadFunction, bucketName, key)
    updateFunctionCode(downloadFunction, bucketName, key)
    updateFunctionCode(s3Handle, bucketName, key)
    println("You have replaced all PAM Application Lambda functions!")
}

suspend fun updateFunctionCode(functionNameVal: String?, bucketName: String?, key: String?) {
    val functionCodeRequest = UpdateFunctionCodeRequest {
        functionName = functionNameVal
        publish = true
        s3Bucket = bucketName
        s3Key = key
    }

    LambdaClient { region = "us-east-1" }.use { awsLambda ->
        val response = awsLambda.updateFunctionCode(functionCodeRequest)
        awsLambda.waitUntilFunctionUpdated {
            functionName = functionNameVal
        }
        println("The last modified value is " + response.lastModified)
    }
}