#include "cameras.h"
#include <QRandomGenerator>
#include <string>
#include <functional>
#include <QDebug>

Cameras::Cameras(uvosled* led): led_(led)
{

}

bool Cameras::setCameras(const std::vector<cam::Camera::Description>& descriptions)
{
	clear();
	bool ret = true;
	for(auto& camera : descriptions)
	{
		if(!addCamera(camera))
			ret = false;
	}
	return ret;
}


void Cameras::clear()
{
	free_ = false;
	for(auto& camera : cameras_)
		cameraRemoved(camera);
	cameras_.clear();
	if(led_)
		uvosled_set_current(led_, 0xFF, 0);
}

std::vector<cam::Camera::Description> Cameras::getCameras()
{
	std::vector<cam::Camera::Description> desc;
	desc.reserve(cameras_.size());
	for(std::shared_ptr<Camera> camera : cameras_)
		desc.push_back(camera->cam()->getDescription());
	return desc;
}

std::shared_ptr<Camera> Cameras::getCamera(size_t id)
{
	std::vector<cam::Camera::Description> desc = getCameras();
	for(size_t i = 0; i < desc.size(); ++i)
	{
		if(desc[i].getHash() == id)
			return cameras_[i];
	}
	return std::shared_ptr<Camera>(nullptr);
}

bool Cameras::addCamera(const cam::Camera::Description& desc)
{
	cameras_.push_back(std::shared_ptr<Camera>(new Camera(desc)));

	if(!cameras_.back()->cam()->isOpen())
	{
		cameras_.pop_back();
		return false;
	}

	cameras_.back()->cam()->setTriggerMode(cam::Camera::TRIGGER_SOFTWARE);
	cameras_.back()->cam()->setExposureTime(exposrueTime_*1000000);
	setFree(false);
	cameraAdded(cameras_.back());
	qDebug()<<"Using camera"<<cameras_.back()->id();
	return true;
}

void Cameras::trigger()
{
	for(auto& camera : cameras_)
		camera->cam()->trigger();

	if(led_ && !free_)
		uvosled_capture(led_, lighting_.mask, lighting_.brightness, exposrueTime_*1.5, exposrueTime_*0.25);
}

bool Cameras::start()
{
	bool ret = true;
	for(auto& camera : cameras_)
	{
		if(!camera->cam()->startAcquisition())
			ret = false;
	}

	if(free_)
		uvosled_set_current(led_, lighting_.mask, lighting_.brightness);

	return ret;
}

bool Cameras::stop()
{
	bool ret = true;
	for(auto& camera : cameras_)
	{
		if(!camera->cam()->stopAcquisition())
			ret = false;
	}

	if(led_)
		uvosled_set_current(led_, 0xFF, 0);
	return ret;
}

bool Cameras::setFree(bool free)
{
	stop();
	free_ = free;
	bool ret = true;

	for(auto& camera : cameras_)
	{
		if(!camera->cam()->setAcquisitionMode(free ? cam::Camera::MODE_FREE : cam::Camera::MODE_SINGLE))
			ret = false;
	}
	return ret;
}

bool Cameras::setExposureTime(double exposureTime)
{
	stop();
	exposrueTime_ = exposureTime;
	bool ret = true;
	for(auto& camera : cameras_)
	{
		if(!camera->cam()->setExposureTime(exposrueTime_*1000000))
			ret = false;
	}
	return ret;
}

void Cameras::imageRecived(Camera::Image img)
{
	bool allreadyUpdated = false;
	for(auto& camera : cameras_)
	{
		for(auto& image : images_)
		{
			if(image.cameraId == camera->id())
			{
				allreadyUpdated = true;
				goto FOUND;
			}
		}
	}
	FOUND:

	if(!allreadyUpdated)
		images_.push_back(img);

	if(images_.size() == cameras_.size())
		newImages(images_);

	images_.clear();
}

void Cameras::store(QSettings &settings)
{
	std::vector<cam::Camera::Description> available = cam::Camera::getAvailableCameras();

	settings.beginWriteArray(GROUP, cameras_.size());
	for(size_t i = 0; i < cameras_.size(); ++i)
	{
		settings.setArrayIndex(i);
		settings.setValue("id", static_cast<unsigned long long>(cameras_[i]->id()));
	}
	settings.endArray();
}

void Cameras::load(QSettings &settings)
{
	std::vector<cam::Camera::Description> available = cam::Camera::getAvailableCameras();

	int size = settings.beginReadArray(GROUP);
	for(int i = 0; i < size; ++i)
	{
		settings.setArrayIndex(i);
		size_t hash = settings.value("id", 0).toULongLong();
		for(auto& camera : available)
		{
			if(camera.getHash() == hash)
				addCamera(camera);
		}
	}
	settings.endArray();
}