/ld26

-- Class: Recorder
-- This records the user's inputs for playback at a later time,
-- or saving to a file. You must start recording *after* all input
-- objects are set up, and you should only run one recorder at a time.
--
-- Extends:
--		<Sprite>

Recorder = Sprite:extend{
	-- private property: elapsed
	-- either time elapsed while recording or playing back, in seconds
	_elapsed = 0,

	-- private property: mousePosTimer
	-- used to make sure mouse motions are recorded even if no other event occurs
	_mousePosTimer = 0,

	-- Constant: IDLE
	-- The recorder is currently doing nothing.
	IDLE = 'idle',

	-- Constant: RECORDING
	-- The recorder is currently recording user input.
	RECORDING = 'recording',

	-- Constant: PLAYING
	-- The recorder is currently playing back user input.
	PLAYING = 'playing',

	-- Property: mousePosInterval
	-- How often, in seconds, we should capture the mouse position.
	-- This records the mouse position when other events occur, too, so
	-- it's possible the interval will be even higher in reality.
	-- Setting this number lower will burn memory.
	mousePosInterval = 0.05,

	-- Property: state
	-- One of the state constants, indicates what the recorder is currently doing.

	-- Property: record
	-- A table of inputs with timing information.

	new = function (self, obj)
		obj = self:extend(obj)
		obj.state = Recorder.IDLE

		Sprite.new(obj)
		return obj
	end,

	-- Method: startRecording
	-- Begins recording user inputs. If the recorder is already recording,
	-- this has no effect.
	--
	-- Arguments:
	--		record - Record to use. Any existing data is appended to.
	--				 If omitted, the current record is used. If the current
	--				 record is unset, this creates a new record.
	--
	-- Returns:
	--		nothing

	startRecording = function (self, record)
		if self.state ~= Recorder.IDLE then return end

		-- set up properties
		self.record = record or self.record or {}
		self.state = Recorder.RECORDING
		self._elapsed = 0
		self._mousePosTimer = 0

		-- insert ourselves into event handlers
		self:stealInputs()
	end,

	-- Method: stopRecording
	-- Stops recording user inputs. If the recorder wasn't recording anyway,
	-- this does nothing.
	-- 
	-- Arguments:
	--		none
	-- 
	-- Returns:
	--		nothing

	stopRecording = function (self)
		if self.state ~= Recorder.RECORDING then return end

		self.state = Recorder.IDLE
		self:restoreInputs()
		love.keypressed = self.origKeyPressed
		love.keyreleased = self.origKeyReleased
	end,

	-- Method: startPlaying
	-- Starts playing back user inputs. If this is already playing
	-- a recording, this restarts it.
	--
	-- Arguments:
	--		record - Record to play back. If omitted, this uses
	--				 the recorder's record property.
	--
	-- Returns:
	--		nothing

	startPlaying = function (self, record)
		record = record or self.record

		-- if we are currently recording, ignore the request

		if self.state == Recorder.RECORDING then return end

		-- restart if needed

		if self.state == Recorder.PLAYING then
			self:stopPlaying()	
		end

		self.state = Recorder.PLAYING 

		self._elapsed = 0
		self.playbackIndex = 1
		self:stealInputs()
	end,

	-- Method: stopPlaying
	-- Stops playing back user inputs.
	--
	-- Arguments:
	--		none
	--
	-- Returns:
	--		nothing

	stopPlaying = function (self)
		if not self.state == Recorder.PLAYING then return end
		self.state = Recorder.IDLE
		self:restoreInputs()
	end,

	stealInputs = function (self)
		local this = self

		self.origKeyPressed = love.keypressed
		love.keypressed = function (key, code) this:recordKeyPress(key, code) end
		self.origKeyReleased = love.keyreleased
		love.keyreleased = function (key, code) this:recordKeyRelease(key, code) end
		self.origMousePressed = love.mousepressed
		love.mousepressed = function (x, y, button) this:recordMousePress(x, y, button) end
		self.origMouseReleased = love.mousereleased
		love.mousereleased = function (x, y, button) this:recordMouseRelease(x, y, button) end
	end,

	restoreInputs = function (self)
		love.keypressed = self.origKeyPressed
		love.keyreleased = self.origKeyReleased
		love.mousepressed = self.origMousePressed
		love.mousereleased = self.origMouseReleased
	end,
	
	recordKeyPress = function (self, key, unicode)
		table.insert(self.record, { self._elapsed, the.mouse.x, the.mouse.y, 'keypress', key, unicode })
		self._mousePosTimer = 0

		if self.origKeyPressed then
			self.origKeyPressed(key, unicode)
		end
	end,

	recordKeyRelease = function (self, key, unicode)
		table.insert(self.record, { self._elapsed, the.mouse.x, the.mouse.y, 'keyrelease', key, unicode })
		self._mousePosTimer = 0

		if self.origKeyReleased then
			self.origKeyReleased(key, unicode)
		end
	end,

	recordMousePress = function (self, x, y, button)
		table.insert(self.record, { self._elapsed, x, y, 'mousepress', button })
		self._mousePosTimer = 0

		if self.origMousePressed then
			self.origMousePressed(x, y, button)
		end
	end,

	recordMouseRelease = function (self, x, y, button)
		table.insert(self.record, { self._elapsed, x, y, 'mouserelease', button })
		self._mousePosTimer = 0

		if self.origMouseReleased then
			self.origMouseReleased(x, y, button)
		end
	end,

	update = function (self, elapsed)
		-- increment timers

		if self.state ~= Recorder.IDLE then
			self._elapsed = self._elapsed + elapsed
		end

		-- record mouse position if the timer has expired

		if self.state == Recorder.RECORDING then
			self._mousePosTimer = self._mousePosTimer + elapsed

			if self._mousePosTimer > self.mousePosInterval then
				table.insert(self.record, { self._elapsed, the.mouse.x, the.mouse.y })

				self._mousePosTimer = 0
			end
		end

		-- handle playback

		if self.state == Recorder.PLAYING and self._elapsed >= self.record[self.playbackIndex][1] then
			local event = self.record[self.playbackIndex]
	
			love.mouse.setPosition(event[2], event[3])

			if event[4] == 'keypress' and self.origKeyPressed then
				self.origKeyPressed(event[5], event[6])
			elseif event[4] == 'keyrelease' and self.origKeyReleased then
				self.origKeyReleased(event[5], event[6])
			elseif event[4] == 'mousepress' and self.origMousePressed then
				self.origMousePressed(event[2], event[3], event[5])
			elseif event[4] == 'mouserelease' and self.origMouseReleased then
				self.origMouseReleased(event[2], event[3], event[5])
			end

			self.playbackIndex = self.playbackIndex + 1

			if self.playbackIndex > #self.record then
				self:stopPlaying()
			end
		end
	end
}