#include "CNetTransceiver.h"
	#include "CEngine.h"
	#include "U_Log.h"
	#include <algorithm>
	CNetTransceiver::CNetTransceiver(unsigned short port, size_t buffsize) : IoThread([this]() { boost::asio::executor_work_guard<boost::asio::io_context::executor_type> work_guard(boost::asio::make_work_guard(IoContext)); IoContext.run(); })
	{
	State = STATE_IDLE;
	try
	{
	Socket = std::make_unique<boost::asio::ip::udp::socket>(IoContext, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), port));
	}
	catch (const boost::system::system_error& ex)
	{
	bool ok = true;
	try
	{
	Socket = std::make_unique<boost::asio::ip::udp::socket>(IoContext, boost::asio::ip::udp::endpoint(boost::asio::ip::udp::v4(), 0U));
	}
	catch (const boost::system::system_error& ex)
	{
	ok = false;
	}
	if (!ok)
	{
	Log::ErrInstance() << "Can't init network transceiver\n";
	}
	else
	{
	Log::ErrInstance() << "Network port " << port << " was busy, another one was chosen\n";
	}
	}
	LocalPort = Socket->local_endpoint().port();
	LocalIpAddress = Socket->local_endpoint().address();
	Queue.Container.reserve(128); //TODO not hardcoded
	Buffer.resize(buffsize);
	Log::Instance() << "Network transceiver is working on " << LocalIpAddress.to_string() << ":" << LocalPort << " with buffer size of " << Buffer.size() << " bytes\n";
	}
	CPeerProperty::CPeerProperty(boost::asio::ip::udp::endpoint endpoint, CType in, CType out, bool blockwholeip)
	{
	EndPoint = endpoint;
	TypeIn = in;
	TypeOut = out;
	BlockWholeIP = blockwholeip;
	}
	void CNetTransceiver::SetNonBlocking(bool enable)
	{
	Socket->non_blocking(enable);
	}
	bool CNetTransceiver::GetNonBlocking()
	{
	return Socket->non_blocking();
	}
	CNetTransceiver::~CNetTransceiver()
	{
	Stop();
	}
	void CPeerProperty::SetTimer(CTimePoint resettime)
	{
	TimerSet = true;
	ResetTime = resettime;
	}
	void CPeerProperty::DisableTimer()
	{
	TimerSet = false;
	}
	void CNetTransceiver::StartSync()
	{
	m_Async = false;
	State = STATE_RUNNING;
	}
	void CNetTransceiver::StartAsync()
	{
	m_Async = true;
	State = STATE_RUNNING;
	ReceiveAsync();
	}
	void CNetTransceiver::Stop()
	{
	if (State == STATE_IDLE) { return; }
	State = STATE_STOP;
	//IoThread.detach();
	if (!InReceivingRoutine && !InSendingRoutine)
	{
	State = STATE_IDLE;
	}
	else
	{
	while (State.load() != STATE_IDLE) { std::this_thread::sleep_for(std::chrono::milliseconds(50)); }
	}
	IoContext.stop();
	IoThread.join();
	}
	void CNetTransceiver::ReceiveAsync()
	{
	if (State == STATE_STOP) { State = STATE_IDLE; return; }
	Receiving = true;
	Socket->async_receive_from(boost::asio::buffer(Buffer), RemoteEndpoint,
	[this](boost::system::error_code ec, std::size_t bytes_recvd)
	{
	Receiving = false;
	InReceivingRoutine = true;
	m_networkError = ec;
	UpdateSinglePeerTimer(RemoteEndpoint);
	if (CanReceiveFromPeer(RemoteEndpoint))
	{
	if (bytes_recvd && ec.value() == 0)
	{
	CTimePoint recvd_at = CEngine::GetInstance()->Time.GetCurrent();
	if(Queue.Enabled)
	{
	CPacket pkt;
	pkt.From = RemoteEndpoint;
	pkt.Data.assign(Buffer.begin(), Buffer.begin() + bytes_recvd);
	pkt.ReceivedAt = recvd_at;
	{
	std::lock_guard<std::mutex> _lock(Queue.Mutex);
	Queue.Container.push_back(std::move(pkt));
	}
	}
	if(ProcessPacket)
	{
	ProcessPacket(RemoteEndpoint, Buffer, bytes_recvd, recvd_at);
	}
	}
	}
	InReceivingRoutine = false;
	if (State == STATE_STOP) { State = STATE_IDLE; return; }
	boost::asio::post(Socket->get_executor(), [this]() { ReceiveAsync(); });
	});
	}
	void CNetTransceiver::SendAsync(boost::asio::ip::udp::endpoint point, const std::vector<std::uint8_t>& msg, std::function<void(boost::system::error_code, std::size_t, CTimePoint)> callback)
	{
	UpdateSinglePeerTimer(point);
	if (!CanSendToPeer(point)) { return; }
	Sending = InSendingRoutine = true;
	Socket->async_send_to(boost::asio::buffer(msg), point, [this, callback](boost::system::error_code ec, std::size_t bytes_sent)
	{
	m_networkError = ec;
	Sending = false;
	InSendingRoutine = false;
	LastSend = CEngine::GetInstance()->Time.GetCurrent();
	if(callback)
	{
	callback(ec, bytes_sent, LastSend);
	}
	});
	}
	void CNetTransceiver::ReceiveSync()
	{
	Receiving = InReceivingRoutine = true;
	size_t bytes_recvd = Socket->receive_from(boost::asio::buffer(Buffer), RemoteEndpoint, 0, m_networkError);
	Receiving = false;
	UpdateSinglePeerTimer(RemoteEndpoint);
	if (CanReceiveFromPeer(RemoteEndpoint))
	{
	if (bytes_recvd && m_networkError.value() == 0)
	{
	CTimePoint recvd_at = CEngine::GetInstance()->Time.GetCurrent();
	if(Queue.Enabled)
	{
	CPacket pkt;
	pkt.From = RemoteEndpoint;
	pkt.Data.assign(Buffer.begin(), Buffer.begin() + bytes_recvd);
	pkt.ReceivedAt = recvd_at;
	{
	std::lock_guard<std::mutex> _lock(Queue.Mutex);
	Queue.Container.push_back(std::move(pkt));
	}
	}
	if(ProcessPacket)
	{
	ProcessPacket(RemoteEndpoint, Buffer, bytes_recvd, recvd_at);
	}
	}
	}
	InReceivingRoutine = false;
	}
	CTimePoint CNetTransceiver::GetLastSendTime() const
	{
	return LastSend;
	}
	boost::system::error_code CNetTransceiver::GetLastError() const
	{
	return m_networkError;
	}
	void CNetTransceiver::SendSync(boost::asio::ip::udp::endpoint point, const std::vector<std::uint8_t>& msg)
	{
	UpdateSinglePeerTimer(point);
	if (!CanSendToPeer(point)) { return; }
	Sending = InSendingRoutine = true;
	Socket->send_to(boost::asio::buffer(msg), point, 0, m_networkError);
	LastSend = CEngine::GetInstance()->Time.GetCurrent();
	Sending = InSendingRoutine = false;
	}
	bool CNetTransceiver::IsAsync() { return m_Async; }
	bool CPeerProperty::IsValid()
	{
	return TypeIn != CType::None || CPeerProperty::TypeOut != CType::None;
	}
	CPeerProperty CPeerProperty::GetInvalid()
	{
	return { {}, CPeerProperty::CType::None, CPeerProperty::CType::None };
	}
	void CPeerProperty::SetTypeIn(CPeerProperty::CType typ)
	{
	if (TypeIn == CType::Protect && typ == CType::Block) { return; }
	TypeIn = typ;
	}
	void CPeerProperty::SetTypeOut(CPeerProperty::CType typ)
	{
	if (TypeOut == CType::Protect && typ == CType::Block) { return; }
	TypeOut = typ;
	}
	void CPeerProperty::SetTypes(CType typin, CType typout)
	{
	SetTypeIn(typin);
	SetTypeOut(typout);
	}
	std::vector<CPeerProperty>::iterator CNetTransceiver::getPeerIterator(boost::asio::ip::udp::endpoint point)
	{
	return std::find_if(Filter.begin(), Filter.end(), [point](const CPeerProperty& prop) -> bool
	{
	if (prop.BlockWholeIP) { return prop.EndPoint.address() == point.address(); }
	return prop.EndPoint.address() == point.address() && prop.EndPoint.port() == point.port();
	});
	}
	CPeerProperty& CNetTransceiver::SetPeerProperty(boost::asio::ip::udp::endpoint point, CPeerProperty::CType typein, CPeerProperty::CType typeout)
	{
	auto it = getPeerIterator(point);
	if (it == Filter.end()) { Filter.push_back({ point, typein, typeout }); return Filter.back(); }
	(*it).SetTypes(typein, typeout);
	return *it;
	}
	void CNetTransceiver::ResetPeerProperty(boost::asio::ip::udp::endpoint point)
	{
	auto it = getPeerIterator(point);
	if (it != Filter.end()) { Filter.erase(it); }
	}
	CPeerProperty& CNetTransceiver::SetPeerPropertyTypeIn(boost::asio::ip::udp::endpoint point, CPeerProperty::CType typein)
	{
	auto it = getPeerIterator(point);
	if (it == Filter.end()) { Filter.push_back({ point, typein, CPeerProperty::CType::None }); return Filter.back(); }
	(*it).SetTypeIn(typein);
	return *it;
	}
	CPeerProperty& CNetTransceiver::SetPeerPropertyTypeOut(boost::asio::ip::udp::endpoint point, CPeerProperty::CType typeout)
	{
	auto it = getPeerIterator(point);
	if (it == Filter.end()) { Filter.push_back({ point, CPeerProperty::CType::None, typeout }); return Filter.back(); }
	(*it).SetTypeOut(typeout);
	return *it;
	}
	CPeerProperty& CNetTransceiver::SetPeerPropertyTypeBoth(boost::asio::ip::udp::endpoint point, CPeerProperty::CType typeboth)
	{
	auto it = getPeerIterator(point);
	if (it == Filter.end()) { Filter.push_back({ point, typeboth, typeboth }); return Filter.back(); }
	(*it).SetTypes(typeboth, typeboth);
	return *it;
	}
	bool CNetTransceiver::GetPeerProperty(boost::asio::ip::udp::endpoint point, CPeerProperty& prop)
	{
	auto it = getPeerIterator(point);
	if (it != Filter.end()) { prop = *it; return true; }
	return false;
	}
	CPeerProperty CNetTransceiver::GetPeerProperty(boost::asio::ip::udp::endpoint point)
	{
	auto it = getPeerIterator(point);
	if (it != Filter.end()) { return *it; }
	return CPeerProperty::GetInvalid();
	}
	bool CNetTransceiver::PeerHasProperty(boost::asio::ip::udp::endpoint point)
	{
	auto it = getPeerIterator(point);
	return it != Filter.end();
	}
	bool CNetTransceiver::CanSendToPeer(boost::asio::ip::udp::endpoint point)
	{
	CPeerProperty prop = GetPeerProperty(point);
	if (!m_InverseFilter)
	{
	if (!prop.IsValid()) { return true; }
	if (prop.TypeOut == CPeerProperty::CType::Block)
	{
	return false;
	}
	}
	else
	{
	if (prop.TypeOut != CPeerProperty::CType::Allow && prop.TypeOut != CPeerProperty::CType::Protect)
	{
	return false;
	}
	}
	return true;
	}
	size_t CNetTransceiver::CountIpsTypeIn(CPeerProperty::CType typein)
	{
	size_t ret = 0U;
	for (CPeerProperty& prop : Filter) { if (prop.TypeIn == typein) { ret++; } }
	return ret;
	}
	size_t CNetTransceiver::CountIpsTypeOut(CPeerProperty::CType typeout)
	{
	size_t ret = 0U;
	for (CPeerProperty& prop : Filter) { if (prop.TypeOut == typeout) { ret++; } }
	return ret;
	}
	size_t CNetTransceiver::CountIpsTypes(CPeerProperty::CType typein, CPeerProperty::CType typeout)
	{
	size_t ret = 0U;
	for (CPeerProperty& prop : Filter) { if (prop.TypeIn == typein && prop.TypeOut == typeout) { ret++; } }
	return ret;
	}
	size_t CNetTransceiver::CountIpsTypeBoth(CPeerProperty::CType typeboth)
	{
	size_t ret = 0U;
	for (CPeerProperty& prop : Filter) { if (prop.TypeIn == typeboth && prop.TypeOut == typeboth) { ret++; } }
	return ret;
	}
	CPeerProperty& CNetTransceiver::SetIpProperty(boost::asio::ip::address addr, CPeerProperty::CType typein, CPeerProperty::CType typeout)
	{
	Filter.erase(std::remove_if(Filter.begin(), Filter.end(), [addr](const CPeerProperty& prop) -> bool
	{ return prop.EndPoint.address() == addr; }), Filter.end());
	Filter.push_back({{ addr, 11231 }, typein, typeout, true }); //TODO is 11231 default client port?
	return Filter.back();
	}
	CPeerProperty& CNetTransceiver::SetIpPropertyTypeIn(boost::asio::ip::address addr, CPeerProperty::CType typein)
	{
	return SetIpProperty(addr, typein, CPeerProperty::CType::None);
	}
	CPeerProperty& CNetTransceiver::SetIpPropertyTypeOut(boost::asio::ip::address addr, CPeerProperty::CType typeout)
	{
	return SetIpProperty(addr, CPeerProperty::CType::None, typeout);
	}
	CPeerProperty& CNetTransceiver::SetIpPropertyTypeBoth(boost::asio::ip::address addr, CPeerProperty::CType typeboth)
	{
	return SetIpProperty(addr, typeboth, typeboth);
	}
	bool CNetTransceiver::CanReceiveFromPeer(boost::asio::ip::udp::endpoint point)
	{
	CPeerProperty prop = GetPeerProperty(point);
	if (!m_InverseFilter)
	{
	if (!prop.IsValid()) { return true; }
	if (prop.TypeIn == CPeerProperty::CType::Block)
	{
	return false;
	}
	}
	else
	{
	if (prop.TypeIn != CPeerProperty::CType::Allow && prop.TypeIn != CPeerProperty::CType::Protect)
	{
	return false;
	}
	}
	return true;
	}
	void CNetTransceiver::UpdatePeerTimers()
	{
	Filter.erase(std::remove_if(Filter.begin(), Filter.end(), [](const auto& p) { return p.TimerSet && CEngine::GetInstance()->Time.GetCurrent() >= p.ResetTime; }), Filter.end());
	}
	void CNetTransceiver::UpdateSinglePeerTimer(boost::asio::ip::udp::endpoint point)
	{
	auto it = getPeerIterator(point);
	if (it != Filter.end())
	{
	if ((*it).TimerSet && CEngine::GetInstance()->Time.GetCurrent() >= (*it).ResetTime)
	{
	Filter.erase(it);
	}
	}
	}
	void CNetTransceiver::SetInverseFilter(bool inversefilter)
	{
	m_InverseFilter = inversefilter;
	}
	void CNetTransceiver::ToggleInverseFilter()
	{
	m_InverseFilter = !m_InverseFilter;
	}
	bool CNetTransceiver::IsFilterInverse()
	{
	return m_InverseFilter;
	}
	char CNetTransceiver::STATE_IDLE = 0;
	char CNetTransceiver::STATE_RUNNING = 1;
	char CNetTransceiver::STATE_STOP = 2;