import com.ionspin.kotlin.crypto.util.encodeToUByteArray
import kotlinx.coroutines.test.runTest
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
import net.sergeych.crypto2.*
import kotlin.test.*

class ContainerTest {
    @Test
    fun testSingle() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val data = "sergeych, ohm many.".encodeToUByteArray()

        val c = Container.createWith(data, syk1)
        assertTrue { c.isDecrypted }
        val c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertIs<Container.Single>(c)

        assertNull(c1.decryptWith(syk2))
        val d = c1.decryptWith(syk2, syk1)
        assertNotNull(d)
        assertContentEquals(data, d)
        assertTrue { c1.isDecrypted }

        val data2 = "To push unpushinable".encodeToUByteArray()
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }
        assertContentEquals(data2, c2.decryptWith(syk1))
    }

    @Test
    fun testSinglePair() = runTest {
        initCrypto()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val data = "sergeych, ohm many.".encodeToUByteArray()

        val c = Container.createWith(data, p1.secretKey to p2.publicKey)
        assertTrue { c.isDecrypted }
        val c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertIs<Container.Single>(c)

        assertNull(c1.decryptWith(p3.secretKey))
        val d = c1.decryptWith(p3.secretKey, p2.secretKey)
        assertNotNull(d)
        assertContentEquals(data, d)
        assertTrue { c1.isDecrypted }
        assertEquals(p2.publicKey.id, c1.decryptedWithKeyId)
        assertEquals(p1.publicKey, c1.authorisedByKey)

        val data2 = "To push unpushinable".encodeToUByteArray()
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }

    }
 @Test
    fun testMultiplePair() = runTest {
        initCrypto()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "sergeych, ohm many.".encodeToUByteArray()

        val c = Container.createWith(data, p1.secretKey to p2.publicKey, p1.secretKey to p4.publicKey)
        assertTrue { c.isDecrypted }
        val c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }

        assertNull(c1.decryptWith(p3.secretKey, p1.secretKey))
        val d = c1.decryptWith(p3.secretKey, p4.secretKey)
        assertNotNull(d)
        assertContentEquals(data, d)
        assertTrue { c1.isDecrypted }
        assertEquals(p4.publicKey.id, c1.decryptedWithKeyId)
        assertEquals(p1.publicKey, c1.authorisedByKey)

        val data2 = "To push unpushinable".encodeToUByteArray()
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }

    }

    @Test
    fun testSingleAsymmetric() = runTest {
        initCrypto()
//        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val data = "sergeych, ohm many.".encodeToUByteArray()

        val c = Container.create(data) { key(p2.publicKey) }
        assertTrue { c.isDecrypted }
        val c1 = Container.decode(c.encoded)
        println(Json.encodeToString(c1))
        assertFalse { c1.isDecrypted }
        assertIs<Container.Single>(c)

        assertNull(c1.decryptWith(p3.secretKey))
        val d = c1.decryptWith(p3.secretKey, p2.secretKey)
        assertNotNull(d)
        assertContentEquals(data, d)
        assertTrue { c1.isDecrypted }

        val data2 = "To push unpushinable".encodeToUByteArray()
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }
        assertContentEquals(data2, c2.decryptWith(p2.secretKey))
    }

    @Test
    fun testMultipleSymmetric() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val syk3 = SymmetricKey.new()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        val c = Container.createWith(data, syk1, syk2) {
            key(p1.secretKey to p3.publicKey)
            key(p4.publicKey)
        }
        assertTrue { c.isDecrypted }
        var c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }

        assertNull(c1.decryptWith(syk3))
        assertFalse { c1.isDecrypted }

        assertContentEquals(data, c1.decryptWith(syk3, syk1))
        assertTrue { c1.isDecrypted }

        c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertNull(c1.decryptWith(p2.secretKey, p1.secretKey))
        assertContentEquals(data, c1.decryptWith(syk3, p3.secretKey))

        c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertContentEquals(data, c1.decryptWith(syk3, p4.secretKey))

        val data2 = "To push unpushinable".encodeToUByteArray()
        assertTrue { c.isDecrypted }
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }
        assertContentEquals(data2, c2.decryptWith(syk2))

    }

    @Test
    fun testSingleGrowSymmetric() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val syk3 = SymmetricKey.new()
        val p1 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, syk1)
        assertTrue { c.isDecrypted }

        fun expectOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertContentEquals(data, c1.decryptWith(k))
        }

        fun expectNotOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertNull(c1.decryptWith(k))
        }

        expectOpen(syk1)
        expectNotOpen(syk2)
        expectNotOpen(p3.secretKey)

        c.decryptWith(syk1)
        assertTrue { c.isDecrypted }
        assertNotNull(c.decryptedData)
        c += syk2
        expectOpen(syk1)
        expectOpen(syk2)
        expectNotOpen(syk3)
        expectNotOpen(p3.secretKey)

        c.decryptWith(syk1)
        c += p3.publicKey
        expectOpen(syk1)
        expectOpen(syk2)
        expectOpen(p3.secretKey)
        expectNotOpen(syk3)
        expectNotOpen(p4.secretKey)

        c.decryptWith(syk1)
        c += p1.secretKey to p4.publicKey
        expectOpen(syk1)
        expectOpen(syk2)
        expectOpen(p3.secretKey)
        expectNotOpen(syk3)
        expectOpen(p4.secretKey)

        val data2 = "To push unpushinable".encodeToUByteArray()
        assertTrue { c.isDecrypted }
        val c2 = Container.decode(c.updateData(data2).encoded)
        assertFalse { c2.isDecrypted }
        assertContentEquals(data2, c2.decryptWith(p4.secretKey))

    }

    @Test
    fun testSingleGrowAsymmetric() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val p1 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, p1.secretKey to p3.publicKey)

        fun expectOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertContentEquals(data, c1.decryptWith(k))
        }

        fun expectNotOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertNull(c1.decryptWith(k))
        }

        expectNotOpen(syk1)
        expectOpen(p3.secretKey)

        c.decryptWith(p3.secretKey)

        c += syk1
        expectOpen(syk1)
        expectNotOpen(syk2)
        expectOpen(p3.secretKey)
    }

    @Test
    fun testMixedOps1() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val syk3 = SymmetricKey.new()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, p1.secretKey to p3.publicKey)

        fun expectOpen(testData: UByteArray,vararg keys: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            for( k in keys)
                assertContentEquals(testData, c1.decryptWith(k))
        }

        fun expectNotOpen(vararg keys: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            for(k in keys) assertNull(c1.decryptWith(k))
        }

        expectNotOpen(syk1)
        expectOpen(data, p3.secretKey)

//        c = Container.decode(c.encoded)

        val data2 = "Cocktails have a delicious, complex taste".encodeToUByteArray()
        c = (c + syk3 + (p1.secretKey to p4.publicKey)).updateData(data2)
        expectNotOpen(syk2, syk1, p1.secretKey, p2.secretKey )
        expectOpen(data2, syk3, p3.secretKey, p4.secretKey)
    }

    @Test
    fun testMixedOps2() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.new()
        val syk2 = SymmetricKey.new()
        val syk3 = SymmetricKey.new()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val p5 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, p1.secretKey to p3.publicKey)

        fun expectOpen(testData: UByteArray,vararg keys: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            for( k in keys)
                assertContentEquals(testData, c1.decryptWith(k))
        }

        fun expectNotOpen(vararg keys: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            for(k in keys) assertNull(c1.decryptWith(k))
        }

        expectNotOpen(syk1)
        expectOpen(data, p3.secretKey)

        c = Container.decode(c.encoded)
        c.decryptWith(p3.secretKey)

        val data2 = "Cocktails have a delicious, complex taste".encodeToUByteArray()
        c = (c + syk3 + p5.publicKey + (p1.secretKey to p4.publicKey)).updateData(data2)
        expectNotOpen(syk2, syk1, p1.secretKey, p2.secretKey )
        expectOpen(data2, syk3, p3.secretKey, p4.secretKey)
    }

}