#include <fstream>
#include <vector>
#include <sha.h>
#include <hex.h>
#include <randpool.h>

using byte = unsigned char;
using ByteArray = std::vector<byte>; //ДОЛГО, но не надо парить мозги

#define OPAD 0x5C
#define IPAD 0x36
#define BITMASK 0x1F
#define KEYSCOUNT 1000


ByteArray StringToByteArray(std::string str)
{
    ByteArray byteArray(str.size());
    for (int i = 0; i < str.size(); i++)
    {
        byteArray[i] = static_cast<byte>(str[i]);
    }
    return byteArray;
}

ByteArray CArrayToByteArray(byte* bytePtr, size_t length)
{
    ByteArray byteArray(length);
    for (int i = 0; i < length; i++)
    {
        byteArray[i] = bytePtr[i];
    }
    return byteArray;
}

ByteArray Sha256(ByteArray data)
{
    CryptoPP::SHA256 hash;
    byte digest[CryptoPP::SHA256::DIGESTSIZE];
    hash.CalculateDigest(digest, data.data(), data.size());
    return CArrayToByteArray(digest, CryptoPP::SHA256::DIGESTSIZE);
}

ByteArray HmacSha256(ByteArray key, ByteArray data)
{
    if (key.size() > CryptoPP::SHA256::BLOCKSIZE)
        key = Sha256(key);
    if (key.size() < CryptoPP::SHA256::BLOCKSIZE)
        key.insert(key.end(), CryptoPP::SHA256::BLOCKSIZE - key.size(), 0x0);

    ByteArray firstOperand = key;
    ByteArray secondOperand = key;

    for (int i = 0; i < CryptoPP::SHA256::BLOCKSIZE; i++)
    {
        firstOperand[i] ^= OPAD;
        secondOperand[i] ^= IPAD;
    }

    secondOperand.insert(secondOperand.end(), data.begin(), data.end());
    secondOperand = Sha256(secondOperand);
    firstOperand.insert(firstOperand.end(), secondOperand.begin(), secondOperand.end());
    ByteArray hmac = Sha256(firstOperand);
    return hmac;
}

ByteArray HkdfExtract(ByteArray xts, ByteArray skm)
{
    return HmacSha256(xts, skm);
}

ByteArray HkdfExpand(ByteArray prk, ByteArray lastKey, ByteArray ctx, int i)
{
    lastKey.insert(lastKey.end(), ctx.begin(), ctx.end());
    lastKey.push_back(i);
    return HmacSha256(prk, lastKey);
}

ByteArray Pbkdf2(ByteArray p, ByteArray s, int c, int keyLen)
{
    int len = keyLen / CryptoPP::SHA256::DIGESTSIZE;
    ByteArray key;
    CryptoPP::RandomPool prng;
    byte output[CryptoPP::SHA256::DIGESTSIZE];
    for (int i = 0; i < len; i++)
    {
        ByteArray u(CryptoPP::SHA256::DIGESTSIZE, 0);
        prng.GenerateBlock(output, CryptoPP::SHA256::DIGESTSIZE);
        ByteArray xts = CArrayToByteArray(output, 32);
        ByteArray _i(sizeof(i), 0);
        for (int l = 0; l < _i.size(); l++)
            _i[l] = (i >> (8 * l)) & 0xFF;
        xts.insert(xts.end(), _i.begin(), _i.end());
        for (int j = 0; j < c; j++)
        {

            ByteArray new_u = HmacSha256(p, xts);
        }
    }
}

int main()
{
    std::ifstream in("\\weather.json", std::ios::in);
    std::string data;
    std::getline(in, data);
    in.close();

    std::vector<ByteArray> keyArrayHkdf;
    ByteArray ctx = { 'y', 'e', 'r', 's', 'e', 'g' };
    CryptoPP::RandomPool prng;
    byte output[CryptoPP::SHA256::DIGESTSIZE];

    for (int i = 0; i < KEYSCOUNT; i++)
    {
        prng.GenerateBlock(output, CryptoPP::SHA256::DIGESTSIZE);
        ByteArray xts = CArrayToByteArray(output, 32);
        ByteArray prk = HkdfExtract(xts, StringToByteArray(data));
        if (i == 0)
            keyArrayHkdf.push_back(HkdfExpand(prk, { 0x0 }, ctx, i));
        else
            keyArrayHkdf.push_back(HkdfExpand(prk, keyArrayHkdf[i - 1], ctx, i));
    }

    std::ofstream out;
    out.open("keys.txt");

    for (auto i = 0; i < KEYSCOUNT; i++)
    {
        byte key = keyArrayHkdf[i][CryptoPP::SHA256::DIGESTSIZE - 1];
        out << (key & BITMASK);
        out << std::endl;
    }

    out.close();

    return 0;
}