#include <iostream>
#include <string>
#include "yespower.h"
#include <vector>
#include <array>
#include <ctime>
#include <cstring>
#include <iomanip>
#include <thread>
#include <atomic>
#include <mutex>

yespower_params_t yespower_params = { .version = YESPOWER_1_0, .N = 2048, .r = 16 };

using uint256 = std::array<uint8_t, 32>;

uint256 CalculateMerkleRoot(const std::string &genesisMessage, const std::string &publicKey) {
    uint256 merkleRoot = {};
    std::string combined = genesisMessage + publicKey;
    std::hash<std::string> hasher;
    size_t hash = hasher(combined);
    memcpy(merkleRoot.data(), &hash, sizeof(hash));
    return merkleRoot;
}

struct CBlockHeader {
    uint32_t nTime;
    uint32_t nBits;
    uint32_t nNonce;
    uint256 hashMerkleRoot;

    std::string Serialize() const {
        std::ostringstream ss;
        ss << nTime << nBits << nNonce;
        for (const auto &byte : hashMerkleRoot) {
            ss << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
        }
        return ss.str();
    }
};

class arith_uint256 {
    uint64_t value = 0;

public:
    void SetCompact(uint32_t nBits) {
        value = nBits;
    }

    bool operator<=(const arith_uint256 &other) const {
        return value <= other.value;
    }

    std::string GetHex() const {
        std::ostringstream ss;
        ss << std::hex << value;
        return ss.str();
    }
};

std::atomic<bool> found(false);
std::mutex printMutex;

void MineThread(CBlockHeader genesisBlock, arith_uint256 hashTarget, int threadID, int numThreads) {
    uint256 resultHash = {};
    uint32_t nonce = threadID;

    while (!found) {
        genesisBlock.nNonce = nonce;

        std::string serializedHeader = genesisBlock.Serialize();
        yespower_tls(reinterpret_cast<const uint8_t *>(serializedHeader.c_str()),
                     serializedHeader.size(),
                     &yespower_params,
                     reinterpret_cast<yespower_binary_t *>(resultHash.data()));

        arith_uint256 newhash;
        memcpy(&newhash, resultHash.data(), sizeof(newhash));

        if (newhash <= hashTarget) {
            found = true;
            std::lock_guard<std::mutex> lock(printMutex);
            std::cout << "\nGenesis Block Found by Thread " << threadID << "!\n";
            std::cout << "Hash: ";
            for (auto byte : resultHash) {
                printf("%02x", byte);
            }
            std::cout << "\nnTime: " << genesisBlock.nTime << "\n";
            std::cout << "nNonce: " << genesisBlock.nNonce << "\n";
            std::cout << "Merkle Root: ";
            for (auto byte : genesisBlock.hashMerkleRoot) {
                printf("%02x", byte);
            }
            std::cout << "\n";
            break;
        }

        nonce += numThreads;
    }
}

void MineGenesis() {
    const uint32_t nBits = 0x1e00ffff;
    const std::string genesisMessage = "One coin to rule them all One coin to find them One coin to bring them And in the darkness bind them";
    const std::string publicKey = "043056301006072a8648ce3d020106052b8104000a034200042d23252e243d07ee9a6bcf82200b6f98748a90323b36513ea3f62165d75b12f4269cb91e3c0a01572ab64997e62615e9b25ac97413eccabb2391eebc4c633dd7";

    CBlockHeader genesisBlock;
    genesisBlock.nTime = std::time(0);
    genesisBlock.nBits = nBits;
    genesisBlock.nNonce = 0;
    genesisBlock.hashMerkleRoot = CalculateMerkleRoot(genesisMessage, publicKey);

    std::cout << "Genesis Block Parameters:\n";
    std::cout << "nTime: " << genesisBlock.nTime << "\n";
    std::cout << "nBits: " << std::hex << nBits << "\n";
    std::cout << "Public Key: " << publicKey << "\n";
    std::cout << "Genesis Message: " << genesisMessage << "\n";

    arith_uint256 hashTarget;
    hashTarget.SetCompact(nBits);

    int maxThreads = std::thread::hardware_concurrency();
    int numThreads = static_cast<int>(maxThreads * 0.8); // Verwende 80% der verfügbaren Threads
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(MineThread, genesisBlock, hashTarget, i, numThreads);
    }

    for (auto &t : threads) {
        t.join();
    }

    if (!found) {
        std::cout << "Genesis Block not found. Adjust parameters and retry.\n";
    }
}

int main() {
    MineGenesis();
    return 0;
}



# create public key with my script

# compile
# g++ -o genesis create_genesis.cpp -lyespower

# start
# ./genesis