#include "pch.h"
#include <iostream>
#include <array>
#include "../../../include/qtl_odbc.hpp"

class SimpleEventLoop
{
public:
	SimpleEventLoop()
	{
		m_objs.reserve(MAXIMUM_WAIT_OBJECTS);
		m_nExpired = INFINITE;
		m_hStopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
		m_objs.push_back(m_hStopEvent);
	}

	qtl::event* add(HANDLE hEvent)
	{
		if (m_objs.size() < m_objs.capacity())
		{
			m_objs.push_back(hEvent);

			std::unique_ptr<event_item> item(new event_item(*this, hEvent));
			event_item* result = item.get();
			m_items.push_back(std::move(item));
			return result;
		}
		return nullptr;
	}

	void run()
	{
		while (m_objs.size()>1)
		{
			DWORD dwSize = m_objs.size();
			DWORD dwTimeout = m_nExpired - GetTickCount();
			DWORD dwObject = WaitForMultipleObjects(dwSize, m_objs.data(), FALSE, dwTimeout);
			if (dwObject >= WAIT_OBJECT_0 && WAIT_OBJECT_0 + dwSize)
			{
				DWORD index = dwObject - WAIT_OBJECT_0;
				HANDLE hEvent = m_objs[index];
				if (hEvent == m_hStopEvent)
					break;

				m_objs.erase(m_objs.begin() + index);
				fire(hEvent, qtl::event::ef_read | qtl::event::ef_write);
			}
			else if (dwObject == WAIT_TIMEOUT)
			{
				fire_timeout();
			}
		}
	}

	void stop()
	{
		SetEvent(m_hStopEvent);
	}

private:
	class event_item : public qtl::event
	{
	public:
		event_item(SimpleEventLoop& ev, HANDLE hEvent) : m_ev(&ev), m_hEvent(hEvent), m_busying(false)
		{
		}
		virtual void set_io_handler(int flags, long timeout, std::function<void(int)>&& handler) override
		{
			m_handler = handler;
			m_busying = true;
			m_nExpired = GetTickCount() + timeout*1000;
			m_ev->m_nExpired = std::min<DWORD>(m_ev->m_nExpired, m_nExpired);
		}
		virtual void remove() override
		{
			if(!m_busying)
				m_ev->remove(this);
		}
		virtual bool is_busying() override
		{
			return m_busying;
		}

		HANDLE m_hEvent;
		std::function<void(int)> m_handler;
		SimpleEventLoop* m_ev;
		DWORD m_nExpired;
		bool m_busying;
	};

	HANDLE m_hStopEvent;
	std::vector<HANDLE> m_objs;
	std::vector<std::unique_ptr<event_item>> m_items;
	DWORD m_nExpired;

	void remove_object(event_item* item)
	{
		auto it = std::find_if(m_objs.begin(), m_objs.end(), [item](HANDLE hEvent) {
			return item->m_hEvent == hEvent;
		});
		if (it != m_objs.end())
		{
			m_objs.erase(it);
		}
	}

	void remove(event_item* item)
	{
		remove_object(item);
		{
			auto it = std::find_if(m_items.begin(), m_items.end(), [item](const std::unique_ptr<event_item>& v) {
				return item == v.get();
			});
			if (it != m_items.end())
			{
				m_items.erase(it);
			}
		}
	}

	void fire(HANDLE hEvent, int flags)
	{
		auto it = std::find_if(m_items.begin(), m_items.end(), [hEvent](const std::unique_ptr<event_item>& v) {
			return hEvent == v->m_hEvent;
		});
		if (it != m_items.end())
		{
			(*it)->m_handler(flags);
		}
	}

	void fire_timeout()
	{
		for (auto& item : m_items)
		{
			if (item->m_nExpired < m_nExpired)
			{
				item->m_handler(qtl::event::ef_timeout);
				remove_object(item.get());
			}
			else
			{
				m_nExpired = std::min<DWORD>(item->m_nExpired, m_nExpired);
			}
		}
	}
};

int main()
{
	SimpleEventLoop ev;
	ev.run();
	return 0;
}