#include "item.h"

#include "src/actors/sensoractor.h"
#include "src/actors/regulator.h"
#include "src/actors/polynomalactor.h"
#include "src/programmode.h"
#include "relay.h"
#include "messageitem.h"
#include "systemitem.h"

#include <QJsonArray>

ItemData::ItemData(uint32_t itemIdIn, QString name, uint8_t value): name_(name), value_(value), itemId_(itemIdIn)
{

}

QString ItemData::getName() const
{
	return name_;
}

void ItemData::setName(QString name)
{
	name_ = name;
}

uint8_t ItemData::getValue() const
{
	return value_;
}

uint32_t ItemData::id() const
{
	return  itemId_;
}

void ItemData::store(QJsonObject &json)
{
	json["Name"] = name_;
	json["ItemId"] = static_cast<double>(itemId_);
	json["Value"] = static_cast<double>(value_);
}

void ItemData::load(const QJsonObject &json, const bool preserve)
{
	if(!preserve)
	{
		name_ = json["Name"].toString(name_);
		itemId_ = static_cast<uint32_t>(json["ItemId"].toDouble(0));
	}
}


//item

Item::Item(uint32_t itemIdIn, QString name, uint8_t value,  QObject *parent): QObject(parent), ItemData (itemIdIn, name,
	        value)
{

}

Item::Item(const ItemData& itemData,  QObject *parent): QObject(parent), ItemData(itemData)
{

}

Item::~Item()
{
}

void Item::store(QJsonObject &json)
{
	ItemData::store(json);
	json["override"] = override_;
	QJsonArray actorsArray;
	for(size_t i = 0; i < actors_.size(); ++i)
	{
		if(!actors_[i]->isExausted())
		{
			QJsonObject actorObject;
			actors_[i]->store(actorObject);
			actorsArray.append(actorObject);
		}
	}
	json["Actors"] = actorsArray;
}

void Item::load(const QJsonObject &json, const bool preserve)
{
	ItemData::load(json, preserve);
	override_ = json["override"].toBool(false);
	const QJsonArray actorsArray(json["Actors"].toArray(QJsonArray()));
	for(int i = 0; i < actorsArray.size(); ++i)
	{
		if(actorsArray[i].isObject())
		{
			std::shared_ptr<Actor> actor = Actor::loadActor(actorsArray[i].toObject());
			if(actor != nullptr) addActor(actor);
		}
	}
}

void Item::actorSetValue(uint8_t value)
{
	if(!override_ && (programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY))
		setValue(value);
}

void Item::setValue(uint8_t value)
{
	informValue(value);
	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
		enactValue(value);
}

void Item::informValue(uint8_t value)
{
	value_ = value;
	valueChanged(value_);
	updated(*this);
}

void Item::enactValue(uint8_t value)
{
	(void)value;
}

void Item::addActor(std::shared_ptr<Actor> actor)
{
	actor->setParent(this);
	actors_.push_back(actor);
	if(programMode == PROGRAM_MODE_PRIMARY || programMode == PROGRAM_MODE_HEADLESS_PRIMARY)
		connect(actor.get(), &Actor::sigValue, this, &Item::actorSetValue);
	connect(this, &Item::valueChanged, actor.get(), &Actor::onValueChanged);

	std::shared_ptr<SensorActor> sensorActor = std::dynamic_pointer_cast<SensorActor>(actor);
	if(sensorActor)connect(&globalSensors, &SensorStore::sensorChangedState, sensorActor.get(), &SensorActor::sensorEvent);

	std::shared_ptr<Regulator> regulator = std::dynamic_pointer_cast<Regulator>(actor);
	if(regulator)connect(&globalSensors, &SensorStore::sensorChangedState, regulator.get(), &Regulator::sensorEvent);

	std::shared_ptr<PolynomalActor> polynomalActor = std::dynamic_pointer_cast<PolynomalActor>(actor);
	if(polynomalActor != nullptr )connect(&globalSensors, &SensorStore::sensorChangedState, polynomalActor.get(),
		                                      &PolynomalActor::sensorEvent);
}

bool Item::removeActor(std::shared_ptr<Actor> actor)
{
	for(unsigned int i = 0; i < actors_.size(); i++)
	{
		if(actors_[i] == actor)
		{
			actors_.erase(actors_.begin()+i);
			return true;
		}
	}
	return false;
}

void Item::setOverride(const bool in)
{
	override_ = in;
}

bool Item::getOverride()
{
	return override_;
}

void Item::removeAllActors()
{
	actors_.clear();
}

std::vector< std::shared_ptr<Actor> >& Item::getActors()
{
	return actors_;
}

bool Item::hasActors()
{
	return actors_.size() > 0;
}

void Item::setActorsActive(bool in)
{
	for(unsigned i = 0; i < actors_.size(); i++)
		in ? actors_[i]->makeActive() : actors_[i]->makeInactive();
}

std::shared_ptr<Item> Item::loadItem(const QJsonObject& json)
{
	std::shared_ptr<Item> newItem = nullptr;
	if(json["Type"].toString("") == "Relay")
	{
		newItem = std::shared_ptr<Relay>(new Relay);
	}
	else if(json["Type"].toString("") == "Message")
	{
		newItem = std::shared_ptr<MessageItem>(new MessageItem);
	}
	else if(json["Type"].toString("") == "System")
	{
		newItem = std::shared_ptr<SystemItem>(new SystemItem);
	}
	else if(json["Type"].toString("") == "Aux")
	{
	}
	if(newItem)
		newItem->load(json);
	return newItem;
}