--[[
--
--	Chronos
--		Keeper of Time
--
--	By AnduinLothar, Alexander Brazie, and Thott 
--
--	Chronos manages time. You can schedule a function to be called
--	in X seconds, with or without an id. You can request a timer, 
--	which tracks the elapsed duration since the timer was started. 
--
--  To use as an embeddable addon:
--	- Put the Chronos folder inside your Interface/AddOns/<YourAddonName>/ folder.
--	- Add Chronos\Chronos.xml to your toc or load it in your xml before your localization files.
--	- Add Chronos to the OptionalDeps in your toc
--	
--	To use as an addon library:
--	- Put the Chronos folder inside your Interface/AddOns/ folder.
--	- Add Chronos to the Dependencies in your toc
--
--	Please see below or see http://www.wowwiki.com/Chronos_(addon) for details.
--
--	$LastChangedBy: karlkfi $
--	$Date: 2006-12-21 06:19:14 -0600 (Thu, 21 Dec 2006) $
--	$Rev: 4467 $
--	
--]]

local CHRONOS_REV = 2.12;

local isBetterInstanceLoaded = ( Chronos and Chronos.version and Chronos.version >= CHRONOS_REV );

if (not isBetterInstanceLoaded) then
	
	if (not Chronos) then
		Chronos = {};
	end
	
	Chronos.version = CHRONOS_REV;
	
	------------------------------------------------------------------------------
	--[[ Variables ]]--
	------------------------------------------------------------------------------
	
	Chronos.online = true;
	
	CHRONOS_DEBUG = false;
	CHRONOS_DEBUG_WARNINGS = false;

	-- Chronos Data
	if (not ChronosData) then
		ChronosData = {};
	end
	
	-- Chronos Recycled Tables Storage
	if (not Chronos.tables) then
		Chronos.tables = {};
	end
		
	-- Initialize the Timers
	if (not ChronosData.timers) then
		ChronosData.timers = {};
	end
	
	-- Initialize the perform-over-time task list
	if (not ChronosData.tasks) then
		ChronosData.tasks = {};
	end
		
	-- Maximum items per frame
	Chronos.MAX_TASKS_PER_FRAME = 100;
		
	-- Maximum steps per task
	Chronos.MAX_STEPS_PER_TASK = 300;
	
	-- Maximum time delay per frame
	Chronos.MAX_TIME_PER_STEP = .3;
		
	Chronos.emptyTable = {};
	
	------------------------------------------------------------------------------
	--[[ User Functions ]]--
	------------------------------------------------------------------------------
	
	--[[
	-- debug(boolean)
	-- 
	-- Toggles debug mode
	]]--
	function Chronos.debug(enable)
		if (enable) then
			ChronosFrame:SetScript("OnUpdate", Chronos.OnUpdate_Debug);
			CHRONOS_DEBUG = true;
			CHRONOS_DEBUG_WARNINGS = true;
		else
			ChronosFrame:SetScript("OnUpdate", Chronos.OnUpdate_Quick);
			CHRONOS_DEBUG = false;
			CHRONOS_DEBUG_WARNINGS = false;
		end
	end
	
	--[[
	-- Scheduling functions
	-- Parts rewritten by AnduinLothar for efficiency
	-- Parts rewritten by Thott for speed
	-- Written by Alexander
	-- Original by Thott
	--
	-- Usage: Chronos.schedule(when,handler,arg1,arg2,etc)
	--
	-- After <when> seconds pass (values less than one and fractional values are
	-- fine), handler is called with the specified arguments, i.e.:
	--	 handler(arg1,arg2,etc)
	--
	-- If you'd like to have something done every X seconds, reschedule
	-- it each time in the handler or preferably use scheduleRepeating.
	--
	-- Also, please note that there is a limit to the number of
	-- scheduled tasks that can be performed per xml object at the
	-- same time. 
	--]]
	function Chronos.schedule(when, handler, ...)
		if ( not Chronos.online ) then 
			return;
		end
		if ( not handler) then
			Chronos.printError("ERROR: nil handler passed to Chronos.schedule()");
			return;
		end
				
		--local memstart = collectgarbage("count");
		-- -- Assign an id
		-- local id = "";
		-- if ( not this ) then 
		-- 	id = "Keybinding";
		-- else
		-- 	id = self:GetName();
		-- end
		-- if ( not id ) then 
		-- 	id = "_DEFAULT";
		-- end
		-- if ( not when ) then 
		-- 	Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS", "Chronos Error Detection: ", id , " has sent no interval for this function. ", when );
		-- 	return;
		-- end

		-- -- Ensure we're not looping ChronosFrame
		-- if ( id == "ChronosFrame" and ChronosData.lastID ) then 
		-- 	id = ChronosData.lastID;
		-- end

		-- use recycled tables to avoid excessive garbage collection -AnduinLothar
		--tinsert(ChronosData.sched, Chronos.getTable())
		--local i = #ChronosData.sched
		local recTable = Chronos.getTable()
		-- ChronosData.sched[i].id = id;
		recTable.time = when + GetTime();
		recTable.handler = handler;
		recTable.args = Chronos.getArgTable(...);

		-- task list is a heap, add new
		local i = #ChronosData.sched+1
		while(i > 1) do
			if(recTable.time < ChronosData.sched[i-1].time) then
				i = i - 1;
			else
				break
			end
		end
		tinsert(ChronosData.sched, i, recTable)
		
		-- Debug print
		--Chronos.printDebugError("CHRONOS_DEBUG", "Scheduled "..handler.." in "..when.." seconds from "..id );
		--Chronos.printError("Memory change in schedule: "..memstart.."->"..memend.." = "..memend-memstart);
	end
	

	--[[
	--	Chronos.scheduleByName(name, delay, function, arg1, ... );
	--
	-- Same as Chronos.schedule, except it takes a schedule name argument.
	-- Only one event can be scheduled with a given name at any one time.
	-- Thus if one exists, and another one is scheduled, the first one
	-- is deleted, then the second one added.
	--
	--]]
	function Chronos.scheduleByName(name, when, handler, ...)
		if ( not name ) then 
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No name specified to Chronos.scheduleByName");
			return;
		end
		local namedSchedule = ChronosData.byName[name];
		if(namedSchedule and handler) then
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: scheduleByName is reasigning \"".. name.."\".");
			Chronos.releaseTable(ChronosData.byName[name]);
		else
			if ( not handler ) then
				if ( not namedSchedule ) then
					Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No handler specified to Chronos.scheduleByName, no previous entry found for scheduled entry \"".. name.."\".");
					return;
				end
				if ( not namedSchedule.handler ) then
					Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No handler specified to Chronos.scheduleByName, no handler could be found in previous entry of \"".. name.."\" either.");
					return;
				end
				handler = namedSchedule.handler;
				Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: scheduleByName is updating \"".. name.."\" to time: ".. when);
			else
				Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: scheduleByName is asigning \"".. name.."\".");
			end
		end
		ChronosData.byName[name] = Chronos.getTable();
		namedSchedule = ChronosData.byName[name];
		namedSchedule.time = when+GetTime()
		namedSchedule.handler = handler;
		namedSchedule.args = Chronos.getArgTable(...);
	end

	--[[
	--	unscheduleByName(name);
	--
	--		Removes an entry that was created with scheduleByName()
	--
	--	Args:
	--		name - the name used
	--
	--]]
	function Chronos.unscheduleByName(name)
		if ( not Chronos.online ) then 
			return;
		end
		if ( not name ) then 
			Chronos.printError("No name specified to Chronos.unscheduleByName");
			return;
		end
		if(ChronosData.byName[name]) then
			Chronos.releaseTable(ChronosData.byName[name]);
			ChronosData.byName[name] = nil;
		end
		
		-- Debug print
		--Chronos.printDebugError("CHRONOS_DEBUG", "Cancelled scheduled timer of name ",name);
	end
	
	--[[
	--	unscheduleRepeating(name);
	--		Mirrors unscheduleByName for backwards compatibility
	--]]
	Chronos.unscheduleRepeating = Chronos.unscheduleByName;
	
	--[[
	--	isScheduledByName(name)
	--		Returns the amount of time left if it is indeed scheduled by name!
	--
	--	returns:
	--		number - time remaining
	--		nil - not scheduled
	--
	--]]
	function Chronos.isScheduledByName(name)
		if ( not Chronos.online ) then 
			return;
		end
		if ( not name ) then 
			Chronos.printError("No name specified to Chronos.isScheduledByName "..(self:GetName() or "unknown"));
			return;
		end
		local namedSchedule = ChronosData.byName[name];
		if(namedSchedule) then
			return namedSchedule.time - GetTime();
		end
		
		-- Debug print
		--Chronos.printDebugError("CHRONOS_DEBUG", "Did not find timer of name ",name);
		return nil;
	end
	
	--[[
	--	isScheduledRepeating(name)	
	--		Mirrors isScheduledByName for backwards compatibility
	--]]
	Chronos.isScheduledRepeating = Chronos.isScheduledByName;
	
	--[[
	--	Chronos.scheduleRepeating(name, delay, function);
	--
	-- Same as Chronos.scheduleByName, except it repeats without recalling and takes no arguments.
	--
	--]]
	function Chronos.scheduleRepeating(name, when, handler)
		if ( not name ) then 
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No name specified to Chronos.scheduleRepeating");
			return;
		end
		local namedSchedule = ChronosData.byName[name];
		if(namedSchedule and handler) then
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: scheduleRepeating is reasigning ".. name);
			Chronos.releaseTable(ChronosData.byName[name]);
		else
			if ( not handler ) then
				if ( not namedSchedule ) then
					Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No handler specified to Chronos.scheduleRepeating, no previous entry found for scheduled entry '".. name.."'.");
					return;
				end
				if ( not namedSchedule.handler ) then
					Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No handler specified to Chronos.scheduleRepeating, no handler could be found in previous entry '".. name.."' either.");
					return;
				end
				handler = namedSchedule.handler;
				Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: scheduleRepeating is updating '".. name.."' to time: ".. when);
			else
				Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: scheduleRepeating is asigning '".. name.."'.");
			end
		end
		ChronosData.byName[name] = Chronos.getTable();
		namedSchedule = ChronosData.byName[name];
		namedSchedule.time = when+GetTime();
		namedSchedule.period = when;
		namedSchedule.handler = handler;
		namedSchedule.repeating = true;
	end
	
	--[[
	--	Chronos.flushByName(name, when);
	--
	-- Updates the ByName or Repeating event to flush at the time specified.  If no time is specified flush will be immediate. If it is a Repeating event the timer will be reset.
	--
	--]]
	function Chronos.flushByName(name, when)
		if ( not name ) then 
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: No name specified to Chronos.flushByName");
			return;
		elseif ( not ChronosData.byName[name] ) then
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos Error Detection: no previous entry found for Chronos.flushByName entry '".. name.."'.");
			return;
		end
		if (not when) then
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: flushing '".. name.."'.");
			when = GetTime();
		else
			Chronos.printDebugError("CHRONOS_DEBUG_WARNINGS","Chronos: flushing '".. name.."' in "..when.." seconds.");
			when = when+GetTime();
		end
		ChronosData.byName[name].time = when;
	end

	--[[
	--	Chronos.startTimer([ID]);
	--		Starts a timer on a particular
	--
	--	Args
	--		ID - optional parameter to identify who is asking for a timer.
	--		
	--		If ID does not exist, self:GetName() is used. 
	--
	--	When you want to get the amount of time passed since startTimer(ID) is called, 
	--	call getTimer(ID) and it will return the number in seconds. 
	--
	--]]
	function Chronos.startTimer( id ) 
		if ( not Chronos.online ) then 
			return;
		end

		if ( not id ) then 
			id = self:GetName();
		end

		-- Create a table for this id's timers
		if ( not ChronosData.timers[id] ) then
			ChronosData.timers[id] = Chronos.getTable();
		end

		-- Clear out an entry if the table is too big.
		if (#ChronosData.timers[id] > Chronos.MAX_TASKS_PER_FRAME) then
			Chronos.printError("Too many Chronos timers created for id " .. tostring(id));
			return;
		end

		-- Add a new timer entry 
		table.insert(ChronosData.timers[id], GetTime());
	end


	--[[
	--	endTimer([id]);
	-- 
	--		Ends the timer and returns the amount of time passed.
	--
	--	args:
	--		id - ID for the timer. If not specified, then ID will
	--		be self:GetName()
	--
	--	returns:
	--		(Number delta, Number start, Number end)
	--
	--		delta - the amount of time passed in seconds.
	--		start - the starting time 
	--		now - the time the endTimer was called.
	--]]

	function Chronos.endTimer( id ) 
		if ( not Chronos.online ) then 
			return;
		end

		if ( not id ) then 
			id = self:GetName();
		end

		if ( not ChronosData.timers[id] or #ChronosData.timers[id] == 0) then
			return nil;
		end
	
		local now = GetTime();

		-- Grab the last timer called
		local startTime = tremove(ChronosData.timers[id]);

		return (now - startTime), startTime, now;
	end


	--[[
	--	getTimer([id]);
	-- 
	--		Gets the timer and returns the amount of time passed.
	--		Does not terminate the timer.
	--
	--	args:
	--		id - ID for the timer. If not specified, then ID will
	--		be self:GetName()
	--
	--	returns:
	--		(Number delta, Number start, Number end)
	--
	--		delta - the amount of time passed in seconds.
	--		start - the starting time 
	--		now - the time the endTimer was called.
	--]]

	function Chronos.getTimer( id ) 
		if ( not Chronos.online ) then 
			return;
		end

		if ( not id ) then 
			id = self:GetName();
		end

		local now = GetTime();
		if ( not ChronosData.timers[id] or #ChronosData.timers[id] == 0) then
			return 0, 0, now;
		end
	
		-- Grab the last timer called
		local startTime = ChronosData.timers[id][#ChronosData.timers[id]];

		return (now - startTime), startTime, now;
	end
	
	--[[
	--	isTimerActive([id])
	--		returns true if the timer exists. 
	--		
	--	args:
	--		id - ID for the timer. If not specified, then ID will
	--		be self:GetName()
	--
	--	returns:
	--		true - exists
	--		false - does not
	--]]
	function Chronos.isTimerActive( id ) 
		if ( not Chronos.online ) then 
			return;
		end

		if ( not id ) then 
			id = self:GetName();
		end

		-- Create a table for this id's timers
		if ( not ChronosData.timers[id] ) then
			return false;
		end

		return true;
	end

	--[[
	--	getTime()
	--
	--		returns the Chronos internal elapsed time.
	--
	--	returns:
	--		(elapsedTime)
	--		
	--		elapsedTime - time in seconds since Chronos initialized
	--]]	
	function Chronos.getTime() 
		return ChronosData.elapsedTime;
	end
	
	--[[
	--	Chronos.afterInit(func, ...)
	--		Performs func after the game has truely started.
	--	By Thott
	--]]
	function Chronos.afterInit(func, ...)
		local id;
		if(this) then
			id = self:GetName();
		else
			id = "unknown";
		end
		--if(id == "SkyFrame") then
		--	Chronos.printError("Ignoring Sky init");
		--	return;
		--end
		if(ChronosData.initialized) then
			func(...);
		else
			if(not ChronosData.afterInit) then
				ChronosData.afterInit = Chronos.getTable();
				Chronos.schedule(0.2, Chronos.initCheck);
			end
			local recTable = Chronos.getTable();
			recTable.func = func;
			recTable.args = Chronos.getArgTable(...);
			recTable.id = id;
			tinsert(ChronosData.afterInit, recTable);
		end
	end
	
	
	------------------------------------------------------------------------------
	--[[ Table Recycling ]]--
	------------------------------------------------------------------------------
	
	function Chronos.getTable(...)
		local stack = Chronos.tables;
		if (not stack) then
			Chronos.tables = {};
			stack = Chronos.tables;
			return {};
		end
		local recTable;
		if (#stack >= 1) then
			recTable = tremove(stack)
		else
			recTable = {};
		end
		for i=1, select("#", ...) do
			recTable[i] = select(i, ...);
		end
		return recTable;
	end
	
	-- Release a table to be nilled and used again.
	-- Optionally pass in an unpack(...) as the 2nd arg so that you can return the args:
	-- return Chronos.releaseTable(t1, unpack(t1))
	function Chronos.releaseTable(t1, ...)
		if (type(t1) ~= "table") then
			return;
		end
		
		local stack = Chronos.tables;
		if (not stack) then
			Chronos.tables = {};
			stack = Chronos.tables;
		end
		
		for k,v in pairs(t1) do
			t1[k] = nil;
		end
		
		tinsert(stack, t1);
		return ...;
	end
	
	
	------------------------------------------------------------------------------
	--[[ Helpers Functions ]]--
	------------------------------------------------------------------------------
	
	function Chronos.getArgTable(...)
		if (select('#', ...) == 0) then
			return Chronos.emptyTable;
		else
			return Chronos.getTable(...);
		end
	end
	
	function Chronos.run(func,args)
		if(func) then
			if(args) then
				return func(unpack(args));
			else
				return func();
			end
		end
	end
	
	function Chronos.printError(text)
		ChatFrame1:AddMessage(text, RED_FONT_COLOR.r, RED_FONT_COLOR.g, RED_FONT_COLOR.b, 1.0, UIERRORS_HOLD_TIME);
	end
	
	function Chronos.printDebugError(var, text)
		if (var) and (getglobal(var)) then
			Chronos.printError(text);
		end
	end
	
	------------------------------------------------------------------------------
	--[[ Frame Script Helpers ]]--
	------------------------------------------------------------------------------
	
	function Chronos.chatColorsInit()
		ChronosData.chatColorsInitialized = true;
		ChronosFrame:UnregisterEvent("UPDATE_CHAT_COLOR");
	end
	
	function Chronos.initCheck()
		if(not ChronosData.initialized) then
			if(UnitName("player") and UnitName("player")~=UKNOWNBEING and UnitName("player")~=UNKNOWNBEING and UnitName("player")~=UNKNOWNOBJECT and ChronosData.variablesLoaded and ChronosData.enteredWorld and ChronosData.chatColorsInitialized) then
				ChronosData.initialized = true;
				Chronos.schedule(1,Chronos.initCheck); 
				return;
			else
				Chronos.schedule(0.2,Chronos.initCheck); 
				return;
			end
		end
		if(ChronosData.afterInit) then
			local i = ChronosData.afterInit_i;
			if(not i) then
				i = 1;
			end
			ChronosData.afterInit_i = i+1;
			--Chronos.printError("afterInit: processing ",i," of ",ChronosData.afterInit.n," initialization functions, id: ",ChronosData.afterInit[i].id);
			Chronos.run(ChronosData.afterInit[i].func, ChronosData.afterInit[i].args);
			if(i == #ChronosData.afterInit) then
				for i,v in ipairs(ChronosData.afterInit) do
					Chronos.releaseTable(v);
				end
				Chronos.releaseTable(ChronosData.afterInit);
				ChronosData.afterInit = nil;
				ChronosData.afterInit_i = nil;
			else
				Chronos.schedule(0.1, Chronos.initCheck);
				return;
			end
		end
	end
	
	--[[
	--	Sends a chat command through the standard editbox
	--]]
	function Chronos.SendChatCommand(command)
		local text = ChatFrameEditBox:GetText();
		ChatFrameEditBox:SetText(command);
		ChatEdit_SendText(ChatFrameEditBox);
		ChatFrameEditBox:SetText(text);
	end
	
	function Chronos.RegisterSlashCommands()
		--Needs to be able Variables load if you want to use Sky
		local chronosFunc = function(msg)
			local _,_,seconds,command = string.find(msg,"([%d\.]+)%s+(.*)");
			if(seconds and command) then
				Chronos.schedule(seconds,Chronos.SendChatCommand,command);
			else
				Chronos.printError(SCHEDULE_USAGE1);
				Chronos.printError(SCHEDULE_USAGE2);
			end
		end
		if (Satellite) then
			Satellite.registerSlashCommand(
				{
					id = "Schedule";
					commands = SCHEDULE_COMM;
					onExecute = chronosFunc;
					helpText = SCHEDULE_DESC;
					replace = true;
				}
			);
		else
			SlashCmdList["CHRONOS_SCHEDULE"] = chronosFunc;
			for i = 1, #SCHEDULE_COMM do setglobal("SLASH_CHRONOS_SCHEDULE"..i, SCHEDULE_COMM[i]); end
		end
	end
	
	------------------------------------------------------------------------------
	--[[ Frame Scripts ]]--
	------------------------------------------------------------------------------
	
	function Chronos.OnLoad()
		Chronos.framecount = 0;
		
		if (not ChronosData.byName) then
			ChronosData.byName = {};
		end
		if (not ChronosData.repeating) then
			ChronosData.repeating = {};
		end
		if (not ChronosData.sched) then
			ChronosData.sched = {};
		end
		ChronosData.elapsedTime = 0;
		
		Chronos.afterInit(Chronos.RegisterSlashCommands);
	end
	
	function Chronos.OnEvent(self, event, ...)
		if(event == "ADDON_LOADED") then
			ChronosData.variablesLoaded = true;
			ChronosFrame:Show();
		elseif (event == "PLAYER_ENTERING_WORLD") then
			ChronosData.enteredWorld = true;
			Chronos.online = true;
		elseif (event == "PLAYER_LEAVING_WORLD") then
			Chronos.online = false;
		elseif ( event == "UPDATE_CHAT_COLOR" ) then
			Chronos.scheduleByName("ChronosAfterChatColorInit", 1, Chronos.chatColorsInit);
		end	
	end
	
	function Chronos.OnUpdate_Quick(self, arg1)
		if ( not Chronos.online ) then 
			return;
		end
		if ( not ChronosData.variablesLoaded ) then 
			return;
		end
		
		if ( ChronosData.elapsedTime ) then
			ChronosData.elapsedTime = ChronosData.elapsedTime + arg1;
		else
			ChronosData.elapsedTime = arg1;
		end
		
		-- Execute scheduled tasks that are ready, pulling them off the front of the list queue.
		local now = GetTime();
		local i;
		local task;
		while(#ChronosData.sched > 0) do
			if (not ChronosData.sched[1].time) then
				--Sea.io.printTable(ChronosData.sched[1]);
				tremove(ChronosData.sched, 1);
			elseif(ChronosData.sched[1].time <= now) then
				task = tremove(ChronosData.sched, 1);
				Chronos.run(task.handler, task.args);
				Chronos.releaseTable(task);
			else
				break;
			end
		end
		
		-- Execute named scheduled tasks that are ready.
		local k,v = next(ChronosData.byName);
		local newK, newV;
		while (k ~= nil) do
			newK,newV = next(ChronosData.byName, k);
			if (not v.time) then
				--Sea.io.printTable(v);
				ChronosData.byName[k] = nil;
			elseif (v.time <= now) then
				if (v.repeating) then
					ChronosData.byName[k].time = now + v.period;
					v.handler();
				else
					Chronos.run(v.handler, v.args);
					Chronos.releaseTable(ChronosData.byName[k]);
					ChronosData.byName[k] = nil;
				end
			end
			k,v = newK,newV;
		end
	end
	
	function Chronos.OnUpdate_Debug(self, arg1)
		if ( not Chronos.online ) then 
			return;
		end
		if ( not ChronosData.variablesLoaded ) then 
			return;
		end
		local memstart = collectgarbage("count");
		
		if ( ChronosData.elapsedTime ) then
			ChronosData.elapsedTime = ChronosData.elapsedTime + arg1;
		else
			ChronosData.elapsedTime = arg1;
		end
	
		local now = GetTime();
		local i;
		local task;
		-- Execute scheduled tasks that are ready, popping them off the heap.
		while(#ChronosData.sched > 0) do
			if(ChronosData.sched[1].time <= now) then
				task = tremove(ChronosData.sched, 1);
				Chronos.run(task.handler, task.args);
				Chronos.releaseTable(task);
			else
				break;
			end
		end
		
		local memend = collectgarbage("count");
		if(memend - memstart > 0) then
			Chronos.printError("gcmemleak from ChronosData.sched in OnUpdate: "..(memend - memstart));
		end
		
		-- Execute named scheduled tasks that are ready.
		memstart = memend;
		local k,v = next(ChronosData.byName);
		local newK, newV;
		while (k ~= nil) do
			newK,newV = next(ChronosData.byName, k);
			if(v.time <= now) then
				local m = collectgarbage("count");
				if (v.repeating) then
					ChronosData.byName[k].time = now + v.period;
					v.handler();
				else
					Chronos.run(v.handler, v.args);
					Chronos.releaseTable(ChronosData.byName[k]);
					ChronosData.byName[k] = nil;
				end
				local mm = collectgarbage("count");
				memstart = memstart + mm - m;
			end
			k,v = newK,newV;
		end
		
		memend = collectgarbage("count");
		if(memend - memstart > 0) then
			Chronos.printError("gcmemleak from ChronosData.byName in OnUpdate: "..(memend - memstart));
		end
	end
	
	------------------------------------------------------------------------------
	--[[ Frame Script Assignment ]]--
	------------------------------------------------------------------------------
	
    Chronos.OnUpdate_Quick();
    
	--Event Driver
	if (not ChronosFrame) then
		CreateFrame("Frame", "ChronosFrame");
	end
	ChronosFrame:Hide();
	--Event Registration
	ChronosFrame:RegisterEvent("ADDON_LOADED");
	ChronosFrame:RegisterEvent("PLAYER_ENTERING_WORLD");
	ChronosFrame:RegisterEvent("PLAYER_LEAVING_WORLD");
	ChronosFrame:RegisterEvent("UPDATE_CHAT_COLOR");
	--Frame Scripts
	ChronosFrame:SetScript("OnEvent", Chronos.OnEvent);
	ChronosFrame:SetScript("OnUpdate", Chronos.OnUpdate_Quick);
	--OnLoad Call
	Chronos.OnLoad();
	
end

