import com.ionspin.kotlin.crypto.util.encodeToUByteArray
import kotlinx.coroutines.test.runTest
import net.sergeych.bintools.toDump
import net.sergeych.bipack.BipackDecoder
import net.sergeych.bipack.BipackEncoder
import net.sergeych.crypto2.*
import kotlin.test.*

class RingTest {

    @Test
    fun testCreationAndSerialization() = runTest {
        initCrypto()

        val y1 = SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray())
        val y2 = SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray())
        assertEquals(y1, y2)

        val e1 = Asymmetric.new()
        val e2: Asymmetric.SecretKey = BipackDecoder.decode(BipackEncoder.encode(e1))
        assertEquals(e1, e2)

        val k1 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))
        val k11 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))

        assertEquals(k1, k11)


        val k2 = UniversalKey.from(Asymmetric.new())
        val k3 = UniversalKey.from(Asymmetric.new())
//
        val r = UniversalRing(k1, k2)
//        val r = UniversalRing(k1)
        assertTrue(k2 in r)
        assertTrue(k1 in r)
        assertFalse { k3 in r }

        println(Asymmetric.new().keyBytes.size)
        println(BipackEncoder.encode(Asymmetric.new()).size)
        val encoded = BipackEncoder.encode(r)
        println(encoded.toDump())
        println(encoded.size)
        assertTrue { encoded.size < 80 }
        val r2: UniversalRing = BipackDecoder.decode(encoded)
        assertTrue { k2 in r2 }
        assertTrue { k1 in r2 }
        assertFalse { k3 in r2 }

        println("\r\n")
        println(r)
        println(r2)

//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]
//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]

        assertEquals(r, r2)
    }

    @Test
    fun testTags() = runTest {
        initCrypto()

        val k1 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))
        val k2 = UniversalKey.from(Asymmetric.new())

        val r1 = UniversalRing(k1, k2)
        var r2 = UniversalRing(deepCopy(k1), deepCopy(k2))
        assertEquals(r2, r1)
        val r3 = UniversalRing(k1 to "foo", k2 to "bar")
        assertNotEquals(r3, r2)
        assertTrue { r3 equalKeys r2 }

        r2 += (k1 to "foo")
        r2 = r2.addTags(k2, "bar")
        assertEquals(r2, r3)
        assertEquals(deepCopy(r2), r3)

        r2 += k1 to "buzz"
        r2 = deepCopy(r2)
        assertEquals(setOf("foo", "buzz"), r2.getTags(k1))
        assertNotEquals(r2, r3)
        r2 = deepCopy(r2.removeTags(k1, "buzz"))
        assertEquals(r2, r3)
    }

    @Test
    fun testAsymmetricEncryption() = runTest {
        initCrypto()

        val sk1 = UniversalKey.newSecretKey()
        val sk2 = UniversalKey.newSecretKey()
        val sk3 = UniversalKey.newSecretKey()
//        val sk4 = UniversalKey.newSecretKey()
        val sik1 = UniversalKey.newSigningKey()
//        val sik2 = UniversalKey.newSigningKey()
        val sik3 = UniversalKey.newSigningKey()

        val data = "Mendeleev' table".encodeToUByteArray()

        var r = UniversalRing(sk2, sk3, sk1.publicKey, sk3.publicKey, sik3.publicKey, sik1.publicKey)

        r = r.addTags(sik1, "SECRET_SIGN")

        val box = deepCopy(Container.create(data) { key(sk3.publicKey) })
        assertContentEquals(data, box.decryptWith(r))

        assertEquals(sk3.publicKey, r.findKey<EncryptingKey>(sk3.id))
        assertTrue { sik3.publicKey in r }
        assertTrue { sik1 in r }
        assertEquals(sik1, r.keyByTag<UniversalKey>("SECRET_SIGN"))

        assertEquals(sik1, r.findKey<SigningKey>(sik1.publicKey.id))
    }

    @Test
    fun testSize() = runTest {
//        val sy1 = SymmetricKey.random().toUniversal()
    }
}