#include "core/system/Precompiled.h"

#include "core/DefaultTask.h"

#include "core/serialization/Serializer.h"
//#include "core/serialization/BinarySerializer.h"
#include "core/serialization/TextSerializer.h"
//#include "core/serialization/XMLSerializer.h"

#include <fstream>

namespace FlowEngine
{
	
	class A;
	class C
	{
	public:
		std::string text;
		A* m_owner;
		int32 dasse;

		C():m_owner(0)
		{
			text = "Ola sua puta rabeta!";
			dasse = 69;
		}

		void Serialize(IArchive& ar, const unsigned int version) 
		{
			ar.Serialize(dasse);
		}
	};

	class A : public Serializer
	{
		typedef Serializer Parent;
	public:		

		virtual void Serialize(IArchive& ar, const unsigned int version) 
		{
			ar.Serialize(dumbi);
		}
			
		int dumbi;
		float dumbf;
		C* testing;

		A():dumbi(12), dumbf(69.69f)
		{ 
			testing = new C();	
			testing->m_owner = this;
		}

		A(int dumb1, float dumb2) : dumbi(dumb1), dumbf(dumb2)
		{ 
			testing = new C();
			testing->m_owner = this;
		}
	};


	class B : public A
	{
		typedef A Parent;
	private:
		int dumbBi;
		float dumbBf;

	public:

		B():dumbBi(9), dumbBf(0.9876f)
		{

		}

		virtual void Serialize(IArchive& ar, const unsigned int version) 
		{
			Parent::Serialize(ar, version);
			ar.Serialize(dumbBi);
		}
	};


	class SilvTask : public DefaultTask
	{
	private:
		typedef DefaultTask Parent;
	
		int dumbi;
		float dumbf;
		A testA;
		A* testAPointer;

		bool m_save, m_xml;
		std::string m_filename;

	public:
		SilvTask():m_save(false), dumbf(69.69f), dumbi(7), m_xml(false),testAPointer(0)
		{			

		}

		int SilvTask::ParseArguments(const std::vector<std::string>& args)
		{
			for(uint32 i = 0; i < (uint32)args.size(); i++)
			{
				if(args[i].find("-xml") != std::string::npos)
					m_xml = true;

				if(args[i].find("-save=") != std::string::npos)
				{
					m_filename = args[i].substr(6);
					m_save = true;
				}
				else if(args[i].find("-load=") != std::string::npos)
				{
					m_filename = args[i].substr(6);
					m_save = false;
				}
			}

			return FE_OK;
		}

		int SilvTask::LoadData()
		{
			//BOOST_CLASS_TRACKING(A, track_never)
			if(m_save)
				WriteObject();
			else
				LoadObject();

			return FE_OK;			
		}

		int SilvTask::WriteObject()
		{
			const A aux(12356, 8956.69f);	
			testAPointer = new A(987, 123.56987f);
			
			
			std::ofstream ofs(m_filename.c_str());
			// create and open a text archive for output
			//boost::archive::text_oarchive oa(ofs);
			TextArchiveO oa(ofs);

			// create and open a binary archive for output						
			//boost::archive::binary_oarchive oa(ofs);
			//BinaryArchiveO oa( ofs);

			// create and open a xml archive for output			
			//boost::archive::xml_oarchive oa(ofs);
			//XMLArchiveO oa(ofs);

			
			//write class instance to archive
			//oa & BOOST_SERIALIZATION_NVP(testAPointer);
			oa & BOOST_SERIALIZATION_NVP(testAPointer);

			return FE_OK;
		}


		int SilvTask::LoadObject()
		{				

			//A aux(0, 0);
			std::ifstream ifs(m_filename.c_str(), std::ios::binary);			
			
			//create and open a character archive for input			
			//boost::archive::text_iarchive ia(ifs);
			TextArchiveI ia(ifs);

			//create and open a binary archive for input
			//boost::archive::binary_iarchive ia(ifs);
			//BinaryArchiveI ia(ifs);

			//create and open a xml archive for input
			//boost::archive::xml_iarchive ia(ifs);
			//XMLArchiveI ia(ifs);

		
			// read class state from archive
			ia & BOOST_SERIALIZATION_NVP(testAPointer);

			//ia & BOOST_SERIALIZATION_NVP(aux);

			return FE_OK;
		}

		int SilvTask::CreateRenderEffects()
		{
			return FE_OK;
		}

		int OnStart(Mutex* mutex)
		{

			return FE_OK;
		}
	};

	int FlowMain(const std::vector<std::string>& cmdLine)
	{
		if(cmdLine.size() < 1)
		{
			FE_LOG_ERROR(FE_INVALIDPARAM, "Please insert the file to read from!");
			return FE_INVALIDPARAM;
		}

		SilvTask* task = new SilvTask();

		int r = task->ParseArguments(cmdLine);
		if (FE_FAILED(r))
		{
			delete task;
			return r;
		}

		FlowCore::GetScheduler().RegisterTask(task, "silver Task", 0, .0f, .0f);

		delete task;
		return FE_OK;
	}
}