#include "itemwidget.h"
#include "ui_itemwidget.h"

#include <QCheckBox>
#include <QDebug>
#include <QSlider>
#include "../items/train.h"
#include "../items/turnout.h"

ItemWidget::ItemWidget(std::weak_ptr<Item> item, QWidget *parent) :
    QWidget(parent),
    item_(item),
    ui(new Ui::ItemWidget)
{
    ui->setupUi(this);

	if(auto workingItem = item_.lock())
    {
		ui->label->setText(workingItem->getName());

		connect(ui->slider, &QSlider::valueChanged, this, &ItemWidget::setValue);
        connect(ui->checkBox_f1, &QCheckBox::stateChanged, this, &ItemWidget::f1);
        connect(ui->checkBox_f2, &QCheckBox::stateChanged, this, &ItemWidget::f2);
        connect(ui->checkBox_f3, &QCheckBox::stateChanged, this, &ItemWidget::f3);
        connect(ui->checkBox_f4, &QCheckBox::stateChanged, this, &ItemWidget::f4);
        connect(ui->pushButton_reverse, &QPushButton::clicked, this, &ItemWidget::reverse);
		connect(ui->radioButton_left, &QRadioButton::clicked, this, [this](){setValue(0);});
		connect(ui->radioButton_right, &QRadioButton::clicked, this, [this](){setValue(1);});

		connect(workingItem.get(), &Item::valueChanged, this, &ItemWidget::moveToValue);

		Train* train = dynamic_cast<Train*>(workingItem.get());
		Turnout* turnout = dynamic_cast<Turnout*>(workingItem.get());

        if(turnout)
        {
            ui->checkBox_f1->hide();
            ui->checkBox_f2->hide();
            ui->checkBox_f3->hide();
            ui->checkBox_f4->hide();
            ui->slider->hide();
        }

        if(!train)
        {
            ui->pushButton_reverse->hide();
        }
        else
        {
            ui->radioButton_left->hide();
            ui->radioButton_right->hide();
            uint8_t functionMask = train->getFunctionMask();
			qDebug()<<"functionMask: "<<(int)functionMask;
            if(!(functionMask & (1 << 0)))
                ui->checkBox_f1->hide();
            if(!(functionMask & (1 << 1)))
                ui->checkBox_f2->hide();
            if(!(functionMask & (1 << 2)))
                ui->checkBox_f3->hide();
            if(!(functionMask & (1 << 3)))
                ui->checkBox_f4->hide();
        }
    }
    else disable();
}

void ItemWidget::deleteItem()
{
    if(auto workingItem = item_.lock())
    {
        deleteRequest(*workingItem);
    }
}

void ItemWidget::setValue(int8_t value)
{
	if(auto workingItem = item_.lock())
		workingItem->setValue(value);
	else
		disable();
}

void ItemWidget::moveToValue(int8_t value)
{
    ui->slider->blockSignals(true);
    ui->radioButton_left->blockSignals(true);
    ui->radioButton_right->blockSignals(true);

	ui->pushButton_reverse->setText(value == 0 ? "Reverse" : "Stop");
    ui->slider->setValue(value);
    ui->radioButton_left->setChecked(!value);
    ui->radioButton_right->setChecked(value);

    ui->slider->blockSignals(false);
    ui->radioButton_left->blockSignals(false);
    ui->radioButton_right->blockSignals(false);
}

void ItemWidget::f1(int value)
{
    if(auto workingItem = item_.lock())
        workingItem->setFunction(0, value == Qt::Checked);
    else disable();
}

void ItemWidget::f2(int value)
{
    if(auto workingItem = item_.lock())
        workingItem->setFunction(1, value == Qt::Checked);
    else disable();
}


void ItemWidget::f3(int value)
{
    if(auto workingItem = item_.lock())
        workingItem->setFunction(2, value == Qt::Checked);
    else disable();
}

void ItemWidget::f4(int value)
{
    if(auto workingItem = item_.lock())
        workingItem->setFunction(3, value == Qt::Checked);
    else disable();
}

void ItemWidget::reverse()
{
    if(auto workingItem = item_.lock())
    {
        Train* train = dynamic_cast<Train*>(workingItem.get());
        if(train && workingItem->getValue() == 0)
            train->reverse();
        else
		{
			setValue(!((bool)workingItem->getValue()));
        }
    }
    else disable();
}

void ItemWidget::disable()
{
    ui->checkBox_f1->setEnabled(false);
    ui->checkBox_f2->setEnabled(false);
    ui->checkBox_f3->setEnabled(false);
    ui->checkBox_f4->setEnabled(false);
    ui->label->setEnabled(false);
    ui->slider->setEnabled(false);
    ui->pushButton_reverse->setEnabled(false);
}

bool ItemWidget::controles(const ItemData& relay)
{
    if(auto workingRelay = item_.lock())
    {
        if(relay == *workingRelay)
            return  true;
        else
            return false;
    }
    return true;
}

void ItemWidget::stepUp()
{
	setValue(ui->slider->value()+1);
}

void ItemWidget::stepDown()
{
	setValue(ui->slider->value()-1);
}

void ItemWidget::setShortcuts(QKeySequence up, QKeySequence down, QKeySequence rev)
{
    shortcuts_.clear();
    shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(up, this)));
    connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::stepUp);
    shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(down, this)));
    connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::stepDown);
    shortcuts_.push_back(std::unique_ptr<QShortcut>(new  QShortcut(rev, this)));
    connect(shortcuts_.back().get(), &QShortcut::activated, this, &ItemWidget::reverse);
}

std::weak_ptr<Item> ItemWidget::getItem()
{
    return item_;
}

void ItemWidget::stateChanged(int state)
{
    qDebug()<<"widget got state "<<state;
    ui->slider->blockSignals(true);
    ui->slider->setValue(state);
    ui->slider->blockSignals(false);
}

ItemWidget::~ItemWidget()
{
    delete ui;
}