#include <cmath>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <unistd.h>

#include <cryptopp/base32.h>
#include <cryptopp/hex.h>
#include <cryptopp/hmac.h>
#include <cryptopp/osrng.h>

using namespace std;

// CLASSES

class OTPGenerator {
public:
  virtual unsigned long generate(const CryptoPP::SecByteBlock &key, const CryptoPP::Integer &input) const = 0;
};

int ipow(int base, int exp) {
  int result = 1;
  while (exp) {
    if (exp & 1)
      result *= base;
    exp >>= 1;
    base *= base;
  }

  return result;
}

class HOTP : public OTPGenerator {
private:
  unsigned int code_digits;

  unsigned long bytesToInt(const string &bytes) const {
    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;
  }

  unsigned long truncate(const string &mac) const {
    uint8_t offset = static_cast<uint8_t >(mac[19]) & static_cast<uint8_t>(0x0f);
    string  offsetBytes = mac.substr(offset, 4);
    return bytesToInt(offsetBytes) & 0x7fffffff;
  }

public:
  HOTP(unsigned int digits):
    code_digits(digits)
  {}

  virtual unsigned long generate(const CryptoPP::SecByteBlock &key, const CryptoPP::Integer &counter) const override {
    string mac;

    CryptoPP::SecByteBlock counter_bytes(8);
    // Do I know that 8 is sufficient here? . . .
    counter.Encode(counter_bytes.BytePtr(), 8, CryptoPP::Integer::UNSIGNED);

    CryptoPP::HMAC<CryptoPP::SHA1> hmac(key, key.size());

    CryptoPP::StringSink  *stringSink = new CryptoPP::StringSink(mac);
    CryptoPP::HashFilter  *hashFilter = new CryptoPP::HashFilter(hmac, stringSink);
    CryptoPP::StringSource ss2(counter_bytes, counter_bytes.size(), true, hashFilter);

    unsigned long result = truncate(mac);

    result = result % ipow(10, code_digits);
    return result;
  }

};

class TOTP : public HOTP {
private:
  unsigned int time_step_size;

  time_t time_step(const time_t time, const int step = 30) const {
    // Time is > 0 so division produces the result we want.
    return time / step;
  }

public:
  TOTP(unsigned int step, unsigned int digits):
    time_step_size(step), HOTP(digits)
  {}

  virtual unsigned long generate(const CryptoPP::SecByteBlock &key, const CryptoPP::Integer &time) const override {
    CryptoPP::Integer current_step = time_step(time.ConvertToLong(), time_step_size);
    return HOTP::generate(key, current_step);
  }
};

// Frontend

CryptoPP::SecByteBlock generate_key(unsigned int size) {
  CryptoPP::AutoSeededRandomPool prng;

  CryptoPP::SecByteBlock key(size);
  prng.GenerateBlock(key, key.size());
  return key;
}

time_t get_time() {
  time_t theTime = time(0);
  if (theTime == static_cast<time_t>(-1)) {
    std::cerr << "time() failed..." << endl;
  }
  return theTime;
}

typedef std::function<std::string(const CryptoPP::SecByteBlock&)> byte_encoder;
typedef std::function<time_t()> time_cb;

std::string base32_encode(const CryptoPP::SecByteBlock string) {
  std::string encoded;

  CryptoPP::StringSink  *stringSink = new CryptoPP::StringSink(encoded);
  CryptoPP::Base32Encoder  *base32Encoder = new CryptoPP::Base32Encoder(stringSink);

  const byte ALPHABET[32+1] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
  CryptoPP::AlgorithmParameters params = CryptoPP::MakeParameters(CryptoPP::Name::EncodingLookupArray(),(const byte *)ALPHABET);
  base32Encoder->IsolatedInitialize(params);


  CryptoPP::StringSource ss1(string, string.size(), true, base32Encoder);
  return encoded;
}

void deterministic_main(
    const CryptoPP::SecByteBlock& key,
    const time_t theTime,
    const byte_encoder key_encoder,
    const OTPGenerator& code_generator
) {
  try {
    std::cout << "key: " << std::setw(41) << key_encoder(key) << std::endl;

    unsigned long result = code_generator.generate(key, theTime);

    cout << setw(46) << setfill('-') << "-" << endl << setfill(' ');
    cout << "code: " << setw(34) << " " << setw(6) << setfill('0') << result << endl << setfill(' ');
  } catch (const CryptoPP::Exception &e) {
    std::cerr << e.what() << endl;
    exit(1);
  }

}
    

int main() {
  unsigned int digits = 6;
  unsigned int time_step = 30;
  unsigned int key_size = 16;
  CryptoPP::SecByteBlock key = generate_key(key_size);
  time_t theTime = get_time();
  TOTP code_generator = TOTP(time_step, digits);

  deterministic_main(key, theTime, base32_encode, code_generator);
  return 0;
}