#include <iostream>
#include <cstdio>
#include <fstream>
#include <chrono>
#include <random>

unsigned UserID = 0;
std::mt19937 rnd(time(NULL));
std::fstream input;

template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }

struct AccountInfo
{
    unsigned ID;
    std::string login, password;
    unsigned long Hash, Salt;
};
// TODO:
namespace utils
{
    template<typename T>
    void Save(T data, char* filename)
    {
        input.open(filename, std::ios::out | std::ios::binary | std::ios::app);
        input<<std::hex<<data<<'\n';
    }
    // The same function but with argument overloading
    template<typename T, typename...Args>
    void Save(T data, char* filename, Args... args)
    {
        input.open(filename, std::ios::out | std::ios::binary | std::ios::app);
        input<<std::hex<<data<<'\n';
        Save(args...);
    }
    template<typename T>
    void Read(T data, char* filename)
    { // The Data needs to be read and processed in the block form which is
         /* I = UserID, H = Hash, L = Login
          * I*4 + H*24 + L*24 */
        input.open(filename, std::ios::in | std::ios::binary);
        std::string line;
        while(std::getline(input, line))
        {
            std::istringstream iss(line);
            if(!(iss>>data)) { break; }
        }
        unsigned char PID[4];
        for(int i = 0; i<arraysize(PID); ++i)
        { PID[i] = line[i]; }
        unsigned char PHASH[24];
        for(int j = 4; j<(arraysize(PHASH)+j); ++j)
            { PHASH[j] = line[j]; }
        unsigned char PLOGIN[24];
        for(int k = 28; k<(arraysize(PLOGIN)+k); ++k)
            { PLOGIN[k] = line[k]; }
    }
    template<typename T, typename... Args>
    void Read(T data, Args... args, char* filename)
    {
        input.open(filename, std::ios::in | std::ios::binary);
        std::string line;
        while(std::getline(input, line))
        {
            std::istringstream iss(line);
            if(!(iss>>data)) { break; }
        }
        unsigned char PID[4];
        for(int i = 0; i<arraysize(PID); ++i)
        { PID[i] = line[i]; }
        unsigned char PHASH[24];
        for(int j = 4; j<(arraysize(PHASH)+j); ++j)
            { PHASH[j] = line[j]; }
        unsigned char PLOGIN[24];
        for(int k = 28; k<(arraysize(PLOGIN)+k); ++k)
            { PLOGIN[k] = line[k]; }
        Read(args...);
    }
};
class Register
{
    AccountInfo reg_user;
public:
    void MakeUser();
};
class Login
{

};
class Info
{
    AccountInfo user;
    unsigned SaltResult = utils::Read(user.Salt, "C:\\Database.txt"), HashResult = utils::Read(user.Hash, "C:\\Database.txt");
public:
    unsigned long MakeSalt(const std::string& UserLogin, unsigned UID)
    {
        UserLogin = utils::Read(user.login);
        UID = Read(user.ID);
        unsigned sum = 0;
        for(unsigned i = UID; i<(UserLogin[i]+ID); ++i)
        {
            sum+=static_cast<unsigned>(UserLogin[i]);
            SaltResult+=(sum+rnd())%UserLogin.size();
        }
        return SaltResult;
    }
    #define HASH_SIZE 24
    unsigned long MakeHash(unsigned SaltResult, unsigned UID)
    {
        for(int pos = UID; pos<HASH_SIZE+UID; ++pos)
            HashResult+=SaltResult%(UID+pos);
        return HashResult;
    };
    #undef HASH_SIZE
};

int main()
{
    return 0;
}