/**
 * SendCertificate: receives ssl connection parameters (it's a huge structure defined in ...)
 *        - get RSA private key of client (using what key ?)
 *         - build SHA-1 hash of certificate
 *        - encode digest (using what key ?)
 *        - sign it using RSA private key
**/


int SendCertificateVerify(CYASSL* ssl)
{
    byte              *output;
    int                sendSz = 0, length, ret;
    word32             idx = 0;
    word32             sigOutSz = 0;
    RsaKey             key;
    int                usingEcc = 0;
    int                     var = 0;

    // proof that this code is executed by the client
    printf(">> I AM A %d AND CLIENT_END IS %d\n", ssl->options.side, CLIENT_END);

    if (ssl->options.sendVerify == SEND_BLANK_CERT)
        return 0;  /* sent blank cert, can't verify */

    /* check for avalaible size */
    if ((ret = CheckAvalaibleSize(ssl, MAX_CERT_VERIFY_SZ)) != 0)
        return ret;

    /* get ouput buffer */        // output buffer of what ???
    output = ssl->buffers.outputBuffer.buffer + ssl->buffers.outputBuffer.length;

    // BuildCertHashes => Does this build the certificate hash ?
    BuildCertHashes(ssl, &ssl->certHashes);

    // Looks like we prepare room for the RSA key inside the ssl structure (since so far "key" is empty)
    InitRsaKey(&key, ssl->heap);

    // Decode RSA Private key from ssl structure and put it into key   <= what key do we use to do so ?
    ret = RsaPrivateKeyDecode(ssl->buffers.key.buffer, &idx, &key, ssl->buffers.key.length);

    if (ret == 0)
        sigOutSz = RsaEncryptSize(&key);
    else 
        {
        }
    if (ret == 0) 
        {
        byte*  verify = (byte*)&output[RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ];
        byte*  signBuffer = ssl->certHashes.md5;
        word32 signSz = sizeof(Hashes);
        byte   encodedSig[MAX_ENCODED_SIG_SZ];
        word32 extraSz = 0;  /* tls 1.2 hash/sig */

        length = sigOutSz;
        if (IsAtLeastTLSv1_2(ssl))
            {
            verify[0] = sha_mac;
            verify[1] = usingEcc ? ecc_dsa_sa_algo : rsa_sa_algo;
            extraSz = HASH_SIG_SIZE;
            }
        c16toa((word16)length, verify + extraSz); /* prepend verify header*/

        if (usingEcc) 
            {
            }
        else 
            {
            if (IsAtLeastTLSv1_2(ssl)) 
                {
                byte* digest;
                int   typeH;
                int   digestSz;

                /* sha1 for now */
                digest   = ssl->certHashes.sha;
                typeH    = SHAh;
                digestSz = SHA_DIGEST_SIZE;

                printf(">> This is my SHA-1 hash, which size is %d:\n", SHA_DIGEST_SIZE);
                for(var=0; var<SHA_DIGEST_SIZE; var++)
                    printf("%d ", digest[var]); 
                printf("\n");

                // encode signature: input digest and size and type of hash, output signature and size
                signSz = EncodeSignature(encodedSig, digest, digestSz, typeH);
                signBuffer = encodedSig;

                printf(">> This is my encoded hash, which size is %d:\n", signSz);
                for(var=0; var<signSz; var++)
                    printf("%d ", encodedSig[var]); 
                printf("\n");
                }

            // sign the encoded signature: 
                // input index in a buffer, private RSA key, encrypt len (512)
                // output is in signBuffer, probably rng (random number genrator ??)
            ret = RsaSSL_Sign(signBuffer, signSz, verify + extraSz + VERIFY_HEADER, ENCRYPT_LEN, &key, &ssl->rng);

            printf(">> This is my signed encoded hash, which size is %d:\n", ENCRYPT_LEN);
            for(var=0; var<ENCRYPT_LEN; var++)
                printf("%d ", signBuffer[var]); 
            printf("\n");

            if (ret > 0)
                ret = 0;  /* RSA reset */
            }
        
        if (ret == 0) 
            {
            // add header to certificate ??
            AddHeaders(output, length + extraSz + VERIFY_HEADER, certificate_verify, ssl);
            sendSz = RECORD_HEADER_SZ + HANDSHAKE_HEADER_SZ + length + extraSz + VERIFY_HEADER;
            HashOutput(ssl, output, sendSz, 0);
            }
        }

    // delete object
    FreeRsaKey(&key);

    if (ret == 0) 
        {
        ssl->buffers.outputBuffer.length += sendSz;
        if (ssl->options.groupMessages)
            return 0;
        else
            return SendBuffered(ssl);
        }
    else
        return ret;
}