package com.rnbbssignatures

import bbs.signatures.Bbs
import bbs.signatures.KeyPair
import bbs.signatures.ProofMessage
import com.facebook.react.bridge.*

class RnBbsSignaturesModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {

  override fun getName(): String {
    return "RnBbsSignatures"
  }

  override fun canOverrideExistingModule(): Boolean {
    return true
  }

  @ReactMethod
  fun generateBls12381G1KeyPair(request: ReadableMap, promise: Promise) {
    val result = WritableNativeMap()
    val seed = ByteArray(32)

    val keyPair = Bbs.generateBls12381G1Key(seed)

    result.putArray("publicKey", keyPair.publicKey.toReadableArray())
    result.putArray("secretKey", keyPair.secretKey.toReadableArray())
    promise.resolve(result as ReadableMap)
  }

  @ReactMethod
  fun generateBls12381G2KeyPair(request: ReadableMap, promise: Promise) {
    val result = WritableNativeMap()
    val seed = ByteArray(32)
    val keyPair: KeyPair

    keyPair = Bbs.generateBls12381G2Key(seed)

    result.putArray("publicKey", keyPair.publicKey.toReadableArray())
    result.putArray("secretKey", keyPair.secretKey.toReadableArray())
    promise.resolve(result as ReadableMap)
  }

  @ReactMethod
  fun bls12381G2PublicKeyToBbsPublicKey(request: ReadableMap, promise: Promise) {
    try {
      var messageCount = 0
      var publicKey: ByteArray? = null

      if (request.hasKey("messageCount")) {
        messageCount = request.getInt("messageCount")
      }
      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }

      val bbsPublicKey = Bbs.blsPublicToBbsPublicKey(publicKey, messageCount)

      val keyPair = KeyPair(bbsPublicKey, ByteArray(0))
      keyPair.publicKey = bbsPublicKey

      promise.resolve(keyPair.publicKey.toReadableArray())
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun sign(request: ReadableMap, promise: Promise) {
    try {
      var publicKey: ByteArray? = null
      var secretKey: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("secretKey")) {
        secretKey = request.getByteArray("secretKey")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")
      }

      val signature = Bbs.sign(secretKey, publicKey, messages)

      promise.resolve(signature.toReadableArray())
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun blsSign(request: ReadableMap, promise: Promise) {
    try {
      var publicKey: ByteArray? = null
      var secretKey: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("secretKey")) {
        secretKey = request.getByteArray("secretKey")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")
      }

      val signature = Bbs.blsSign(secretKey, publicKey, messages)

      promise.resolve(signature.toReadableArray())
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun verify(request: ReadableMap, promise: Promise) {
    try {
      var publicKey: ByteArray? = null
      var signature: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")
      }
      if (request.hasKey("signature")) {
        signature = request.getByteArray("signature")
      }

      val verified = Bbs.verify(publicKey, signature, messages)
      promise.resolve(verified)
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun blsVerify(request: ReadableMap, promise: Promise) {
    try {
      var messageCount: Int = 0
      var publicKey: ByteArray? = null
      var signature: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")
        if (messages != null) {
          messageCount = messages.count()
        }
      }
      if (request.hasKey("signature")) {
        signature = request.getByteArray("signature")
      }

      val verified = Bbs.blsVerify(publicKey, signature, messages)

      promise.resolve(verified)
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun createProof(request: ReadableMap, promise: Promise) {
    try {
      var nonce: ByteArray? = null
      var publicKey: ByteArray? = null
      var signature: ByteArray? = null
      var messages: Array<ByteArray>? = null
      var revealed: ReadableArray? = null
      var revealedArray: ArrayList<Int> = ArrayList<Int>()
      var proofMessage: Array<ProofMessage> = arrayOf()

      val blindingFactor = ByteArray(0)

      if (request.hasKey("nonce")) {
        nonce = request.getByteArray("nonce")
      }
      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("revealed")) {
        revealed = request.getByteArray("revealed").toReadableArray()
        revealedArray = ArrayList(revealed.size())

        for (i in 0 until revealed.size() step 1) {
          revealedArray.add(revealed.getInt(i))
        }
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")

        if (messages != null && messages.count() > 0) {
          var type: Int
          for ((index, message) in messages.withIndex()) {
            type = if (revealedArray.contains(index)) {
              1 // Revealed
            } else {
              2 // Hidden
            }

            val list: MutableList<ProofMessage> = proofMessage.toMutableList()
            list.add(ProofMessage(type, message, blindingFactor))
            proofMessage = list.toTypedArray()
          }
        }
      }
      if (request.hasKey("signature")) {
        signature = request.getByteArray("signature")
      }

      val proof = Bbs.createProof(publicKey, nonce, signature, proofMessage)

      promise.resolve(proof.toReadableArray())
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun verifyProof(request: ReadableMap, promise: Promise) {
    try {
      var publicKey: ByteArray? = null
      var proof: ByteArray? = null
      var nonce: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("proof")) {
        proof = request.getByteArray("proof")
      }
      if (request.hasKey("nonce")) {
        nonce = request.getByteArray("nonce")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")!!
      }

      val verified = Bbs.verifyProof(publicKey, proof, nonce, messages)

      promise.resolve(verified)
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun blsCreateProof(request: ReadableMap, promise: Promise) {
    try {
      var nonce: ByteArray? = null
      var publicKey: ByteArray? = null
      var signature: ByteArray? = null
      var messages: Array<ByteArray>? = null
      var revealed: ReadableArray? = null
      var revealedArray: ArrayList<Int> = ArrayList<Int>()
      var proofMessage: Array<ProofMessage> = arrayOf()
      val blindingFactor = ByteArray(0)

      if (request.hasKey("nonce")) {
        nonce = request.getByteArray("nonce")
      }
      if (request.hasKey("revealed")) {
        revealed = request.getByteArray("revealed").toReadableArray()
        revealedArray = ArrayList(revealed.size())

        for (i in 0 until revealed.size() step 1) {
          revealedArray.add(revealed.getInt(i))
        }
      }
      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")

        if (messages != null && messages.count() > 0) {
          var type: Int
          for ((index, message) in messages.withIndex()) {
            type = if (revealedArray.contains(index)) {
              1 // Revealed
            } else {
              2 // Hidden
            }

            val list: MutableList<ProofMessage> = proofMessage.toMutableList()
            list.add(ProofMessage(type, message, blindingFactor))
            proofMessage = list.toTypedArray()
          }
        }
      }
      if (request.hasKey("signature")) {
        signature = request.getByteArray("signature")
      }

      val proof = Bbs.blsCreateProof(publicKey, nonce, signature, proofMessage)

      promise.resolve(proof.toReadableArray())
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }

  @ReactMethod
  fun blsVerifyProof(request: ReadableMap, promise: Promise) {
    try {
      var publicKey: ByteArray? = null
      var proof: ByteArray? = null
      var nonce: ByteArray? = null
      var messages: Array<ByteArray>? = null

      if (request.hasKey("publicKey")) {
        publicKey = request.getByteArray("publicKey")
      }
      if (request.hasKey("proof")) {
        proof = request.getByteArray("proof")
      }
      if (request.hasKey("nonce")) {
        nonce = request.getByteArray("nonce")
      }
      if (request.hasKey("messages")) {
        messages = request.getArrayOfByteArrays("messages")!!
      }

      val verified = Bbs.blsVerifyProof(publicKey, proof, nonce, messages)

      promise.resolve(verified)
    } catch (exception: Exception) {
      promise.reject(exception)
    }
  }
}