--[[
	Int64 class that is used to handle integer based
	encoding.
	This can be configured to any type, just make sure it is never over
	32 bits(as it is a limitation of roblox's memory allocator)
	@author JESUS
	@submodule Int64
]]

local Int64 = {};
Int64.__index = Int64;

-- purpose: constructor
function Int64.new(bytes)
	return setmetatable({
		_arr = table.create(bytes,0);
		_number = 0;
		_offset = 0;
		_reading = 1;
	}, Int64);
end

-- purpose: clear int arr
function Int64:clear()
	self._reading=1;
	self._offset=0;
	table.clear(self._arr);
end

-- purpose: read buffer
function Int64:read(buffer)
	self._arr=buffer;
	self._number=buffer[1];
	self._offset=0;
	self._reading=1;
end

-- purpose: to bits
local function toBits(num, bits)
	local t={}; -- will contain the bits
	for b=bits,1,-1 do
		local rest=math.fmod(num,2);
		t[b]=rest;
		num=(num-rest)/2;
	end
	if(num==0)then 
		return t;
	end
end

-- purpose: max bit lol
local max_bits=16;
local max_32_bit=bit32.lshift(1,max_bits)-1;
function Int64:set(amnt, value)
	local remaining=max_bits-self._offset;
	if(self._offset==0 and amnt==max_bits)then
		-- maximum bit count lol
		self._arr[self._reading]=bit32.band(value,max_32_bit);
		self._offset=0;
		self._reading+=1;
		return;
	elseif(remaining>=amnt)then
		-- can fit segment
		self._number=bit32.replace(self._number,value,self._offset,amnt);
		self._offset+=amnt;
		
		-- skip if possible
		if((max_bits-self._offset)==0)then
			self._arr[self._reading]=self._number;
			self._reading+=1;
			self._offset=0;
			self._number=0;
		end
	elseif(remaining==0)then
		-- mike
		self._arr[self._reading]=self._number;
		self._reading+=1;
		self._number=bit32.extract(value,0,amnt);
		self._offset=amnt;
	else
		-- have to split up to multiple segments
		local after=amnt-remaining;
		self._arr[self._reading]=bit32.replace(self._number,value,self._offset,remaining);
		self._number=bit32.rshift(value,remaining);--bit32.extract(value,remaining,after);
		self._offset=after;
		self._reading+=1;
	end
end

-- purpose: get bits lol
function Int64:get(amnt)
	local remaining=max_bits-self._offset;
	if(self._offset==0 and amnt==max_bits)then
		-- maximum bit count lol
		self._offset=0;
		self._reading+=1;
		self._number=self._arr[self._reading];
		return self._arr[self._reading-1];
	elseif(remaining>=amnt)then
		-- can fit segment
		local number=bit32.extract(self._number,self._offset,amnt);
		self._offset+=amnt;

		-- skip if possible
		if((max_bits-self._offset)<=0)then
			self._reading+=1;
			self._number=self._arr[self._reading];
			self._offset=0;
		end
		return number;
	elseif(remaining==0)then
		-- edge segment
		self._reading+=1;
		self._number=self._arr[self._reading];
		self._offset=amnt;
		return bit32.extract(self._number,0,amnt);
	else
		-- have to split up to multiple segments
		self._reading+=1;		
		local after=amnt-remaining;
		local other=self._arr[self._reading];
		local number=bit32.extract(self._number,self._offset,remaining);
		self._offset=after;
		self._number=other;
		return bit32.lshift(bit32.extract(other,0,after),remaining)+number;
	end
end

-- purpose: set segs(yea)
function Int64:setSeg(numSegs, value)
	if(numSegs<=2)then
		self:set(max_bits*numSegs,value);
	else
		-- align reader
		local value=self:set(max_bits-self._offset);
		for i=2,numSegs-1 do
			value=bit32.lshift(value,max_bits)+self._arr[self._reading];
			self._reading+=1;
		end
		return value+self:set(max_bits-self._offset);
	end
end

-- purpose: get num segs(yea)
function Int64:getSeg(num)
	if(num<=2)then
		-- no need to align for this one
		return self:get(max_bits*num);
	else
		-- align reader
		local value=self:get(max_bits-self._offset);
		for i=2,num-1 do
			value=bit32.lshift(value,max_bits)+self._arr[self._reading];
			self._reading+=1;
		end
		return value+self:get(max_bits-self._offset);
	end
end

-- purpose: dispose
function Int64:dispose()
	table.insert(self._arr,self._number);
	return self._arr;
end

return Int64;