/* This file is part of libbrandt.
 * Copyright (C) 2016 GNUnet e.V.
 *
 * libbrandt is free software: you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation, either version 3 of the License, or (at your option) any later
 * version.
 *
 * libbrandt is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
 * A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * libbrandt.  If not, see <http://www.gnu.org/licenses/>.
 */

/**
 * @file brandt.c
 * @brief \todo
 * @author Markus Teich
 */
#include <gcrypt.h>

#include "crypto.h"
#include "internals.h"
#include "util.h"


typedef int
(*msg_recv)(struct BRANDT_Auction *ad,
            const unsigned char   *buf,
            size_t                buflen,
            uint16_t              sender);


/**
 * stores the function pointers to receive functions for each state.
 *
 * The first index denotes if a first price auction or a M+1st price auction is
 * used. If it is 0, it is a first price auction, if it is 1, it is a M+1st
 * price auction.
 *
 * The second index denotes if the outcome should be public or private. A value
 * of 0 means a private outcome, while a value of 1 means public outcome.
 */
static msg_recv handler_in[2][2][msg_last] =
{
	[0] =
	{
		[0] =
		{
			[msg_init] = smc_recv_keyshare,
			[msg_bid] = smc_recv_encrypted_bid,
			[msg_outcome] = fp_priv_recv_outcome,
			[msg_decrypt] = fp_priv_recv_decryption,
		},
		[1] =
		{
			[msg_init] = smc_recv_keyshare,
			[msg_bid] = smc_recv_encrypted_bid,
			[msg_outcome] = fp_pub_recv_outcome,
			[msg_decrypt] = fp_pub_recv_decryption,
		}
	},
	[1] =
	{
		[0] =
		{
			[msg_init] = smc_recv_keyshare,
			[msg_bid] = smc_recv_encrypted_bid,
		},
		[1] =
		{
			[msg_init] = smc_recv_keyshare,
			[msg_bid] = smc_recv_encrypted_bid,
		}
	}
};


void
BRANDT_init ()
{
	gcry_error_t err = 0;

	if (!gcry_check_version ("1.7.0"))
		eprintf ("libgcrypt version mismatch");

	/* SECMEM cannot be resized dynamically. We do not know how much we need */
	if ((err = gcry_control (GCRYCTL_DISABLE_SECMEM, 0)))
		weprintf ("failed to set libgcrypt option DISABLE_SECMEM: %s",
		          gcry_strerror (err));

	/* ecc is slow otherwise and we don't create long term keys anyway. */
	if ((err = gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0)))
		weprintf ("failed to set libgcrypt option ENABLE_QUICK_RANDOM: %s",
		          gcry_strerror (err));

	gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
	brandt_crypto_init ();
}


void
BRANDT_got_message (struct BRANDT_Auction *auction,
                    uint16_t              sender,
                    const unsigned char   *msg,
                    size_t                msg_len)
{
	uint16_t    type = *(uint16_t *)msg;
	int         m = !!auction->desc->m;
	int         pub = !!auction->desc->outcome_public;
	enum rounds round = auction->cur_round;

	/** todo: cache out of order messages */

	if (!handler_in[m][pub][round] ||
	    !handler_in[m][pub][round](auction,
	                               msg + sizeof (type),
	                               msg_len - sizeof (type),
	                               sender))
	{
		/** \todo */
		weprintf ("wow fail");
	}
	msg + sizeof (type);
}