#include "EntityDocks.h"
#include <stdexcept>

QList<std::shared_ptr<WsMessage>> deduct_each(std::shared_ptr<WsEntity> item) 
{
	QList<std::shared_ptr<WsMessage>> rets;
	auto immediate = std::make_shared<ImmediateCore>(item);

	for (auto msg : DeduceFramework::_accept_stack) {
		if (msg->targetEntity() == item->entityID()) {
			auto enters = item->getEntryWithInType(msg->topicString());
			for (auto e : enters)
				e(immediate, msg, rets);
		}
	}
	return rets;
}


QList<std::shared_ptr<WsMessage>> DeduceFramework::_accept_stack;
void DeduceFramework::accept(const QList<std::shared_ptr<WsMessage>>& set)
{
	_accept_stack.append(set);
}

#include <QTime>
#include <QtConcurrent>
void DeduceFramework::deduceBegin(std::shared_ptr<const DeduceRequest> ins)
{
	auto dt = QTime::currentTime();

	auto ret_list_set = QtConcurrent::blockingMapped(
		_entity_map.values(), deduct_each
	);

	_accept_stack.clear();
	for (auto vlist : ret_list_set)
		emit this->reply(vlist);

	auto fmsg = std::make_shared<RespondDefault>();
	fmsg->reset(ins->targetEntity(), ins->sourceEntity());
	fmsg->_time_consume = dt.msecsTo(QTime::currentTime());
	emit this->complete(fmsg);
}

#include <simsbasic.h>
DeduceFramework::DeduceFramework() {
	auto mgr_e = std::make_shared<EntitiesManager>();
	mgr_e->append(this->shared_from_this());
	this->_entity_map[mgr_e->entityID()] = mgr_e;
}

std::shared_ptr<WsComponent> DeduceFramework::defaultNew() const
{
	throw std::logic_error("The method or operation is not implemented.");
}

void DeduceFramework::bindEntity(uint64_t entity_id)
{
	this->_bind_entity = entity_id;
}

QString DeduceFramework::name() const
{
	return NAME(DeduceFramework);
}

void DeduceFramework::recoveryFrom(const QJsonObject& obj)
{
	throw std::logic_error("The method or operation is not implemented.");
}

void DeduceFramework::saveTo(QJsonObject& obj) const
{
	throw std::logic_error("The method or operation is not implemented.");
}

void DeduceFramework::execute(std::shared_ptr<ImmediateMap> map,
	std::shared_ptr<const EntityAllocte> in, QList<std::shared_ptr<RespondDefault>>& out)
{

}
void DeduceFramework::execute(std::shared_ptr<ImmediateMap> map,
	std::shared_ptr<const EntityTotalGet> in, QList<std::shared_ptr<EntityTotalList>>& out)
{
	auto rst = std::make_shared<EntityTotalList>();
	rst->reset(in->targetEntity(), in->sourceEntity());
	rst->_entities_list = _entity_map.keys();
	out << rst;
}