package dev.inmo.postssystem.core.api

import dev.inmo.micro_utils.common.ByteArrayAllocator
import dev.inmo.micro_utils.mime_types.KnownMimeTypes
import dev.inmo.postssystem.core.content.*
import dev.inmo.postssystem.core.content.api.business.content_adapters.binary.BinaryContent
import dev.inmo.postssystem.core.content.api.business.content_adapters.text.TextContent
import dev.inmo.postssystem.core.generateContentId
import kotlinx.serialization.json.Json
import kotlinx.serialization.modules.SerializersModule
import kotlinx.serialization.modules.polymorphic
import kotlin.test.Test
import kotlin.test.assertEquals

private val jsonFormat = Json {
    serializersModule = SerializersModule {
        polymorphic(Content::class) {
            subclass(TextContent::class, TextContent.serializer())
            subclass(BinaryContent::class, BinaryContent.serializer())
        }
    }
}

class ContentSerialization {
    private val simpleTextTestEntries = 10
    private val simpleSpecialTestEntries = 10

    @Test
    fun test_that_content_correctly_serializing_and_deserializing() {
        val contents = (0 until simpleTextTestEntries).map {
            TextContent("Example$it")
        } + (0 until simpleSpecialTestEntries).map {
            BinaryContent(KnownMimeTypes.Any, "$it.example") {
                byteArrayOf(it.toByte())
            }
        }

        val registeredContentFakes = contents.map { content ->
            RegisteredContent(
                generateContentId(),
                content
            )
        }

        val stringified = registeredContentFakes.map {
            jsonFormat.encodeToString(RegisteredContent.serializer(), it)
        }

        val parsed = stringified.map {
            jsonFormat.decodeFromString(RegisteredContent.serializer(), it)
        }

        parsed.forEachIndexed { i, registeredContent ->
            val content = registeredContent.content
            assertEquals(registeredContentFakes[i].id, registeredContent.id)
            when (content) {
                is TextContent -> assertEquals(registeredContentFakes[i].content, content)
                is BinaryContent -> {
                    val expectedContent = registeredContentFakes[i].content as BinaryContent
                    val fakeByteArrayAllocator: ByteArrayAllocator = { byteArrayOf() }
                    assertEquals(
                        expectedContent.copy(dataAllocator = fakeByteArrayAllocator),
                        content.copy(dataAllocator = fakeByteArrayAllocator)
                    )
                    val expectedData = expectedContent.dataAllocator()
                    val parsedData = content.dataAllocator()
                    assertEquals(expectedData.size, parsedData.size)
                    expectedData.withIndex().forEach { (i, byte) ->
                        assertEquals(byte, parsedData[i])
                    }
                }
            }
        }
    }
}