// Copyright 2014 Thom Chiovoloni, released under the MIT license.

/// A random number generator based on the basic implementation of the PCG algorithm,
/// as described here: http://www.pcg-random.org/
var PcgRandom = (function() {
	'use strict';

	var defaultIncHi = 0x14057b7e;
	var defaultIncLo = 0xf767814f;

	/// Construct a random number generator.
	function PcgRandom(seedHi, seedLo, incHi, incLo) {
		this.setSeed(seedHi, seedLo, incHi, incLo)
	}

	/// Set the seed and incrementer.
	PcgRandom.prototype.setSeed = function(seedHi, seedLo, incHi, incLo) {
		if (seedLo == null && seedHi == null) {
			seedLo = (Math.random() * 0xffffffff) >>> 0;
			seedHi = 0;
		}
		else if (seedLo == null) {
			seedLo = seedHi;
			seedHi = 0;
		}
		if (incLo == null && incHi == null) {
			incLo = this.state_ ? this.state_[3] : defaultIncLo;
			incHi = this.state_ ? this.state_[2] : defaultIncHi;
		}
		else if (incLo == null) {
			incLo = incHi;
			incHi = 0;
		}

		this.state_ = new Int32Array([ 0, 0, incHi >>> 0, (incLo|1) >>> 0 ]);
		this.next_();
		add64_(this.state_, this.state_[0], this.state_[1], seedHi>>>0, seedLo>>>0);
		this.next_();
		return this;
	};

	/// Return a copy of the internal state of this random number generator as a JavaScript Array.
	PcgRandom.prototype.getState = function() {
		return [this.state_[0], this.state_[1], this.state_[2], this.state_[3]];
	};

	/// Set the state of the random number generator.
	PcgRandom.prototype.setState = function(state) {
		this.state_[0] = state[0];
		this.state_[1] = state[1];
		this.state_[2] = state[2];
		this.state_[3] = state[3]|1;
	};

	// shim for Math.imul.
	var imul = Math.imul;
	if (!imul) {
		imul = function(a, b) {
			var ah = (a >>> 16) & 0xffff, al = a & 0xffff;
			var bh = (b >>> 16) & 0xffff, bl = b & 0xffff;
			return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0) | 0);
		};
	}

	// multiply two 64 bit numbers (given in parts), and store the result in `out`.
	function mul64_(out, aHi, aLo, bHi, bLo) {
		var c1 = (aLo >>> 16) * (bLo & 0xffff) >>> 0;
		var c0 = (aLo & 0xffff) * (bLo >>> 16) >>> 0;

		var lo = ((aLo & 0xffff) * (bLo & 0xffff)) >>> 0;
		var hi = ((aLo >>> 16) * (bLo >>> 16)) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;

		c0 = (c0 << 16) >>> 0;
		lo = (lo + c0) >>> 0;
		if ((lo >>> 0) < (c0 >>> 0)) {
			hi = (hi + 1) >>> 0;
		}

		c1 = (c1 << 16) >>> 0;
		lo = (lo + c1) >>> 0;
		if ((lo >>> 0) < (c1 >>> 0)) {
			hi = (hi + 1) >>> 0;
		}

		hi = (hi + imul(aLo, bHi)) >>> 0;
		hi = (hi + imul(aHi, bLo)) >>> 0;

		out[0] = hi;
		out[1] = lo;
	}

	// add two 64 bit numbers (given in parts), and store the result in `out`.
	function add64_(out, aHi, aLo, bHi, bLo) {
		var hi = (aHi + bHi) >>> 0;
		var lo = (aLo + bLo) >>> 0;
		if ((lo >>> 0) < (aLo >>> 0)) {
			hi = (hi + 1) | 0;
		}
		out[0] = hi;
		out[1] = lo;
	}

	var MUL_HI = 0x5851f42d >>> 0;
	var MUL_LO = 0x4c957f2d >>> 0;

	/// Generate a random 32 bit integer. This uses the PCG algorithm, described
	/// here: http://www.pcg-random.org/
	PcgRandom.prototype.next_ = function() {
		// save current state (what we'll use for this number)
		var oldHi = this.state_[0] >>> 0;
		var oldLo = this.state_[1] >>> 0;

		// churn LCG.
		mul64_(this.state_, oldHi, oldLo, MUL_HI, MUL_LO);
		add64_(this.state_, this.state_[0], this.state_[1], this.state_[2], this.state_[3]);

		// get least sig. 32 bits of ((oldstate >> 18) ^ oldstate) >> 27
		var xsHi = oldHi >>> 18;
		var xsLo = ((oldLo >>> 18) | (oldHi << 14)) >>> 0;
		xsHi = (xsHi ^ oldHi) >>> 0;
		xsLo = (xsLo ^ oldLo) >>> 0;
		var xorshifted = ((xsLo >>> 27) | (xsHi << 5)) >>> 0;
		// rotate xorshifted right a random amount, based on the most sig. 5 bits
		// bits of the old state.
		var rot = oldHi >>> 27;
		var rot2 = ((-rot >>> 0) & 31) >>> 0;
		return ((xorshifted >>> rot) | (xorshifted << rot2)) >>> 0;
	};

	/// Get a uniformly distributed 32 bit integer between [0, max).
	PcgRandom.prototype.integer = function(max) {
		if (!max) {
			return this.next_();
		}
		max = max >>> 0;
		if ((max & (max - 1)) === 0) {
			return this.next_() & (max - 1); // fast path for power of 2
		}

		var num = 0;
		var skew = ((-max >>> 0) % max) >>> 0;
		for (num = this.next_(); num < skew; num = this.next_()) {
			// this loop will rarely execute more than twice,
			// and is intentionally empty
		}
		return num % max;
	};

	var BIT_53 = 9007199254740992.0;
	var BIT_27 = 134217728.0;

	/// Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
	/// 53 bits of precision (every bit of the mantissa is randomized).
	PcgRandom.prototype.number = function() {
		var hi = (this.next_() & 0x03ffffff) * 1.0;
		var lo = (this.next_() & 0x07ffffff) * 1.0;
		return ((hi * BIT_27) + lo) / BIT_53;
	};

	return PcgRandom;
}());

if (typeof module !== 'undefined' && module.exports) {
	module.exports = PcgRandom;
}