#include "cement.h"


Cementer cement;
static CCriticalSection cs_cement;


bool Cementer::generate(int start_height, int stop_height, string filename)
{
  // Check that we actually have blocks to this height with safety margin:
  if (stop_height > nBestHeight - SAFE_CEMENT_MARGIN)
    throw runtime_error(strprintf(_("Requested cement exceeds nBestHeight - %d!\n"),
                                  SAFE_CEMENT_MARGIN));
    
  // Open destination cement file
  FILE *fileout = fopen(filename.c_str(), "w");
  if (!fileout)
    throw runtime_error(strprintf(_("Cannot write cement to file: '%s'\n"), filename.c_str()));
  
  // Starting at the genesis:
  int height = 0;
  CBlockIndex *pindex = pindexGenesisBlock;
    
  // Up through the desired height:
  while (height < stop_height) {
    // Get current block height
    height = pindex->nHeight;
        
    // Main-chain blocks strictly, at or above the start height:
    if (pindex->IsInMainChain() && height >= start_height) {
      // Get the block's hash
      uint256 hash = pindex->GetBlockHash();

      // Write block's height and header hash to the cement file
      fprintf(fileout, "%d %s\n", height, hash.ToString().c_str());
    }

    // Advance to next block
    pindex = pindex->pnext;
  }

  fclose(fileout);
  // We're done:
  printf("Cement written to %s.\n", filename.c_str());
  return true;
}


void Cementer::permitCement()
{
  mayLoadCement = true;
}


bool Cementer::cementPermitted()
{
  return mayLoadCement;
}


void Cementer::unload()
{
  CRITICAL_BLOCK(cs_cement)
  {
    entries.clear();
  }
}


bool Cementer::load(string filename)
{
  if (!mayLoadCement)
    throw runtime_error("'loadcement' is only permitted if bitcoind was started with -cement flag!");

  int foundEntries = 0;
  ifstream cementFile(filename.c_str());

  if (cementFile.bad())
    throw runtime_error(strprintf(_("Cannot open cement file: '%s'\n"), filename.c_str()));

  CRITICAL_BLOCK(cs_cement)
  {
    string line;
    while(getline(cementFile, line)) {
      stringstream lineStream(line);
      int height;
      string hexHash;
      lineStream >> height;
      bool validEntry = lineStream.good();
      lineStream >> hexHash;
      int hexHashLen = hexHash.length();
      if (hexHashLen != 64)
        validEntry = false;
      for (size_t i = 0, n = hexHashLen; i < n; ++i) {
        if (!isxdigit(hexHash[i])) validEntry = false;
      }
      // Sanity check: height must always be 1 plus that of prev. entry:
      if (((!entries.empty()) && (height != entries.back().height + 1)) || !validEntry) {
        printf("Invalid cement entry: '%s'\n", line.c_str());
      } else {
        // Entry is valid, add it to current cement:
        uint256 hash = uint256(hexHash);
        CementEntry e;
        e.height = height;
        e.hash = hash;
        entries.push_back(e);
        foundEntries++;
      }
    }
  }
  printf("%d cement entries loaded from %s.\n", foundEntries, filename.c_str());
  return (foundEntries != 0);
}


int Cementer::getCementStart()
{
  CRITICAL_BLOCK(cs_cement)
  {
    if (!entries.empty()) return entries.front().height;
    return 0;
  }
}


int Cementer::getCementEnd()
{
  CRITICAL_BLOCK(cs_cement)
  {
    if (!entries.empty()) return entries.back().height;
    return 0;
  }
}


void Cementer::fastForward(int nHeight)
{
  if (entries.empty()) return;

  // If we're already above the cement, discard all of it:
  if (nHeight > entries.back().height)
    entries.clear();

  // Discard any cement entries below given height:
  while (!entries.empty() && (entries.front().height < nHeight))
    entries.pop_front();
}


bool Cementer::expectCement(int nHeight)
{
  CRITICAL_BLOCK(cs_cement)
  {
    // Discard any exhausted cement:
    fastForward(nHeight);
  
    // If there is no cement:
    if (entries.empty()) return false;

    // True if the current entry's height is the given one:
    return (entries.front().height == nHeight);
  }
}


// Note: must call expectCement(height) first!
uint256 Cementer::getExpected()
{
  CRITICAL_BLOCK(cs_cement)
  {
    return entries.front().hash;
  }
}


bool Cementer::verify(int nHeight, const uint256& hash)
{
  bool result = false;

  CRITICAL_BLOCK(cs_cement)
  {
    // Discard any exhausted cement:
    fastForward(nHeight);

    // If there is no cement loaded:
    if (entries.empty()) return true;

    CementEntry current = entries.front();

    if (current.height > nHeight) {
      // Gap in cement:
      result = true;
      printf("Warning: gap in cement at height %d !\n", nHeight);
    } else {
      // The current cement is of nHeight:
      result = (current.hash == hash);
      printf("Proposed block %s (%d) %s by cement.\n", hash.ToString().c_str(), nHeight,
             result ? "ACCEPTED" : "REJECTED");
    }
  }

  return result;
}