<?php
/**
 * Calculates a simple but stronger hash from given string. No salts are being
 * added here.
 *
 * @param	$str	The string to be hashed
 * @return	$hash	The hash from string $str
 */
function hashString ($str) {
	// Calculate strong hash from given string
	$hash = Scrypt::hash($str, $GLOBALS['salt'], $GLOBALS['difficulty']);

	// Return it directly
	return $hash;
}

/**
 * Multiple-hashes given string. This is done by hashing the given string and
 * then hashing the generated hash again.
 *
 * @param	$str	The string to be hashed 4 times
 * @return	$hash	The generated hash
 */
function multipleHashString ($str) {
	// Generate hash from given hash
	$hash = hashString($str);

	// Now over-hash it
	for ($idx = 0; $idx < ($GLOBALS['hash_cycles'] - 1); $idx++) {
		// Over-hash the given hash
		$hash = hashString($hash);
	} // END - for

	// Return it
	return $hash;
}

/**
 * Calculates sum from given hash
 *
 * @param	$hash	Hash to calculate sum from
 * @return	$sum	Sum from given hash
 */
function calculateSumFromHash ($hash) {
	// Everything starts with zero ...
	$sum = 0;

	// Loop through hash
	for ($idx = 0; $idx < (strlen($hash) / 2); $idx++) {
		// And add it
		$sum = $sum + hexdec(substr($hash, $idx, 2));
	} // END - for

	// And return it
	return $sum;
}

/**
 * Calculates new nonce
 *
 * @return	void
 */
function calculateNonce () {
	// Linear incrementation
	$GLOBALS['nonce'] += $GLOBALS['none_increment'];
}

/**
 * Writes/flushes check-point file
 *
 * @param	$hash	Found hash or gensis hash
 * @return	void
 */
function flushCheckPointFile ($hash) {
	// Display message
	print ('FLUSHING: Writing ' . count($GLOBALS['found_hashes']) . ' blocks ...' . PHP_EOL);

	// Start timer
	$timer = microtime(true);

	// Flush data
	file_put_contents(
		CHECKPOINT_FILE,
		$GLOBALS['total_blocks'] . '|' .
		$GLOBALS['total_reward'] . '|' .
		$GLOBALS['total_hashes'] . '|' .
		$GLOBALS['total_found'] . '|' .
		$GLOBALS['total_restarts'] . '|' .
		$GLOBALS['hash_cycles'] . '|' .
		$GLOBALS['salt'] . '|' .
		$GLOBALS['difficulty'] . '|' .
		base64_encode((float) $GLOBALS['nonce']) . '|' .
		$hash . '|' .
		$GLOBALS['root_hash'] . '|' .
		base64_encode(gzcompress(json_encode($GLOBALS['found_hashes'])))
	);

	// Set time
	$GLOBALS['time_flush'] = microtime(true);
	print ('FLUSHING: Took ' . ($GLOBALS['time_flush'] - $timer) . ' seconds.' . PHP_EOL);
}

/**
 * Adds a found hash and flushes the checkpoint file
 *
 * @param	$hash	Hash to save
 */
function addFoundHash ($hash) {
	// Increment counter
	$GLOBALS['total_found']++;

	// Add hash to array
	array_push($GLOBALS['found_hashes'][$GLOBALS['total_blocks']], [
		'current_hash' => $GLOBALS['current_hash'],
		'root_hash'    => $GLOBALS['root_hash'],
		'nonce'        => (float) $GLOBALS['nonce'],
		'iter'         => $GLOBALS['iteration'],
		'hashes_block' => $GLOBALS['hashes_block'],
		'hash_cycles'  => $GLOBALS['hash_cycles'],
		'difficulty'   => $GLOBALS['difficulty'],
		'nonce_hash'   => $hash,
	]);

	// Found hash:
	print ('FOUND: hash=' . $hash . ',nonce=' . $GLOBALS['nonce'] . ',total_found=' . $GLOBALS['total_found'] . PHP_EOL);

	// Set time as a new hash was found
	$GLOBALS['found_time'] = microtime(true);

	// Flush check-point file after new hash is found
	flushCheckPointFile($hash);
}

/**
 * Initializes nonce
 *
 * @return	void
 */
function initNonce () {
	$GLOBALS['nonce'] = 1 / (mt_rand() ^ (1 / pi()));
	print (__FUNCTION__ . ': nonce=' . $GLOBALS['nonce'] . PHP_EOL);
}

/**
 * Sums all hex parts of the hash to one final sum
 *
 * @param	$hash	Hex-hash to sum
 * @return	Sum of hash
 */
function sumHash ($hash) {
	// Init it
	$sum = 0;

	for ($i = 0; $i < (strlen($hash) / 2); $i++) {
		$sum += hexdec(substr($hash, $i, 2));
	}

	return $sum;
}

/**
 * Loads check-point file, if found
 *
 * @return	void
 */
function loadCheckpointFile () {
	// Is the check point there?
	if (is_readable(CHECKPOINT_FILE)) {
		// Then load it
		$checkPoint = file_get_contents(CHECKPOINT_FILE);

		// Explode it
		$data = explode('|', $checkPoint);

		// Assert on count
		assert(count($data) == 10);

		// 1st element is nonce, 2nd hash, 3rd found hashes
		$GLOBALS['total_blocks']   = $data[0];
		$GLOBALS['total_reward']   = $data[1];
		$GLOBALS['total_hashes']   = $data[2];
		$GLOBALS['total_found']    = $data[3];
		$GLOBALS['total_restarts'] = $data[4];
		$GLOBALS['hash_cycles']    = intval($data[5]);
		$GLOBALS['salt']           = $data[6];
		$GLOBALS['difficulty']     = $data[7];
		$GLOBALS['nonce']          = (float) base64_decode($data[8]);
		$GLOBALS['current_hash']   = $data[9];
		$GLOBALS['root_hash']      = $data[9];
		$GLOBALS['found_hashes']   = json_decode(gzuncompress(base64_decode($data[11])), TRUE);
	} // END - if
}