/*
 * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
 */

package kotlinx.coroutines.experimental.io

import kotlinx.coroutines.experimental.*
import org.junit.*
import org.junit.Test
import org.junit.rules.*
import java.util.concurrent.*
import kotlin.coroutines.experimental.*
import kotlin.test.*

class StringScenarioTest : TestBase() {
    @get:Rule
    val timeout = Timeout(10L, TimeUnit.SECONDS)

    private val ch = ByteBufferChannel(autoFlush = true)

    @Test
    fun testWriteCharByChar() {
        runBlocking {
            expect(1)

            launch(coroutineContext) {
                ch.writeStringUtf8("A")
                expect(3)
                yield()

                expect(5)
                ch.writeStringUtf8("B")
                expect(6)
                yield()

                expect(7)
                ch.writeStringUtf8("\n")
                expect(8)
                yield()
            }

            expect(2)
            yield()

            expect(4)
            val line = ch.readUTF8Line()

            assertEquals("AB", line)
            expect(9)

            yield()
            expect(10)
            finish(11)
        }
    }

    @Test
    fun testSplitUtf8() {
        runBlocking {
            val sb = StringBuilder()

            expect(1)

            launch(coroutineContext) {
                expect(2)
                val b = byteArrayOf(0xd0.toByte(), 0x9a.toByte(), 0x0a)
                ch.writeFully(b, 0, 1)
                yield()

                expect(3)
                assertTrue { sb.isEmpty() }

                ch.writeFully(b, 1, 1)
                yield()

                expect(4)
                assertEquals("\u041a", sb.toString())

                ch.writeFully(b, 2, 1)
                yield()
            }

            ch.readUTF8LineTo(sb)
            expect(5)

            assertEquals("\u041a", sb.toString())

            finish(6)
        }
    }

    @Test
    fun testSplitLineDelimiter() = runBlocking {
        expect(1)

        launch(coroutineContext) {
            expect(2)
            ch.writeFully("ABC\r".toByteArray())
            expect(3)
            yield()

            expect(5)
            ch.writeFully("\n".toByteArray())
            yield()
        }

        yield()

        expect(4)
        val line = ch.readASCIILine()
        expect(6)

        assertEquals("ABC", line)

        finish(7)
    }

    @Test
    fun testReadTailWriteFirst() = runBlocking {
        expect(1)

        launch(coroutineContext) {
            expect(2)

            ch.writeFully("ABC".toByteArray())

            yield()

            expect(4)
            ch.close()
            yield()
        }

        yield()

        expect(3)

        val line = ch.readUTF8Line()
        expect(5)
        assertEquals("ABC", line)

        finish(6)
    }

    @Test
    fun testReadTailReadFirst() = runBlocking {
        expect(1)

        launch(coroutineContext) {
            expect(3)

            ch.writeFully("ABC".toByteArray())

            yield()

            expect(4)
            ch.close()
            yield()
        }

        expect(2)

        val line = ch.readUTF8Line()
        expect(5)
        assertEquals("ABC", line)

        finish(6)
    }

    @Test
    fun testReadThroughWrap() = runBlocking {
        val L = ".".repeat(128)

        expect(1)

        launch(coroutineContext) {
            expect(2)

            ch.writeFully(ByteArray(4000))

            expect(3)
            ch.readFully(ByteArray(3999)) // keep one byte remaining to keep buffer unreleased

            expect(4)

            ch.writeFully(L.toByteArray())

            expect(5)
            ch.close()
        }

        yield()

        expect(6)

        ch.readByte()
        expect(7)

        val line = ch.readUTF8Line()

        finish(8)

        assertEquals(L, line)
    }

    @Test
    fun testReadShifted() = runBlocking {
        val L = ".".repeat(127) + "\n"
        var base = 0

        for (shift in 1..4096 - 8) {
            expect(base + 1)

            launch(coroutineContext) {
                expect(base + 2)

                ch.writeFully(ByteArray(shift))

                expect(base + 3)
                ch.readFully(ByteArray(shift - 1)) // keep one byte remaining to keep buffer unreleased

                expect(base + 4)

                ch.writeFully(L.toByteArray())

                expect(base + 5)
            }

            yield()

            expect(base + 6)

            ch.readByte()
            expect(base + 7)

            val line = ch.readUTF8Line()

            expect(base + 8)

            assertEquals(L.dropLast(1), line)

            base += 8
        }

        finish(base + 1)
    }

    @Test
    fun writeLongLine() = runBlocking {
        val L = ".".repeat(16384)

        expect(1)

        launch(coroutineContext) {
            expect(2)

            ch.writeFully(L.toByteArray())

            expect(4)
            ch.close()
        }

        yield()

        expect(3)
        val line = ch.readUTF8Line()

        expect(5)

        assertEquals(L, line)

        finish(6)
    }
}