/*******************************************************************************

 Copyright (c) 2009, Charles McGarvey
 All rights reserved.
 
 Redistribution   and   use  in  source  and  binary  forms,  with  or  without
 modification, are permitted provided that the following conditions are met:
 
   * Redistributions  of  source  code  must retain the above copyright notice,
     this list of conditions and the following disclaimer.
   * Redistributions  in binary form must reproduce the above copyright notice,
     this  list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
 THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*******************************************************************************/

#include <map>
#include <vector>

#include "Animation.hh"
#include "Mippleton.hh"
#include "Serializable.hh"


namespace Mf {


/**
 * The collection of nested animation classes.  The animation implementation
 * consists of an Impl class which is allocated and initialized with the
 * interface object.  This class contains the specific fields which are required
 * to run a single instance of an animation.  The sequence data is loaded in a
 * different class which can be shared amongst multiple animation implementation
 * instances.
 */

class Animation::Impl
{
	friend class Animation;

	/**
	 * Contains "global" animation data for the various animations which get
	 * loaded.  This is a mippleton, so it will be shared amongst any animation
	 * which wants to use these loaded sequences.
	 */

	class Data : public Mippleton<Data>
	{
		friend class Impl;
		friend class Mippleton<Data>;

		/**
		 * A frame of an animation sequence.  A frame is merely an index which
		 * presumably represents a "slide" or tile which should be displayed,
		 * and the duration that is how long the slide will be shown.
		 */

		struct Frame
		{
			unsigned	index;					///< Frame index.
			Scalar		duration;				///< Frame duration.

			/**
			 * Construction is initialization.  The frame data is loaded from a
			 * frame map which is probably loaded within an animation file.
			 */
		
			Frame(SerializableP root) :
				index(0),
				duration(1.0)
			{
				Serializable::Map rootObj;

				if (root->get(rootObj))
				{
					Serializable::Map::iterator it;

					for (it = rootObj.begin(); it != rootObj.end(); ++it)
					{
						std::string key = (*it).first;
						if (key == "index")
						{
							long value = 0;
							(*it).second->get(value);
							index = unsigned(value);
						}
						else if (key == "duration")
						{
							double value = 0.0;
							(*it).second->getNumber(value);
							duration = Scalar(value);
						}
					}
				}
			}
		};


		/**
		 * A sequence is just a few attributes and a list of frames in the order
		 * that they should be played.
		 */

		struct Sequence
		{
			std::vector<Frame>	frames;			///< List of frames.
			Scalar				delay;			///< Scale frame durations.
			bool				loop;			///< Does the sequence repeat?
			std::string			next;			///< Next sequence name.

			/**
			 * Construction is initialization.  The constructor loads sequence
			 * data from the sequence map, presumably loaded from an animation
			 * file.  The rest of the loading takes place in the frame's
			 * constructor which loads each individual frame.
			 */

			Sequence(SerializableP root) :
				delay(0.0),
				loop(true)
			{
				Serializable::Map rootObj;

				if (root->get(rootObj))
				{
					Serializable::Map::iterator it;
					for (it = rootObj.begin(); it != rootObj.end(); ++it)
					{
						std::string key = (*it).first;

						if (key == "frames")
						{
							Serializable::Array framesObj;

							if ((*it).second->get(framesObj))
							{
								Serializable::Array::iterator jt;

								for (jt = framesObj.begin();
										jt != framesObj.end(); ++jt)
								{
									if (*jt)
									{
										frames.push_back(Frame(*jt));
									}
								}
							}
						}
						else if (key == "delay")
						{
							double value;
							(*it).second->getNumber(value);
							delay = Scalar(value);
						}
						else if (key == "loop")
						{
							(*it).second->get(loop);
						}
						else if (key == "next")
						{
							(*it).second->get(next);
						}
					}
				}
			}
		};


		/**
		 * Starts loading a file with animation data.  Such a file is formatted
		 * as a map of named sequences.   The sequence constructor loads each
		 * individual sequence.
		 */

		void loadFromFile()
		{
			std::string filePath = Animation::getPath(getName());

			Deserializer deserializer(filePath);

			SerializableP root = deserializer.deserialize();

			if (root)
			{
				Serializable::Map rootObj;

				if (root->get(rootObj))
				{
					Serializable::Map::iterator it;

					for (it = rootObj.begin(); it != rootObj.end(); ++it)
					{
						sequences.insert(std::pair<std::string,Sequence>((*it).first,
									Sequence((*it).second)));
					}
				}
			}
		}

		/**
		 * Construction is initialization.  The animation class data container
		 * registers itself as a mippleton and then loads the animation data.
		 */

		explicit Data(const std::string& name) :
			Mippleton<Data>(name)
		{
			loadFromFile();
		}

		std::map<std::string,Sequence> sequences;		///< List of sequences.
	};


	/**
	 * Construction is intialization.
	 */

	Impl(const std::string& name) :
		data(Data::getInstance(name)),
		currentSequence(0),
		frameCounter(0),
		frameIndex(0),
		timeAccum(0),
		frameDuration(0) {}


	/**
	 * Sets up the animation classes to "play" a named sequence.  If another
	 * sequence was active, it will be replaced as the current sequence.  Future
	 * updates will progress the new sequence.
	 */

	void startSequence(const std::string& name)
	{
		std::map<std::string,Data::Sequence>::iterator it;

		it = data->sequences.find(name);

		if (it != data->sequences.end())
		{
			currentSequence = &(*it).second;
			frameCounter = 0;
			frameIndex = currentSequence->frames[0].index;
			timeAccum = 0.0;
			frameDuration = currentSequence->delay *
				currentSequence->frames[0].duration;
		}
	}

	/**
	 * Updates or progresses the animation sequence.  If the time interval
	 * surpasses the duration of the current frame, a new frame becomes the
	 * current frame.  If the last frame of a sequence expires, the active
	 * sequence will switch automatically to the designated "next" sequence, or
	 * if none is specified but the sequence is set to loop, the first frame of
	 * the sequence will become the current frame, and the animation essentially
	 * starts over again.
	 */

	void update(Scalar t, Scalar dt)
	{
		if (currentSequence)
		{
			timeAccum += dt;

			if (timeAccum >= frameDuration)
			{
				if (++frameCounter >= currentSequence->frames.size())
				{
					if (!currentSequence->next.empty())
					{
						startSequence(currentSequence->next);
					}
					else if (currentSequence->loop)
					{
						frameCounter = 0;
					}
					else
					{
						frameCounter--;
						currentSequence = 0;
					}
				}

				frameIndex = currentSequence->frames[frameCounter].index;
				timeAccum = frameDuration - timeAccum;
				frameDuration = currentSequence->delay *
					currentSequence->frames[frameCounter].duration;
			}
		}
	}

	boost::shared_ptr<Data>	data;				///< Internal data.

	Data::Sequence*			currentSequence;	///< Active sequence.
	unsigned				frameCounter;		///< Current frame.
	unsigned				frameIndex;			///< Index of current frame.
	Scalar					timeAccum;			///< Time accumulation.
	Scalar					frameDuration;		///< Scaled frame duration.
};


Animation::Animation(const std::string& name) :
	// pass through
	impl_(new Animation::Impl(name)) {}


void Animation::startSequence(const std::string& name)
{
	// pass through
	impl_->startSequence(name);
}

void Animation::update(Scalar t, Scalar dt)
{
	// pass through
	impl_->update(t, dt);
}


/**
 * Gets the index for the current frame.  This is presumably called by some
 * drawing code which will draw the correct current frame.
 */

unsigned Animation::getFrame() const
{
	return impl_->frameIndex;
}


/**
 * Specialized search location for animation files.  They can be found in the
 * "animations" subdirectory of any of the searched directories.
 */

std::string Animation::getPath(const std::string& name)
{
	return Resource::getPath("animations/" + name + ".json");
}


} // namespace Mf

/** vim: set ts=4 sw=4 tw=80: *************************************************/