#include <gnunet/platform.h>
#include <gnunet/gnunet_crypto_lib.h>
#include <gnunet/gnunet_signatures.h>

#include <taler/taler_mintdb_plugin.h>
#include <taler/taler_signatures.h>
#include <taler/taler_amount_lib.h>


#define CURRENCY "EUR\0\0\0\0\0\0\0\0"

struct TALER_MINTDB_CollectableBlindcoin *
init_CollectableBlindcoin ()
{
  // indent by 2 spaces
  struct TALER_MINTDB_CollectableBlindcoin *coin = GNUNET_new (*coin);

    struct GNUNET_CRYPTO_EddsaPrivateKey *reserve_sig_key = GNUNET_CRYPTO_eddsa_key_create ();
    struct GNUNET_CRYPTO_rsa_PrivateKey  *denomination_key = GNUNET_CRYPTO_rsa_private_key_create (512);


    coin->denom_pub.rsa_public_key = GNUNET_CRYPTO_rsa_private_key_get_public (denomination_key);
    GNUNET_CRYPTO_eddsa_key_get_public (reserve_sig_key,
                                        &coin->reserve_pub.eddsa_pub);


    //TODO Randomise the amount that is deposited and apply a fee subsequently

    // GNUNET_assert (GNUNET_OK ==
    //                TALER_string_to_amount (CURRENCY ":1.1",
    //                                        &coin->amount_with_fee));

    coin->amount_with_fee = (struct TALER_Amount) {1, 1, CURRENCY};
    coin->withdraw_fee    = (struct TALER_Amount) {0, 1, CURRENCY};


    int random_int = rand(); // GNUNET_CRYPTO_random_u32
    coin->sig.rsa_signature = GNUNET_CRYPTO_rsa_sign(denomination_key, &random_int, sizeof(random_int));
    GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &coin->h_coin_envelope);

    void *purpose = GNUNET_malloc (sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof(int));
    ((struct GNUNET_CRYPTO_EccSignaturePurpose *)purpose)->size = sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose) + sizeof(int);
    ((struct GNUNET_CRYPTO_EccSignaturePurpose *)purpose)->purpose = GNUNET_SIGNATURE_PURPOSE_TEST;
    *((int *)(purpose + sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose))) = random_int;

    GNUNET_CRYPTO_eddsa_sign(reserve_sig_key, purpose, &coin->reserve_sig.eddsa_signature);



    GNUNET_free(reserve_sig_key);
    GNUNET_CRYPTO_rsa_private_key_free(denomination_key);
    return coin;
}


struct TALER_MINTDB_Reserve *
init_Reserve(){
    struct TALER_MINTDB_Reserve *reserve = GNUNET_malloc(sizeof(*reserve));
    struct GNUNET_CRYPTO_EddsaPrivateKey *reserve_priv = GNUNET_CRYPTO_eddsa_key_create();

    GNUNET_CRYPTO_eddsa_key_get_public(reserve_priv , &(reserve->pub.eddsa_pub));


    reserve->balance = (struct TALER_Amount){1, 1, CURRENCY};
    reserve->expiry = GNUNET_TIME_absolute_get_forever_();

    GNUNET_free(reserve_priv);
    return reserve;
}


struct TALER_MINTDB_RefreshSession *
init_Refresh_session(){
    struct TALER_MINTDB_RefreshSession *refresh_session = GNUNET_malloc(sizeof(*refresh_session));

    refresh_session->noreveal_index = 1;
    refresh_session->num_oldcoins = 1;
    refresh_session->num_newcoins = 1;

    return refresh_session;
}


struct TALER_MINTDB_Deposit *
init_Deposit(){
    static int transaction_id = 0;

    struct TALER_MINTDB_Deposit *deposit = GNUNET_malloc(sizeof(*deposit));

    deposit-> transaction_id = transaction_id;
    transaction_id++;


    //TODO Randomize the amount that is deposited

    deposit->amount_with_fee = (struct TALER_Amount) {1, 1, CURRENCY};
    deposit->deposit_fee = (struct TALER_Amount) {0, 1, CURRENCY};

    deposit->timestamp = GNUNET_TIME_absolute_get();
    deposit->refund_deadline = GNUNET_TIME_absolute_get();

    GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &deposit->h_contract);
    GNUNET_CRYPTO_hash_create_random(GNUNET_CRYPTO_QUALITY_WEAK, &deposit->h_wire);

    // Coin Spend Signature
    {
        struct GNUNET_CRYPTO_EddsaSignature sig;

        struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prvt = GNUNET_CRYPTO_eddsa_key_create();
        void *prp = GNUNET_malloc(sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)+sizeof(int));
        *((struct GNUNET_CRYPTO_EccSignaturePurpose *)prp) =(struct GNUNET_CRYPTO_EccSignaturePurpose) {sizeof(struct GNUNET_CRYPTO_EccSignaturePurpose)+sizeof(int), GNUNET_SIGNATURE_PURPOSE_TEST};


        GNUNET_CRYPTO_eddsa_sign(p_eddsa_prvt, (struct GNUNET_CRYPTO_EccSignaturePurpose *) prp, &sig);

        deposit->csig.eddsa_signature = sig;

        GNUNET_free(p_eddsa_prvt);
    }

    // Merchant Key
    {
        struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
        struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prv = GNUNET_CRYPTO_eddsa_key_create();

        GNUNET_CRYPTO_eddsa_key_get_public(p_eddsa_prv, &eddsa_pub);

        deposit->merchant_pub.eddsa_pub = eddsa_pub;

        GNUNET_free(p_eddsa_prv);
    }

    // Coin
    {


        {
            struct GNUNET_CRYPTO_EddsaPublicKey eddsa_pub;
            struct GNUNET_CRYPTO_EddsaPrivateKey *p_eddsa_prvt = GNUNET_CRYPTO_eddsa_key_create();

            GNUNET_CRYPTO_eddsa_key_get_public(p_eddsa_prvt, &eddsa_pub);

            deposit->coin.coin_pub.eddsa_pub = eddsa_pub;

            GNUNET_free(p_eddsa_prvt);
        }

        {
            struct GNUNET_CRYPTO_rsa_PrivateKey *p_rsa_prv = GNUNET_CRYPTO_rsa_private_key_create(128);
            struct GNUNET_CRYPTO_rsa_PublicKey *p_rsa_pub = GNUNET_CRYPTO_rsa_private_key_get_public(p_rsa_prv);

            deposit->coin.denom_pub.rsa_public_key = p_rsa_pub;



            deposit->coin.denom_sig.rsa_signature = GNUNET_CRYPTO_rsa_sign(p_rsa_prv,
                                                            (void *) &(deposit->coin.coin_pub.eddsa_pub),
                                                            sizeof(&(deposit->coin.coin_pub.eddsa_pub)));

            GNUNET_CRYPTO_rsa_private_key_free(p_rsa_prv);
        }

    }


    return deposit;
}


struct TALER_MINTDB_DenominationKeyIssueInformation *
init_denomination(){
  struct TALER_MINTDB_DenominationKeyIssueInformation *dki = GNUNET_malloc(sizeof(&dki));


  dki->denom_priv.rsa_private_key
    = GNUNET_CRYPTO_rsa_private_key_create (128);
  GNUNET_assert (NULL != dki->denom_priv.rsa_private_key);
  dki->denom_pub.rsa_public_key
    = GNUNET_CRYPTO_rsa_private_key_get_public (dki->denom_priv.rsa_private_key);
  GNUNET_CRYPTO_rsa_public_key_hash (dki->denom_pub.rsa_public_key,
      &dki->issue.denom_hash);

  struct GNUNET_CRYPTO_EddsaPrivateKey *master_prvt =
    GNUNET_CRYPTO_eddsa_key_create();

  struct GNUNET_CRYPTO_EddsaPublicKey master_pub;

  GNUNET_CRYPTO_eddsa_key_get_public(master_prvt, &master_pub);
  dki->issue.master.eddsa_pub = master_pub;

  struct GNUNET_TIME_Absolute anchor = GNUNET_TIME_absolute_get();

  dki->issue.start = GNUNET_TIME_absolute_hton (anchor);
  dki->issue.expire_withdraw =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
          GNUNET_TIME_relative_get_hour_()));
  dki->issue.expire_spend =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
          GNUNET_TIME_relative_get_hour_()));
  dki->issue.expire_legal =
    GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_add (anchor,
          GNUNET_TIME_relative_get_hour_()));

  struct TALER_Amount amount = {.value = 1, .fraction = 1, .currency = CURRENCY};

  TALER_amount_hton (&dki->issue.value, &amount);
  TALER_amount_hton (&dki->issue.fee_withdraw, &amount);
  TALER_amount_hton (&dki->issue.fee_deposit, &amount);
  TALER_amount_hton (&dki->issue.fee_refresh, &amount);
  dki->issue.purpose.purpose = htonl (TALER_SIGNATURE_MASTER_DENOMINATION_KEY_VALIDITY);
  dki->issue.purpose.size = htonl (sizeof (struct TALER_MINTDB_DenominationKeyIssueInformation) -
      offsetof (struct TALER_MINTDB_DenominationKeyIssueInformation,
        issue.purpose));
  GNUNET_assert (GNUNET_OK ==
      GNUNET_CRYPTO_eddsa_sign (master_prvt,
        &dki->issue.purpose,
        &dki->issue.signature.eddsa_signature));

  return dki;
}







// Destructors


int
free_deposit(struct TALER_MINTDB_Deposit *deposit){
  GNUNET_free(deposit->coin.denom_pub.rsa_public_key);
  GNUNET_free(deposit->coin.denom_sig.rsa_signature);

  GNUNET_free(deposit);

  return GNUNET_OK;
}


int
free_coin(struct TALER_MINTDB_CollectableBlindcoin *coin){
  GNUNET_free(coin->sig.rsa_signature);
  GNUNET_free(coin->denom_pub.rsa_public_key);

  GNUNET_free(coin);

  return GNUNET_OK;
}


int
free_denomination(struct TALER_MINTDB_DenominationKeyIssueInformation *dki){
  GNUNET_free(dki->denom_priv.rsa_private_key);
  GNUNET_free(dki->denom_pub.rsa_public_key);

  GNUNET_free(dki);

  return GNUNET_OK;
}