package main

import (
    "bytes"
    "fmt"
    "time"

    "github.com/henrydcase/nobs/dh/csidh"
    "github.com/henrydcase/nobs/drbg"
    "github.com/henrydcase/sidh_torture/csidh/ref/go-wrapper"
)

var rng *drbg.CtrDrbg

func TestSS() {
    var r wrapper.Ref
    var ssRef [csidh.SharedSecretSize]byte
    var ss [csidh.SharedSecretSize]byte
    var prB csidh.PrivateKey
    var pkB csidh.PublicKey

    // Go types
    prA := r.KeygenPrv()
    pkA := r.KeygenPub(&prA)

    csidh.GeneratePrivateKey(&prB, rng)
    csidh.GeneratePublicKey(&pkB, &prB, rng)

    s1 := time.Now()
    // Generate with Go
    csidh.DeriveSecret(&ss, &pkA, &prB, rng)
    s2 := time.Since(s1)

    // Generate with C
    s1 = time.Now()
    r.Derive(ssRef[:], &pkB, &prA)
    s3 := time.Since(s1)
    fmt.Printf("|TestSharedSecret  | %.8s | %.8s |\n", s2, s3)

    if !bytes.Equal(ss[:], ssRef[:]) {
        panic("TestSS")
    }
}

func TestKeyGeneration() {
    var r wrapper.Ref
    var ssRef [csidh.SharedSecretSize]byte
    var ss [csidh.SharedSecretSize]byte

    // Go types
    var prA csidh.PrivateKey
    var pkA csidh.PublicKey
    var prB csidh.PrivateKey
    var pkB csidh.PublicKey

    csidh.GeneratePrivateKey(&prA, rng)
    csidh.GeneratePublicKey(&pkA, &prA, rng)
    csidh.GeneratePrivateKey(&prB, rng)
    csidh.GeneratePublicKey(&pkB, &prB, rng)

    s1 := time.Now()
    // Generate with Go
    r.Derive(ss[:], &pkA, &prB)
    s2 := time.Since(s1)

    // Generate with C
    s1 = time.Now()
    r.Derive(ssRef[:], &pkB, &prA)
    s3 := time.Since(s1)
    fmt.Printf("|TestKeyGeneration | %.8s | %.8s |\n", s2, s3)

    if !bytes.Equal(ss[:], ssRef[:]) {
        panic("TestKeyGeneration")
    }
}

func main() {
    fmt.Printf("| TestName         |Go        | C        |\n")
    fmt.Printf("|------------------|----------|----------|\n")

    rng = drbg.NewCtrDrbg()
    for {
        TestSS()
        TestKeyGeneration()
    }
}