#include <stdio.h>
 #include <string>
 #include <sstream>
 #include <iomanip>
 #include <iostream>
 #include <string.h>
 #include <time.h>
 
 #include <openssl/hmac.h>
 #include <openssl/evp.h>
 
 namespace {
   // done
   unsigned long bytesToInt(const std::string &bytes) {
     unsigned long result = 0;
     auto          byteCount = bytes.size() - 1;
     for (auto byte = bytes.cbegin(); byte < bytes.cend(); byte++, byteCount--) {
       const uint8_t val = static_cast<uint8_t>(*byte);
       result |= val << (byteCount * 8);
     }
     return result;
   }
 
   //done
   int ipow(int base, int exp) {
     int result = 1;
     while (exp) {
       if (exp & 1) {
         result *= base;
       }
       exp >>= 1;
       base *= base;
     }
 
     return result;
   }
 
   //done
   unsigned char *timeToBytes(unsigned long long time, unsigned char *data, size_t data_size) {
     for (int idx = data_size - 1; idx > -1; idx--) {
       unsigned char next_digit = time & 0xff;
       data[idx] = next_digit;
       time >>= 8;
     }
 
     return data;
   }
 
   //done
   unsigned long truncate(const std::string &mac) {
     uint8_t offset = static_cast<uint8_t >(mac[19]) & static_cast<uint8_t>(0x0f);
     std::string  offsetBytes = mac.substr(offset, 4);
     return bytesToInt(offsetBytes) & 0x7fffffff;
   }
 
   std::string hotp(const std::string &key, const unsigned char *data, size_t data_size, const int digits=6) {
   }
   
   std::string generate_token(const std::string &key, const int digits=6) {
     //done
     time_t time_chunk = ::time(nullptr) / 30;
 
     unsigned char data[8] = {0,0,0,0,0,0,0,0};
     timeToBytes(time_chunk, data, 8);
 
     return hotp(key, data, 8, digits);
   }
 }
 
 int main() 
 {
   char key[5] = "\x00\x00\x00\x00";
   std::cout << generate_token(std::string(key, 5)) << std::endl;;
 
   return 0;
 }