// Copyright (c) 2012-2013 The Boolberry developers
// Copyright (c) 2012-2013 The Zano developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#pragma once
// 
// #include "crypto/crypto.h"
// #include "currency_core/currency_basic.h"
// #include "profile_tools.h"
// 
// extern "C" {
// #include "crypto/keccak.h"
// //#include "crypto/alt/KeccakNISTInterface.h"
// }
// 
// 
// #include "crypto/wild_keccak.h"
// //#include "crypto/wild_keccak2.h"
// #include "../core_tests/random_helper.h"
// #include "crypto/hash.h"
// 
// 
// 
// 
// #define TEST_BUFF_LEN 200
// 
// class test_keccak_base
// {
// public:
//   static const size_t loop_count = 100000;
// 
//   bool init()
//   {
//     currency::block b;
//     m_buff = currency::get_block_hashing_blob(b);
//     m_buff.append(32 * 4, 0);
//     return true;
//   }
// 
//   bool pretest()
//   {
//     ++m_buff[0];
//     if (!m_buff[0])
//       ++m_buff[0];
//     return true;
//   }
// protected:
//   std::string m_buff;
// };
// 
// // class test_keccak : public test_keccak_base
// // {
// // public:
// //   bool test()
// //   {
// //     pretest();
// //     crypto::hash h;
// //     keccak(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
// //     LOG_PRINT_L4(h);
// //     return true;
// //   }
// // };
// 
// 
// class test_keccak_generic : public test_keccak_base
// {
// public:
//   bool test()
//   {
//     pretest();
//     crypto::hash h;
//     crypto::keccak_generic<crypto::regular_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
//     LOG_PRINT_L4(h);
//     return true;
//   }
// };
// 
// class test_keccak_generic_with_mul : public test_keccak_base
// {
// public:
//   bool test()
//   {
//     pretest();
//     crypto::hash h;
//     crypto::keccak_generic<crypto::mul_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h));
//     return true;
//   }
// };
// 
// template<int scratchpad_size>
// class test_wild_keccak : public test_keccak_base
// {
// public:
//   bool init()
//   {
//     m_scratchpad_vec.resize(scratchpad_size / sizeof(crypto::hash));
//     for (auto& h : m_scratchpad_vec)
//       h = crypto::rand<crypto::hash>();
// 
//     return test_keccak_base::init();
//   }
// 
//   bool test()
//   {
//     pretest();
// 
//     crypto::hash h;
//     crypto::wild_keccak_dbl<crypto::mul_f>(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h), sizeof(h), [&](crypto::state_t_m& st, crypto::mixin_t& mix)
//     {
// #define SCR_I(i) m_scratchpad_vec[st[i]%m_scratchpad_vec.size()]
//       for (size_t i = 0; i != 6; i++)
//       {
//         OPT_XOR_4_RES(SCR_I(i * 4), SCR_I(i * 4 + 1), SCR_I(i * 4 + 2), SCR_I(i * 4 + 3), *(crypto::hash*)&mix[i * 4]);
//       }
//     });
// 
//     return true;
//   }
// protected:
//   std::vector<crypto::hash> m_scratchpad_vec;
// };
// 
// // 
// // template<int scratchpad_size>
// // class test_wild_keccak2 : public test_keccak_base
// // {
// // public:
// //   bool init()
// //   {
// //     m_scratchpad_vec.resize(scratchpad_size / sizeof(crypto::hash));
// //     for (auto& h : m_scratchpad_vec)
// //       h = crypto::rand<crypto::hash>();
// // 
// //     return test_keccak_base::init();
// //   }
// // 
// //   bool test()
// //   {
// //     pretest();
// // 
// //     crypto::hash h2;
// //     crypto::wild_keccak_dbl_opt(reinterpret_cast<const uint8_t*>(&m_buff[0]), m_buff.size(), reinterpret_cast<uint8_t*>(&h2), sizeof(h2), (const UINT64*)&m_scratchpad_vec[0], m_scratchpad_vec.size() * 4);
// //     LOG_PRINT_L4("HASH:" << h2);
// //     return true;
// //   }
// // protected:
// //   std::vector<crypto::hash> m_scratchpad_vec;
// // };
// 
// #ifdef _DEBUG
//   #define max_measere_scratchpad 100000
// #else
//   #define max_measere_scratchpad 50000000
// #endif
// #define measere_rounds 10000
// 
// void generate_scratchpad()
// {
//   crypto::hash seed = crypto::cn_fast_hash("sdssdsffdss", 10);
//   std::vector<crypto::hash> scratchpad;
//   size_t count = 500000000 / 32;
//   TIME_MEASURE_START_MS(gen_time);
//   LOG_PRINT_L0("Generating....");
//   crypto::generate_scratchpad2(seed, scratchpad, count);
//   TIME_MEASURE_FINISH_MS(gen_time);
//   LOG_PRINT_L0("Generated scratchpad " << (scratchpad.size() * 32) / (1024 * 1024) << "MB in " << gen_time << "ms");
// }
// 
// void generate_light_scratchpad()
// {
//   crypto::hash seed = crypto::cn_fast_hash("sdssdsffdss", 10);
//   std::vector<crypto::hash> scratchpad;
//   size_t count = 500000000 / 32;
//   TIME_MEASURE_START_MS(gen_time);
//   LOG_PRINT_L0("Generating....");
//   crypto::generate_scratchpad_light(seed, scratchpad, count);
//   TIME_MEASURE_FINISH_MS(gen_time);
//   LOG_PRINT_L0("Generated scratchpad " << (scratchpad.size() * 32) / (1024 * 1024) << "MB in " << gen_time << "ms");
// }
// 
// 
// void measure_keccak_over_scratchpad(uint64_t start_scratchpad_size, uint64_t step_size)
// {
// //  std::cout << std::setw(20) << std::left << "sz\t" <<
//     //std::setw(10) << "original\t" <<
// //    std::setw(10) << "original opt\t" <<
// //    std::setw(10) << "w2\t" << 
// //    std::setw(10) << "w2_opt" << ENDL;
// 
//   std::vector<crypto::hash> scratchpad_vec;
//   scratchpad_vec.resize(max_measere_scratchpad);
//   std::string has_str = "Keccak is a family of sponge functions. The sponge function is a generalization of the concept of cryptographic hash function with infinite output and can perform quasi all symmetric cryptographic functions, from hashing to pseudo-random number generation to authenticated encryption";
// 
//   for (size_t j = 0; j != scratchpad_vec.size(); j++)
//     scratchpad_vec[j] = crypto::rand<crypto::hash>();
// 
//   for (uint64_t i = start_scratchpad_size; i < max_measere_scratchpad; i += i/10)
//   {
// 
//     crypto::hash res_h = currency::null_hash;
//     uint64_t ticks_a = epee::misc_utils::get_tick_count();
//     *(uint64_t*)(&has_str[8]) = i;
// 
//     uint64_t ticks_b = epee::misc_utils::get_tick_count();
//     for (size_t r = 0; r != measere_rounds; r++)
//     {
//       *(size_t*)(&has_str[1]) = r;
//       crypto::get_wild_keccak(has_str, res_h, 1, scratchpad_vec, i);
//     }
// 
//     //wild keccak 2
//     uint64_t ticks_c = epee::misc_utils::get_tick_count();
//     for (size_t r = 0; r != measere_rounds; r++)
//     {
//       *(size_t*)(&has_str[1]) = r;
//       res_h = crypto::cn_fast_hash(has_str.data(), has_str.size());
//     }
//     //wild keccak 2 opt
//     uint64_t ticks_d = epee::misc_utils::get_tick_count();
//     for (size_t r = 0; r != measere_rounds; r++)
//     {
//       crypto::get_wild_keccak2(has_str, res_h, scratchpad_vec, i);
//     }
// 
//     uint64_t ticks_e = epee::misc_utils::get_tick_count();
//     std::cout << std::setw(20) << std::left << i * sizeof(crypto::hash) << "\t" <<
//       //std::setw(10) << ticks_b - ticks_a << "\t" <<
//       //std::setw(10) << ticks_c - ticks_b << "\t" <<
//       std::setw(10) << ticks_d - ticks_c << "\t" <<
//       std::setw(10) << ticks_e - ticks_d << ENDL;
//   }
// }
// 
// void measure_keccak_over_scratchpad()
// {
//   //measure_keccak_over_scratchpad(100/32, 100/32);
//   //measure_keccak_over_scratchpad(10, max_measere_scratchpad / 10);
//   measure_keccak_over_scratchpad(max_measere_scratchpad/10, 0);
// }