#include "ViewDrawNotifier.h"
#include <vector>
#include <android/native_window.h> // requires ndk r5 or newer
#include <strings.h>
#include <android/log.h>
#include <unthread.h>
#include <unmutex.h>


#define LOG_TAG "Android::ViewDrawNotifier"

#define LOG_INFO(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
#define LOG_ERROR(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)

namespace Android
{
	struct ViewDrawNotifier:public IViewDrawNotifier
	{
		struct CMessage
		{
			int		Code;
			void*	pArg;
			int		Arg;
		};
		std::vector<CMessage>	mMessageQueue;
		enum RenderThreadMessage {
			MSG_NONE = 0,
			MSG_WINDOW_SET,
			MSG_RENDER_LOOP_EXIT
		};

		un::thread	mThread;
		un::mutex	mMutex;

		IViewDrawDelegate* mpDelegate;

		// android window, supported by NDK r5 and newer
		ANativeWindow* mWindow;
		volatile	bool	mPause;

		ViewDrawNotifier()
		{
			LOG_INFO("Renderer instance created");
			mpDelegate=0x0;
			mWindow=0x0;
			mPause=false;
		}

		~ViewDrawNotifier()
		{
			LOG_INFO("Renderer instance destroyed");
		}

		void Start(IViewDrawDelegate* ipDelegate)
		{
			mpDelegate=ipDelegate;

			LOG_INFO("Creating renderer thread");
			un::thread thread(threadStartCallback, (void*)this);
			mThread.swap(thread);
			//pthread_create(&_threadId, 0, threadStartCallback, this);
		}

		void Stop()
		{
			LOG_INFO("Stopping renderer thread");

			// send message to render thread to stop rendering
			CMessage	message;

			message.Code=MSG_RENDER_LOOP_EXIT;
			mMutex.lock();
			mMessageQueue.push_back(message);
			mMutex.unlock();

			mThread.join();
			//pthread_join(_threadId, 0);
			LOG_INFO("Renderer thread stopped");

			return;
		}

		void Pause()
		{
		}

		void Resume()
		{
		}

		void SetView(void *ipView)
		{
			CMessage	message;

			message.Code=MSG_WINDOW_SET;
			message.pArg=ipView;

			mMutex.lock();
			mMessageQueue.push_back(message);
			mMutex.unlock();

			return;
		}



		void renderLoop()
		{
			bool renderingEnabled = true;

			LOG_INFO("renderLoop()");

			while (renderingEnabled)
			{
				if(mPause)
				{

				}

				mMutex.lock();
				size_t n=mMessageQueue.size();
				for(size_t a=0;a<n;a++)
				{
					CMessage&	message=mMessageQueue[a];

					switch (message.Code)
					{
						case MSG_WINDOW_SET:
						{
							LOG_INFO("MSG_WINDOW_SET");

							ANativeWindow* window=reinterpret_cast<ANativeWindow*>(message.pArg);
							mWindow=window;
							if(!mpDelegate->OnSetView(window))
								mpDelegate->OnDestroy();
						}
						break;

						case MSG_RENDER_LOOP_EXIT:
						{
							LOG_INFO("MSG_RENDER_LOOP_EXIT");

							renderingEnabled = false;
							mpDelegate->OnDestroy();
						}
						break;

						default:
							break;
					}
				}
				mMessageQueue.resize(0);
				mMutex.unlock();

				if (renderingEnabled)
				{
					mpDelegate->OnDrawFrame();
				}
			}

			LOG_INFO("Render loop exits");

			return;
		}

	   static	 void* threadStartCallback(void *myself)
		{
		   ViewDrawNotifier *renderer = (ViewDrawNotifier*)myself;

			renderer->renderLoop();
			return 0;
		}

	};
}
IViewDrawNotifier*
IViewDrawNotifier::New()
{
	return new Android::ViewDrawNotifier();
}