import kotlinx.coroutines.test.runTest
import net.sergeych.bintools.*
import net.sergeych.bipack.decodeFromBipack
import net.sergeych.crypto2.DecryptionFailedException
import net.sergeych.crypto2.EncryptedKVStorage
import net.sergeych.crypto2.SymmetricKey
import net.sergeych.crypto2.initCrypto
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertNull

class StorageTest {

    @Test
    fun testGetAndSet() = runTest {
        initCrypto()
        val plain = MemoryKVStorage()
        val key = SymmetricKey.new()
        val storage = EncryptedKVStorage(plain, key, removeExisting = false)

        var hello by storage.optStored<String>()
        assertNull(hello)
        hello = "world"
        assertEquals("world", storage["hello"]?.decodeFromBipack<String>())
        println("plain: ${plain.keys}")
        assertEquals(setOf("hello"), storage.keys)
        var foo by storage.stored("bar")
        assertEquals("bar", foo)
        foo = "bar2"
//        plain.dump()
//        storage.dump()
        assertEquals(setOf("hello", "foo"), storage.keys)
    }

    @Test
    fun testReEncrypt() = runTest {
        initCrypto()
        fun test(x: KVStorage) {
            val foo by x.stored("1")
            val bar by x.stored("2")
            val bazz by x.stored("3")
            assertEquals("foo", foo)
            assertEquals("bar", bar)
            assertEquals("bazz", bazz)
        }

        fun setup(s: KVStorage, k: SymmetricKey): EncryptedKVStorage {
            val x = EncryptedKVStorage(s, k, removeExisting = false)
            var foo by x.stored("1")
            var bar by x.stored("2")
            var bazz by x.stored("3")
            foo = "foo"
            bar = "bar"
            bazz = "bazz"
            return x
        }

        val k1 = SymmetricKey.new()
        val k2 = SymmetricKey.new()
        val plain = MemoryKVStorage()
        val s1 = setup(plain, k1)
        test(s1)
        s1.reEncrypt(k2)
        test(s1)
//        val s2  = EncryptedKVStorage(plain, k2)
//        test(s2)
    }

    @Test
    fun testDeleteExisting() = runTest {
        initCrypto()
        val plain = MemoryKVStorage()
        val c1 = EncryptedKVStorage(plain, SymmetricKey.new(), removeExisting = false)  // 1
        c1.write("hello", "world")
        assertFailsWith<DecryptionFailedException> {
            val c2 = EncryptedKVStorage(plain, SymmetricKey.new(), removeExisting = false)  // 2
        }
        val c2 = EncryptedKVStorage(plain, SymmetricKey.new(), removeExisting = true)  // 2
    }
}

fun KVStorage.dump() {
    for (k in keys)
        println("$k: ${this[k]?.toDump()}")
}