#pragma once

#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x500
#include <windows.h>
#include <process.h>
#include <comutil.h>
#include <vector>

#pragma comment(lib, "comsuppw.lib")

namespace cg_quick
{
	class noncopyable
	{
	private:
		noncopyable(const noncopyable &);
		const noncopyable &operator= (const noncopyable &);
	protected:
		noncopyable(void)  {}
		~noncopyable(void) {}
	};

	template <class lock_t>
	class locker
	{
	private:
		lock_t & lock_;

	public:
		locker(lock_t & lck) : lock_(lck)
		{
			lock_.lock();
		}
		locker(const locker &r) : lock_(r.lock_)
		{
			lock_.lock();
		}

		const locker &operator= (const locker &r)
		{
			if (this != &r)
			{
				lock_.unlock();
				lock_ = r.lock_;
				lock_.lock();
			}
			return *this;
		}

		~locker()
		{
			lock_.unlock();
		}
	};

	struct nolock : public noncopyable
	{
		bool lock(int timeout = -1) { return true; }
		void unlock() {}

		typedef locker<nolock> locker;
		locker get_locker() { return locker(*this); }
	};

	struct cslock : public noncopyable, private CRITICAL_SECTION
	{
		cslock()
		{
			::InitializeCriticalSection(this);
		}
		~cslock()
		{
			::DeleteCriticalSection(this);
		}

		bool lock(int timeout = -1)
		{
			// возможна ситуация, когда CRT уничтожает CRITICAL_SECTION,
			// а из другого потока происходит попытка её занятия
			// (в частности, такое наблюдается при завершениим программ по Ctrl-C -
			// при записи в лог в момент, когда удаляются различные объекты)
			__try
			{
				::EnterCriticalSection(this); return true;
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
			}
			return false;
		}
		void unlock()
		{
			__try
			{
				::LeaveCriticalSection(this);
			}
			__except(EXCEPTION_EXECUTE_HANDLER)
			{
			}
		}

		typedef locker<cslock> locker;
		locker get_locker() { return locker(*this); }
	};

	template <typename T>
	class transparent_proxy : public noncopyable
	{
		T * m_ptr;
		transparent_proxy();
	public:
		transparent_proxy(T * ptr) : m_ptr(ptr) {}
		T * operator -> () const { return m_ptr; }
	};

	template <typename T>
	class locking_proxy : public noncopyable
	{
		T * m_ptr;
		locking_proxy();
	public:
		locking_proxy(T * ptr) : m_ptr(ptr)
		{
			m_ptr->lock();
		}
		~locking_proxy()
		{
			m_ptr->unlock();
		}
		T * operator -> () const { return m_ptr; }
	};

	template <typename T, class lock_t = nolock>
	class singleton : public noncopyable
	{
		static T * pinstance_;
	protected:
		static lock_t locker_;
	public:
		static T & instance()
		{
			if (!pinstance_)
			{
				lock_t::locker guard = locker_.get_locker();
				if (!pinstance_)
				{
					pinstance_ = new T();
				}
			}
			return *pinstance_;
		}

		template <template <typename> class proxy = transparent_proxy>
		struct ptr : public noncopyable
		{
			proxy<T> operator-> ()
			{
				return &singleton<T,lock_t>::instance();
			}
		};
	};

	template <typename T, class lock_t>
	__declspec(selectany) lock_t singleton<T, lock_t>::locker_;

	template <typename T, class lock_t>
	__declspec(selectany) T * singleton<T, lock_t>::pinstance_ = NULL;

	template <class lock_t = nolock, int bufsize = 4096>
	class simple_allocator : public singleton<simple_allocator<lock_t, bufsize>, lock_t>
	{
		friend class singleton<simple_allocator, lock_t>;
		simple_allocator() {}
	public:
		char * Alloc(int size = 4096)
		{
			lock_t::locker guard = locker_.get_locker();
			return new char[bufsize];
		}
		void Free(char *buf)
		{
			lock_t::locker guard = locker_.get_locker();
			if (buf)
			{
				delete [] buf;
			}
		}

		static int get_alloc_size()
		{
			return bufsize;
		}
	};

	template <class lock_t = nolock, int bufsize = 4096>
	class pool_allocator : public singleton<pool_allocator<lock_t, bufsize>, lock_t>
	{
		friend class singleton<pool_allocator, lock_t>;	
		std::vector<char *> m_pool;

		pool_allocator()
		{
			m_pool.reserve(50);
		}
	public:
		~pool_allocator()
		{
			for (std::vector<char *>::iterator it = m_pool.begin(); it != m_pool.end(); ++it)
			{
				delete [] *it;
			}
		}

		char * Alloc(int size = 4096)
		{
			lock_t::locker guard = locker_.get_locker();
			if (m_pool.empty())
			{
				return new char[bufsize];
			}
			char * tmp = *(m_pool.rbegin());
			m_pool.pop_back();
			return tmp;
		}

		void Free(char *buf)
		{
			lock_t::locker guard = locker_.get_locker();
			if (buf)
			{
				m_pool.push_back(buf);
			}
		}

		static int get_alloc_size()
		{
			return bufsize;
		}

		int get_size() const
		{
			return m_pool.size();
		}
	};

	class simple_reload_manager
	{
		DWORD m_dwLastStamp;
	protected:
		bool should_reload()
		{
			SYSTEMTIME stTime;	
			::GetLocalTime(&stTime);
			bool bret = (m_dwLastStamp != (DWORD)stTime.wDay);
			m_dwLastStamp = stTime.wDay;
			return bret;
		}
	public:
		simple_reload_manager()
		{
			SYSTEMTIME stTime;	
			::GetLocalTime(&stTime);
			m_dwLastStamp = stTime.wDay;
		}
	};


	template <class allocator_t = pool_allocator<nolock> >
	class simple_string_formatter
	{
		wchar_t * m_format;
		wchar_t * m_result;

		template <typename T>
		struct convertHelper;

		template <>
		struct convertHelper<wchar_t>
		{
			typedef const wchar_t* converttype;
		}
		template <>
		struct convertHelper<char>
		{
			typedef _bstr_t converttype;
		}

	public:
		simple_string_formatter()
		{
			m_format = (wchar_t *)allocator_t::instance().Alloc(allocator_t::get_alloc_size());
			m_result = (wchar_t *)allocator_t::instance().Alloc(allocator_t::get_alloc_size());
		}
		~simple_string_formatter()
		{
			allocator_t::instance().Free(m_format);
			allocator_t::instance().Free(m_result);
		}
		void init_string_formatter(const wchar_t *szMask)
		{
			_swnprintf(m_format,allocator_t::get_alloc_size()/sizeof(wchar_t),L"%s",szMask);
		}
		template <typename charT>
		wchar_t * generate_string(const charT *szCoreString, void * pParams = NULL)
		{
			SYSTEMTIME stTime;	
			::GetLocalTime(&stTime);
			_swnprintf(m_result,allocator_t::get_alloc_size()/sizeof(wchar_t), m_format, (int)stTime.wYear, (int)stTime.wMonth, (int)stTime.wDay, (int)stTime.wHour, (int)stTime.wMinute, (int)stTime.wSecond, (int)stTime.wMilliseconds, (const wchar_t *)(convertHelper<charT>::converttype)szCoreString);
			return m_result;
		}
	};

	template <class allocator_t = pool_allocator<nolock> >
	class simple_filename_formatter
	{
		wchar_t * m_format;
		wchar_t * m_result;
	public:
		simple_filename_formatter()
		{
			m_format = (wchar_t *)allocator_t::instance().Alloc(allocator_t::get_alloc_size());
			m_result = (wchar_t *)allocator_t::instance().Alloc(allocator_t::get_alloc_size());
		}
		~simple_filename_formatter()
		{
			allocator_t::instance().Free(m_format);
			allocator_t::instance().Free(m_result);
		}
		void init_filename_formatter(const wchar_t *szMask)
		{
			_swnprintf(m_format,allocator_t::get_alloc_size()/sizeof(wchar_t),L"%s",szMask);
		}
		wchar_t * generate_filename()
		{
			SYSTEMTIME stTime;	
			::GetLocalTime(&stTime);
			_swnprintf(m_result,allocator_t::get_alloc_size()/sizeof(wchar_t),m_format, (int)stTime.wYear, (int)stTime.wMonth, (int)stTime.wDay, (int)stTime.wHour, (int)stTime.wMinute, (int)stTime.wSecond, (int)stTime.wMilliseconds);
			return m_result;
		}
	};

	const UINT WM_OPEN_FILE = WM_USER;
	const UINT WM_CLOSE_FILE = WM_USER + 1;
	const UINT WM_WRITE_LINE = WM_USER + 2;
	const UINT WM_WRITE_LINEW = WM_USER + 3;

	template <template <class> class string_formatter_t = simple_string_formatter,
		template <class> class filename_formatter_t = simple_filename_formatter,
	class reload_manager_t = simple_reload_manager,
	class file_lock_t = nolock,
	class allocator_t = pool_allocator<nolock> >
	class file_writer : protected reload_manager_t, public string_formatter_t<allocator_t>, public filename_formatter_t<allocator_t>
	{
	private:
		HANDLE m_hWriterThread;
		DWORD  m_dwThreadId;
		HANDLE m_hFile;
		HANDLE m_hWaitStart;
		HANDLE m_hWaitStop;

		bool   m_bActive;

		file_lock_t locker_;

		void CloseImpl()
		{
			if (m_hFile != INVALID_HANDLE_VALUE)
			{
				::CloseHandle(m_hFile);
				m_hFile = INVALID_HANDLE_VALUE;
				m_bActive = false;
			}
		}

		void OpenImpl()
		{
			CloseImpl();
			m_hFile = ::CreateFileW(generate_filename(),
				GENERIC_WRITE,
				FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
				NULL,
				OPEN_ALWAYS,
				FILE_ATTRIBUTE_NORMAL,
				NULL);

			if (m_hFile == INVALID_HANDLE_VALUE)
			{
				return;
			}

			if (::SetFilePointer(m_hFile, ::GetFileSize(m_hFile, NULL), NULL, FILE_BEGIN) == (DWORD)0xFFFFFFFF)
			{
				return;
			}
			m_bActive = true;
		}

		template <typename charT>
		void WriteImpl(const charT *buffer, void *pData)
		{
			if (!m_bActive)
			{
				return;
			}

			if (should_reload())
			{
				OpenImpl();
			}

			file_lock_t::locker guard = locker_.get_locker();

			::SetFilePointer(m_hFile, 0, NULL, FILE_END);
			DWORD dwWrittenBytes;

			wchar_t * tmpbuf = generate_string<charT>(buffer,pData);

			::WriteFileW(m_hFile, tmpbuf, wcslen(tmpbuf), &dwWrittenBytes, NULL);
		}

		static DWORD WINAPI Execute(file_writer *pInstance)
		{
			MSG msg;

			__try
			{	
				::PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
				::SetEvent(pInstance->m_hWaitStart);

				while (::GetMessage(&msg, NULL, 0, 0))
				{
					switch (msg.message)
					{
					case WM_OPEN_FILE:
						pInstance->OpenImpl();
						break;
					case WM_CLOSE_FILE:
						pInstance->CloseImpl();
						break;
					case WM_WRITE_LINE:
						pInstance->WriteImpl((const char *)msg.wParam, (void *)msg.lParam);
						allocator_t::instance().Free((char *)msg.wParam);
						if ((void *)msg.lParam)
						{
							delete (void *)msg.lParam;
						}
						break;
					case WM_WRITE_LINEW:
						pInstance->WriteImpl((const wchar_t *)msg.wParam, (void *)msg.lParam);
						allocator_t::instance().Free((char *)msg.wParam);
						if ((void *)msg.lParam)
						{
							delete (void *)msg.lParam;
						}
						break;
					default:
						;
					}
				}
			}
			__finally
			{
				::SetEvent(pInstance->m_hWaitStop);
			}
			return 0;
		}

	public:
		file_writer() : reload_manager_t(),
			string_formatter_t<allocator_t>(),
			filename_formatter_t<allocator_t>(),
			m_hWriterThread(INVALID_HANDLE_VALUE),
			m_hFile(INVALID_HANDLE_VALUE),
			m_hWaitStart(INVALID_HANDLE_VALUE),
			m_hWaitStop(INVALID_HANDLE_VALUE),
			m_dwThreadId(0),
			m_bActive(false)
		{
			m_hWaitStart = ::CreateEvent(NULL, FALSE, FALSE, NULL);
			m_hWaitStop = ::CreateEvent(NULL, FALSE, FALSE, NULL);
		}

		~file_writer()
		{
			Stop();
			::CloseHandle(m_hWaitStart);
			::CloseHandle(m_hWaitStop);
			::CloseHandle(m_hWriterThread);
		}

		bool Start()
		{
			m_hWriterThread = (HANDLE)_beginthreadex(NULL,
				0,
				(unsigned (__stdcall *)( void * ))Execute,
				this,
				0,
				(unsigned *)&m_dwThreadId);

			if (m_hWriterThread == INVALID_HANDLE_VALUE)	return false;

			::WaitForSingleObject(m_hWaitStart, INFINITE);

			Open();

			return true;
		}

		void Stop()
		{
			Close();
			::PostThreadMessage(m_dwThreadId, WM_QUIT, 0, 0);
			::WaitForSingleObject(m_hWaitStop, INFINITE);
		}

		void Close() const
		{
			::PostThreadMessage(m_dwThreadId, WM_CLOSE_FILE, 0, 0);
		}
		void Open()
		{
			::PostThreadMessage(m_dwThreadId, WM_OPEN_FILE, 0, 0);
		}
		void Write(char *buffer, void *pData) const
		{
			::PostThreadMessage(m_dwThreadId, WM_WRITE_LINE, (WPARAM)buffer, (LPARAM)pData);
		}
		void WriteW(wchar_t *buffer, void *pData) const
		{
			::PostThreadMessage(m_dwThreadId, WM_WRITE_LINEW, (WPARAM)buffer, (LPARAM)pData);
		}
	};

	class simple_priority_manager
	{
		DWORD m_dwPriorityLevel;
	public:
		bool can_write(DWORD dwPriority)
		{
			return dwPriority >= m_dwPriorityLevel;
		}
	public:
		simple_priority_manager() : m_dwPriorityLevel(0) {}
		void set_priority(DWORD dwPriority)
		{
			m_dwPriorityLevel = dwPriority;
		}
	};

	template <class create_lock_t,
		template <template <class> class cl1, template <class> class cl2, class, class, class> class writer_t,
	class file_lock_t,
	class priority_manager_t,
	class reload_manager_t,
		template <class> class string_formatter_t,
		template <class> class filename_formatter_t,
		template <class, int> class allocator_t,
		int alloc_size = 4096>
	class quick_logger : public priority_manager_t,
		public writer_t<
		string_formatter_t,
		filename_formatter_t,
		reload_manager_t,
		file_lock_t, allocator_t<create_lock_t, alloc_size>
		>,
		public singleton<quick_logger<create_lock_t, 
		                              writer_t,
									  file_lock_t,
									  priority_manager_t,
									  reload_manager_t,
									  string_formatter_t,
									  filename_formatter_t,
									  allocator_t,
									  alloc_size
		                             >,
						 create_lock_t>
	{
		friend class singleton<quick_logger, create_lock_t>;
		quick_logger() : priority_manager_t(),
			writer_t< 
			string_formatter_t,
			filename_formatter_t,
			reload_manager_t,
			file_lock_t, allocator_t<create_lock_t, alloc_size> >()
		{}
	public:
		void WriteFormat(DWORD dwPriority, void *pData, const char *szMask, ...)
		{
			if (!can_write(dwPriority))
			{
				return;
			}
			char * buffer = allocator_t<create_lock_t, alloc_size>::instance().Alloc(alloc_size);
			va_list vargs;
			va_start(vargs, szMask);
			_vsnprintf(buffer, alloc_size, szMask, vargs);
			va_end (vargs);
			Write(buffer, pData);
		}
		void WriteSimpleFormat(const char *szMask, ...)
		{
			char * buffer = allocator_t<create_lock_t, alloc_size>::instance().Alloc(alloc_size);
			va_list vargs;
			va_start(vargs, szMask);
			_vsnprintf(buffer, alloc_size, szMask, vargs);
			va_end (vargs);
			Write(buffer, NULL);
		}
		void WriteSimpleFormatW(const wchar_t *swzMask, ...)
		{
			wchar_t * buffer = (wchar_t *)allocator_t<create_lock_t, alloc_size>::instance().Alloc(alloc_size);
			va_list vargs;
			va_start(vargs, swzMask);
			_vsnwprintf(buffer, alloc_size/sizeof(wchar_t), swzMask, vargs);
			va_end (vargs);
			WriteW(buffer, NULL);
		}
	};

	__declspec(selectany) quick_logger<cslock, file_writer, nolock, simple_priority_manager, simple_reload_manager, simple_string_formatter, simple_filename_formatter, pool_allocator>::ptr<> g_logger;
}
#define LOG(Priority) if (!cg_quick::g_logger->can_write(Priority)) ; else cg_quick::g_logger->WriteSimpleFormat
#define LOGW(Priority) if (!cg_quick::g_logger->can_write(Priority)) ; else cg_quick::g_logger->WriteSimpleFormatW

#define MP_LOWEST		0
#define MP_INFO			1
#define MP_TRACE		2
#define MP_IMPORTANT		3
#define MP_CRITICAL		4
#define MP_HIGHEST		5

/*
void InitLogWriter()
{
	cg_quick::g_logger->set_priority(MP_LOWEST);
	cg_quick::g_logger->init_string_formatter(L"%04d.%02d.%02d %02d:%02d:%02d.%03d\t%s\r\n");
	cg_quick::g_logger->init_filename_formatter(L"c:\\test\\test_%04d_%02d_%02d.log");
	cg_quick::g_logger->Start();
}

void ReleaseLogWriter()
{
	cg_quick::g_logger->Stop();
}
*/