import java.math.BigInteger
import java.util.*

class RSA(val pq: Pair<BigInteger,BigInteger>) {
    val sizeOfValues = 1024
    // generate two values
    //val p = BigInteger.probablePrime(sizeOfValues, Random())
    //val q = BigInteger.probablePrime(sizeOfValues, Random())
    var tmpToShow: BigInteger? = null
    val p = pq.first
    val q = pq.second
    val n = p*q  // our module
    var publicKey = Pair(BigInteger.ZERO,BigInteger.ZERO)
    var privateKey = Pair(BigInteger.ZERO,BigInteger.ZERO)

    val eilerVal = (p.minus(1.toBigInteger()))*(q.minus(1.toBigInteger()))

    val e = BigInteger.valueOf(3) // public exponent


    fun go(){
        checkE(e)
        val d = modInversion(e,eilerVal)
        publicKey = Pair(e,n)
        privateKey = Pair(d,n)
        println("Public key is {${publicKey.first};${publicKey.second}}")
        println("Private key is {${privateKey.first};${privateKey.second}}")
    }

    fun encrypt(message: BigInteger): BigInteger? {
        val encryptedMsg = message.insverseMod(publicKey)
        println("Encrypted message is $encryptedMsg")
        return encryptedMsg
    }

    fun decrypt(message: BigInteger): BigInteger? {
        val decryptedMsg = message.insverseMod(privateKey)
        println("Decrypted message is $decryptedMsg")
        return decryptedMsg
    }

    fun sign(message: BigInteger): Pair<BigInteger, BigInteger> {
        tmpToShow = message

        var s = message.insverseMod(privateKey)
        val sha = SHA1()
        val sString = sha.encrypt(s.toString())
        return Pair(message,s!!)
    }

    fun checkSign(signedMessage: Pair<BigInteger,BigInteger>): Boolean {
        val checkingPair = signedMessage.second.insverseMod(publicKey)
        println("Checking pair is $checkingPair")
        if (checkingPair == tmpToShow){
            return true
        }
        return false
    }


    fun checkE(e: BigInteger){
        if (e > 1.toBigInteger() && e < eilerVal && isPrime(e, eilerVal)) {
                println("Open exponent is correct")
            } else {
                println("Your open exponent is wrong")
            }
        }
    private fun nod(a: BigInteger, b: BigInteger): BigInteger {
        var a = a
        var b = b
        var t: BigInteger
        while (b != BigInteger.ZERO) {
            t = a
            a = b
            b = t % b
        }
        return a
    }

    private fun isPrime(a: BigInteger, b: BigInteger): Boolean {
        return nod(a, b) == 1.toBigInteger()
    }

    fun ClosedRange<Int>.random() =
            Random().nextInt(endInclusive - start) +  start

    fun modInversion(a: BigInteger, m: BigInteger): BigInteger {
        var a = a
        var m = m
        val m0 = m
        var y = BigInteger.ZERO
        var x = BigInteger.ONE

        if (m == BigInteger.ONE)
            return BigInteger.ZERO

        while (a.compareTo(BigInteger.ONE) > 0) {
            val q = a.divide(m)
            var t = m
            m = a.mod(m)
            a = t
            t = y

            y = x.subtract(q.multiply(y))
            x = t
        }


        if (x.compareTo(BigInteger.ONE) < 0)
            x = x.add(m0)

        return x
    }
}

private fun BigInteger.insverseMod(key: Pair<BigInteger, BigInteger>): BigInteger? {
    return modPower(this,key.first,key.second)
}

fun modPower(base: BigInteger, exponent: BigInteger, mod: BigInteger): BigInteger {
    var base = base
    var exponent = exponent
    var mod = mod
    var res = BigInteger("1")
    if (exponent.compareTo(BigInteger.ZERO) < 0) {
        exponent = exponent.abs()
    }
    if (base.compareTo(BigInteger.ZERO) < 0) {
        base = base.abs()
    }
    if (mod.compareTo(BigInteger.ZERO) < 0) {
        mod = mod.abs()
    }

    while (exponent.compareTo(BigInteger.ZERO) > 0) {
        if (exponent.and(BigInteger.ONE).compareTo(BigInteger.ONE) == 0) {
            res = res.multiply(base).mod(mod)
        }
        base = base.multiply(base).mod(mod)
        exponent = exponent.shiftRight(1)
    }
    return res
}