// Exemple simplifié en C++
#include <string>
#include <vector>

class TxOut {
public:
    int64_t amount; // Montant en unités de base (e.g., satoshis)
    std::string scriptPubKey; // Script de verrouillage
};

class TxIn {
public:
    std::string prevTxHash; // Hash de la transaction précédente
    uint32_t prevOutIndex; // Index de la sortie dans cette transaction
    std::string scriptSig;  // Script de signature (initialement vide)
    std::string sequence;   // Normalement 0xFFFFFFFF
};

class Transaction {
public:
    uint32_t version; // Version du protocole (e.g., 1)
    std::vector<TxIn> inputs;
    std::vector<TxOut> outputs;
    uint32_t locktime; // Heure de verrouillage

    // Méthode pour calculer l'identifiant (hash) de cette transaction
    std::string getHash() const {
        // Sérialiser la transaction (sans les scriptsSig pour le hash de commitment)
        std::string serialized = serialize(*this);
        return doubleSHA256(serialized); // SHA256(SHA256(data))
    }
};

class BlockHeader {
public:
    uint32_t version;       // Version du bloc
    std::string prevBlockHash; // Hash du bloc précédent (lie les blocs)
    std::string merkleRoot;   // Racine de l'arbre de Merkle de toutes les tx
    uint32_t timestamp;     // Heure Unix en secondes
    uint32_t bits;          // Cible de difficulté encodée en compact format
    uint32_t nonce;         // Nombre utilisé pour le PoW

    // Méthode pour sérialiser l'en-tête pour le minage
    std::string serialize() const {
        // Concaténer tous les champs dans l'ordre précis
        return ...;
    }
};

class Block {
public:
    BlockHeader header;
    std::vector<Transaction> transactions;

    // Méthode pour calculer le hash du bloc (hash de l'en-tête sérialisé)
    std::string getHash() const {
        std::string headerData = header.serialize();
        return doubleSHA256(headerData);
    }

    // Méthode pour construire l'arbre de Merkle
    void computeMerkleRoot() {
        std::vector<std::string> merkleTree;
        // Hacher chaque transaction
        for (const auto& tx : transactions) {
            merkleTree.push_back(tx.getHash());
        }
        //... Calcul récursif des hachages des paires jusqu'à la racine
        // header.merkleRoot = résultat final;
    }
};

class UTXO {
public:
    std::string txHash;    // Hash de la transaction qui a créé cet output
    uint32_t outIndex;     // Index de l'output dans la transaction
    TxOut output;          // L'output lui-même (montant et scriptPubKey)
};

// La classe Blockchain gérera une map de l'UTXO Set et la liste des blocs.
class Blockchain {
private:
    std::vector<Block> chain; // Chaîne principale (en pratique, on utilise des pointeurs)
    std::unordered_map<std::string, UTXO> utxoSet; // Base de données UTXO clé: txHash+index
    // ... autres états (meilleur hash de bloc, difficulté, etc.)

public:
    bool addBlock(const Block& newBlock);
    bool validateTransaction(const Transaction& tx);
    // ... autres méthodes
};

void mineBlock(Block& block) {
    block.header.timestamp = getCurrentTimestamp();
    block.computeMerkleRoot(); // Calculer la racine de Merkle une fois

    uint32_t target = calculateTargetFromBits(block.header.bits); // Convertir 'bits' en cible

    while (true) { // Boucle de minage
        std::string blockHash = block.getHash(); // Calcule le hash basé sur header.serialize()
        uint256 hashValue(blockHash); // Convertir le hash en un grand nombre entier

        if (hashValue < target) {
            std::cout << "Bloc miné ! Nonce trouvé: " << block.header.nonce << std::endl;
            std::cout << "Hash: " << blockHash << std::endl;
            break; // Succès !
        }

        block.header.nonce++; // Incrémenter le nonce

        // Si le nonce atteint sa limite, changer le timestamp ou le coinbase
        if (block.header.nonce == UINT32_MAX) {
            block.header.timestamp = getCurrentTimestamp();
            block.header.nonce = 0;
            // Potentiellement recalculer le merkleRoot si on change la tx coinbase
        }
    }
}

// Exemple simplifié de gestion de message
void handleMessage(int socket, const std::string& message) {
    std::string magic = message.substr(0, 4);
    std::string command = message.substr(4, 12);
    uint32_t length = decodeUint32(message.substr(16, 4));
    std::string payload = message.substr(20, length);

    if (command == "version") {
        // Traiter le message version
        sendVerackMessage(socket);
    } else if (command == "inv") {
        // Parcourir la liste d'objets inventaire
        // Si c'est un nouveau bloc, envoyer un getdata pour le récupérer
        sendGetDataMessage(socket, inventory);
    } else if (command == "block") {
        Block receivedBlock = deserializeBlock(payload);
        if (validateBlock(receivedBlock)) {
            blockchain.addBlock(receivedBlock);
            // Propager le bloc aux autres pairs
            relayBlock(receivedBlock);
        }
    }
    // ... autres commandes
}

// Pseudocode pour addBlock
bool Blockchain::addBlock(const Block& newBlock) {
    if (!validateBlock(newBlock)) return false;

    std::vector<Transaction> blockTxs = newBlock.transactions;
    std::vector<UTXO> toAdd;
    std::vector<std::string> toRemove; // Clés des UTXO à supprimer

    // Parcourir toutes les tx du nouveau bloc
    for (const auto& tx : blockTxs) {
        // Traiter les inputs (dépenses)
        for (const auto& input : tx.inputs) {
            std::string utxoKey = input.prevTxHash + std::to_string(input.prevOutIndex);
            toRemove.push_back(utxoKey);
        }
        // Traiter les outputs (créations)
        for (uint32_t i = 0; i < tx.outputs.size(); ++i) {
            UTXO newUtxo;
            newUtxo.txHash = tx.getHash();
            newUtxo.outIndex = i;
            newUtxo.output = tx.outputs[i];
            toAdd.push_back(newUtxo);
        }
    }

    // Appliquer les changements ATOMIQUEMENT (dans une transaction DB si possible)
    for (const auto& key : toRemove) {
        db.remove(key);
    }
    for (const auto& utxo : toAdd) {
        std::string key = utxo.txHash + std::to_string(utxo.outIndex);
        db.put(key, serialize(utxo));
    }

    // Ajouter le bloc à la chaîne
    chain.push_back(newBlock);
    return true;
}