#include "ProjectionModel.h"
#include "Channel.h"
#include "Warp.h"
#include "gui/QChannelWidget.h"
#include "gui/QDesignViewWindow.h"

using namespace projection;

QChannelWidget::QChannelWidget(QWidget* pParent, Qt::WFlags flags)
    : QWidget(pParent, flags), m_pChannel(NULL)
{
    ui.setupUi(this);

    ui.pluginComboBox->clear();

 		foreach (ProjectorInterface *projector_interface, ProjectionModel::projector_interfaces)
				{
						foreach (QString projector_name, projector_interface->projectors())
								{
										ProjectorWidget* projector_widget = projector_interface->newProjectorWidget(projector_name);
										Q_ASSERT (NULL!=projector_widget);
										ui.stackedWidget->addWidget(projector_widget);
										ui.pluginComboBox->addItem(projector_widget->data().getFullName());
								}
				}

		// If we only have the default plugin, the combo is not displayed.
		if (ui.pluginComboBox->count()==1) 
		{
				ui.pluginComboBox->hide();
				ui.pluginLabel->hide();
		}
		

		connect(ui.pluginComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(on_pluginComboBox_currentIndexChanged(int)));

    ui.toolBox->setAutoFillBackground(false);

    setEnabled(false);

		ui.projectionTransformWidget->disconnect();
		connect(ui.projectionTransformWidget, SIGNAL(matrixChanged(const TransformMatrix&)),
						this, SLOT(on_projectionTransformWidget_matrixChanged(const TransformMatrix&)));

		ui.projectionTransformWidget->setUseScale(false);
		ui.viewTransformWidget->setUseScale(false);
}

QChannelWidget::~QChannelWidget()
{
}

void QChannelWidget::setChannel(Channel* pChannel)
{
		if (m_pChannel==pChannel) return;

    m_pChannel = pChannel;

		if (pChannel) 
		{
				Q_ASSERT(NULL!=pChannel->getProjector());
				QString fullname=pChannel->getProjector()->getFullName();
				int next_index=ui.pluginComboBox->findText(fullname);
				ui.pluginComboBox->setCurrentIndex(next_index);

				// In some case, the on_pluginComboBox_currentIndexChanged is not called at first time (because the index does not change indeed).
				// So, we force the connection
				ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
				projector_widget->disconnect();
				m_pChannel->disconnect();

				connect(projector_widget, SIGNAL(dataChanged(const ProjectorData&)), m_pChannel, SLOT(updatePluginData(const ProjectorData&)));
				
		}
		else ui.pluginComboBox->setCurrentIndex(0);
		updateGUI();

		setEnabled(NULL!=pChannel);
}

Channel* QChannelWidget::getChannel() const
{
    return m_pChannel;
}

void QChannelWidget::updateGUI()
{
    if (m_pChannel)
    {
        ui.nameEdit->setText(m_pChannel->getName());
        ui.overlayNameCheckBox->setChecked(m_pChannel->getOverlayName());
        ui.remoteHostNameEdit->setText(m_pChannel->getRemoteHostName());
        ui.remoteFullScreenCheckBox->setChecked(m_pChannel->getRemoteFullScreen());
        ui.remoteScreenComboBox->setCurrentIndex(ui.remoteScreenComboBox->findText(QString::number(m_pChannel->getRemoteScreen())));
        ui.overlayImageEdit->setText(m_pChannel->getOverlayImageFileName());

				// On s'occupe de la partie Projection
				// Inutile si elle n'est pas selectionnee, d'ailleurs.

				// On met a jour les donnees.
				const ProjectorData* projector_data=m_pChannel->getProjector();
				ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
				projector_widget->updateGUI(projector_data);

				ui.projectionTransformWidget->setMatrix(m_pChannel->getProjectorTransformMatrix());

        ui.warpCheckBox->setChecked(m_pChannel->getDistWarpEnabled());
        ui.warpResSpinBox->setValue(m_pChannel->getDistWarp()->getNumCtrlPoints());




				// On s'occupe de la partie View
				// Inutile si elle n'est pas selectionnee, d'ailleurs.


				ui.viewProjectionWidget->disconnect();
				ui.viewTransformWidget->disconnect();

				connect(ui.viewProjectionWidget, SIGNAL(matrixChanged(const ProjectionMatrix&)),
								this, SLOT(on_viewProjectionWidget_matrixChanged(const ProjectionMatrix&)));
				connect(ui.viewTransformWidget, SIGNAL(matrixChanged(const TransformMatrix&)),
								this, SLOT(on_viewTransformWidget_matrixChanged(const TransformMatrix&)));
				ui.viewProjectionWidget->setMatrix(m_pChannel->getView()->getProjectionMatrix());
				ui.viewTransformWidget->setMatrix(m_pChannel->getView()->getTransformMatrix());

    }
    else
    {
        ui.nameEdit->setText("");
        ui.overlayNameCheckBox->setChecked(false);
        ui.remoteHostNameEdit->setText("");
        ui.remoteFullScreenCheckBox->setChecked(false);
        ui.remoteScreenComboBox->setCurrentIndex(0);
        ui.overlayImageEdit->setText("");

				ui.projectionTransformWidget->clear();
				ui.viewProjectionWidget->clear();
				ui.viewTransformWidget->clear();

				Q_ASSERT(NULL!=ui.stackedWidget);
				if (NULL!=ui.stackedWidget->currentWidget())
				{
						ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
						Q_ASSERT(NULL!=projector_widget);
						projector_widget->clear();
						
				}
		}
}

void QChannelWidget::on_nameEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getName() != ui.nameEdit->text())
        {
            m_pChannel->setName(ui.nameEdit->text());
            ui.nameEdit->setText(m_pChannel->getName());
        }
    }
}

void QChannelWidget::on_overlayNameCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setOverlayName(checked);
    }
}

void QChannelWidget::on_remoteHostNameEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getRemoteHostName() != ui.remoteHostNameEdit->text())
            m_pChannel->setRemoteHostName(ui.remoteHostNameEdit->text());
    }
}

void QChannelWidget::on_remoteFullScreenCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setRemoteFullScreen(checked);
    }
}

void QChannelWidget::on_remoteScreenComboBox_activated(int)
{
    if (m_pChannel)
    {
        m_pChannel->setRemoteScreen(ui.remoteScreenComboBox->currentText().toInt());
    }
}

void QChannelWidget::on_overlayImageEdit_editingFinished()
{
    if (m_pChannel)
    {
        if (m_pChannel->getOverlayImageFileName() != ui.overlayImageEdit->text())
            m_pChannel->setOverlayImageFileName(ui.overlayImageEdit->text());
    }
}

void QChannelWidget::on_overlayImageBrowseButton_clicked()
{
    if (m_pChannel)
    {
        QString fileName = QFileDialog::getOpenFileName(this, "Choose a file to open", ui.overlayImageEdit->text(), "Image files (*.*)");
        if (!fileName.isEmpty()) {
            ui.overlayImageEdit->setText(fileName);
            on_overlayImageEdit_editingFinished();
        }
    }
}

void QChannelWidget::on_warpCheckBox_toggled(bool checked)
{
    if (m_pChannel)
    {
        m_pChannel->setDistWarpEnabled(checked);
    }
}

void QChannelWidget::on_warpResSpinBox_valueChanged(int value)
{
    if (m_pChannel)
    {
        m_pChannel->getDistWarp()->setNumCtrlPoints(value);
        m_pChannel->updateData();
    }
}

void QChannelWidget::on_warpResetButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->getDistWarp()->reset();
        m_pChannel->updateData();
    }
}

void QChannelWidget::on_calibrateButton_clicked()
{
}

void QChannelWidget::on_fitButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->fitView();
    }
}

void QChannelWidget::on_windowButton_clicked()
{
    if (m_pChannel)
    {
        m_pChannel->showProjectorWindow();
    }
}

void QChannelWidget::on_projectionTransformWidget_matrixChanged(const TransformMatrix& matrix)
{
		m_pChannel->setProjectorTransformMatrix(matrix);
}

void QChannelWidget::on_viewProjectionWidget_matrixChanged(const ProjectionMatrix& matrix)
{
		m_pChannel->setViewProjectionMatrix(matrix);
}

void QChannelWidget::on_viewTransformWidget_matrixChanged(const TransformMatrix& matrix)
{
		m_pChannel->setViewTransformMatrix(matrix);
}

void QChannelWidget::on_pluginComboBox_currentIndexChanged(int current_index)
{
		ui.stackedWidget->currentWidget()->disconnect();
		ui.stackedWidget->setCurrentIndex(current_index);
		ui.stackedWidget->currentWidget()->disconnect();
		if (m_pChannel)
		{
				m_pChannel->setProjector (ui.pluginComboBox->currentText());
				ProjectorWidget* projector_widget=qobject_cast<ProjectorWidget*>(ui.stackedWidget->currentWidget());
				m_pChannel->disconnect();
				connect(projector_widget, SIGNAL(dataChanged(const ProjectorData&)), m_pChannel, SLOT(updatePluginData(const ProjectorData&)));
				m_pChannel->updateData();
				
		}
		updateGUI();
}