#include "autocookwindow.h"
#include "ui_autocookwindow.h"

#include "keepwarmpopup.h"

AutoCookWindow::AutoCookWindow(QWidget *parent, Cook cook) :
    QMainWindow(parent),
    ui(new Ui::AutoCookWindow),
    cook(cook)
{
    ui->setupUi(this);

    ui->clockContainer->setParent(ui->upperStack);
    setAttribute(Qt::WA_DeleteOnClose);

    autocook = AutoCook(cook);
    processSelected = false;

    setupUi();

    Oven *oven = Oven::getInstance();
    connect(oven, SIGNAL(changed(Oven*)), SLOT(updateView()));

    returnToCurrentStepTimer.setSingleShot(true);
    returnToCurrentStepTimer.setInterval(3000);
    connect(&returnToCurrentStepTimer, SIGNAL(timeout()), SLOT(returnToCurrentStep()));

    showCurrentHumidityTimer.setSingleShot(true);
    showCurrentHumidityTimer.setInterval(3000);
    connect(&showCurrentHumidityTimer, SIGNAL(timeout()), SLOT(showCurrentHumidity()));

    showCurrentTempTimer.setSingleShot(true);
    showCurrentTempTimer.setInterval(3000);
    connect(&showCurrentTempTimer, SIGNAL(timeout()), SLOT(showCurrentTemp()));

    connect(&checkCookTimer, SIGNAL(timeout()), SLOT(checkCook()));
    checkCookTimer.start(100);

    connect(&checkProcessTimer, SIGNAL(timeout()), SLOT(checkProcess()));
}

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

void AutoCookWindow::setupUi()
{
    steamModeIcon.load(":/images/cook_mode/small_steam.png");
    dryModeIcon.load(":/images/cook_mode/small_dryheat.png");
    combiModeIcon.load(":/images/cook_mode/small_combi.png");

    ui->cookTypeIcon->setPixmap(Define::icon(cook.type));
    ui->selectCookButton->setText(cook.name);

    ui->stepIndicator->setMaximum(cook.steps.size() - 1);

    ui->cookStepAnimation->start(300);

    ui->humidityGauge->setMinimum(0);
    ui->humidityGauge->setMaximum(100);
    ui->humidityGauge->setValue(0);

    ui->heatGauge->setMinimum(30);
    ui->heatGauge->setMaximum(300);
    ui->heatGauge->setValue(30);

    ui->openDoorAnimation->load(":/images/animation/door_01.png");
    ui->openDoorAnimation->load(":/images/animation/door_02.png");
    ui->openDoorAnimation->load(":/images/animation/door_03.png");
    ui->openDoorAnimation->load(":/images/animation/door_04.png");
    ui->openDoorAnimation->load(":/images/animation/door_05.png");
    ui->openDoorAnimation->load(":/images/animation/door_06.png");
    ui->openDoorAnimation->load(":/images/animation/door_07.png");
    ui->openDoorAnimation->load(":/images/animation/door_08.png");
    ui->openDoorAnimation->load(":/images/animation/door_09.png");
    ui->openDoorAnimation->start(300);
    ui->openDoorAnimation->hide();
    ui->openDoorArrow->hide();

    ui->closeDoorAnimation->load(":/images/animation/door_09.png");
    ui->closeDoorAnimation->load(":/images/animation/door_08.png");
    ui->closeDoorAnimation->load(":/images/animation/door_07.png");
    ui->closeDoorAnimation->load(":/images/animation/door_06.png");
    ui->closeDoorAnimation->load(":/images/animation/door_05.png");
    ui->closeDoorAnimation->load(":/images/animation/door_04.png");
    ui->closeDoorAnimation->load(":/images/animation/door_03.png");
    ui->closeDoorAnimation->load(":/images/animation/door_02.png");
    ui->closeDoorAnimation->load(":/images/animation/door_01.png");
    ui->closeDoorAnimation->start(300);
    ui->closeDoorAnimation->hide();
    ui->closeDoorArrow->hide();

    lastViewCookMode = Define::InvalidMode;
    lastViewCookType = Define::Invalid;
    lastViewCoreTemp = 999;
    lastViewDoorType = Define::Invalid;
    lastViewTime = 0;
    lastViewStepIndex = -1;
    selectedStepIndex = 0;
    showingCurrentHumidity = false;
    showingCurrentTemp = false;

    if (autocook.cook.processes.isEmpty())
    {
        ui->processTitleLabel->hide();
        ui->processTypeLabel->hide();
        ui->processButton_1->hide();
        ui->processButton_2->hide();
        ui->processButton_3->hide();
    }
    else
    {
        QString typeText;
        QSignalMapper *sm = NULL;
        for (int i = 0; i < 3; i++)
        {
            QPushButton *pb;
            switch (i)
            {
            case 0:
                pb = ui->processButton_1;
                break;
            case 1:
                pb = ui->processButton_2;
                break;
            case 2:
                pb = ui->processButton_3;
                break;
            }

            if (i < autocook.cook.processes.size())
            {
                if (sm == NULL)
                {
                    sm = new QSignalMapper(this);
                    connect(sm, SIGNAL(mapped(int)), SLOT(startProcess(int)));
                }

                Define::Process process = autocook.cook.processes[i];

                QString text = Define::name(process);
                if (typeText.isEmpty())
                    typeText = text;
                else
                    typeText += ", " + text;

                QString styleSheet = QString("QPushButton { border-image: url(%1) } QPushButton:pressed { border-image: url(%2) }")
                        .arg(Define::icon(process))
                        .arg(Define::iconOverlay(process));

                pb->setStyleSheet(styleSheet);

                sm->setMapping(pb, (int) process);
                connect(pb, SIGNAL(clicked()), sm, SLOT(map()));
            }
            else
            {
                pb->hide();
            }
        }

        ui->processTypeLabel->setText(typeText);
    }

    ui->processContainer->hide();

    updateView();
}

void AutoCookWindow::updateView()
{
    Oven *oven = Oven::getInstance();

    QString spanFontSize11("<span style=\"font-size:11pt\">%1</span>");
    QString spanFontSize9("<span style=\"font-size:9pt\">%1</span>");

    int remainingTime = qMax(0, autocook.remainingTime());
    if (remainingTime != lastViewTime)
    {
        lastViewTime = remainingTime;

        QString hour = spanFontSize11.arg("시간");
        QString min = spanFontSize11.arg("분");
        QString sec = spanFontSize11.arg("초");

        if (remainingTime >= 3600)
            ui->timeLabel->setText(QString("%1%2 %3%4")
                                   .arg(remainingTime / 3600)
                                   .arg(hour)
                                   .arg((remainingTime % 3600) / 60, 2, 10, QLatin1Char('0'))
                                   .arg(min));
        else if (remainingTime >= 60)
            ui->timeLabel->setText(QString("%1%2 %3%4")
                                   .arg(remainingTime / 60)
                                   .arg(min)
                                   .arg(remainingTime % 60, 2, 10, QLatin1Char('0'))
                                   .arg(sec));
        else
            ui->timeLabel->setText(QString("%1%2")
                                   .arg(remainingTime)
                                   .arg(sec));
    }

    int coreTemp = oven->currentInterTemp();
    if (coreTemp != lastViewCoreTemp)
    {
        lastViewCoreTemp = coreTemp;

        QString coreTempLabel = QString::number(coreTemp);
        if (cook.isCoreTempValid())
            coreTempLabel += spanFontSize11.arg("℃ / " + QString::number(cook.coreTemp())) + spanFontSize9.arg("℃");
        else
            coreTempLabel += spanFontSize11.arg("℃");

        ui->interTempLabel->setText(coreTempLabel);
    }

    if (autocook.done())
    {
        if (!oven->door())
        {
            if (ui->openDoorAnimation->isHidden())
                ui->openDoorAnimation->show();

            if (ui->openDoorArrow->isHidden())
                ui->openDoorArrow->show();

            if (ui->closeDoorAnimation->isVisible())
                ui->closeDoorAnimation->hide();

            if (ui->closeDoorArrow->isVisible())
                ui->closeDoorArrow->hide();
        }
        else
        {
            if (ui->openDoorAnimation->isVisible())
                ui->openDoorAnimation->hide();

            if (ui->openDoorArrow->isVisible())
                ui->openDoorArrow->hide();

            if (ui->closeDoorAnimation->isVisible())
                ui->closeDoorAnimation->hide();

            if (ui->closeDoorArrow->isVisible())
                ui->closeDoorArrow->hide();
        }

        if (ui->processContainer->isHidden())
            ui->processContainer->show();
    }
    else if (autocook.isWaitingDoorOpened() && !oven->door())
    {
        if (ui->openDoorAnimation->isHidden())
            ui->openDoorAnimation->show();

        if (ui->openDoorArrow->isHidden())
            ui->openDoorArrow->show();

        if (ui->closeDoorAnimation->isVisible())
            ui->closeDoorAnimation->hide();

        if (ui->closeDoorArrow->isVisible())
            ui->closeDoorArrow->hide();
    }
    else if (!autocook.isWaitingDoorOpened() && oven->door())
    {
        if (ui->openDoorAnimation->isVisible())
            ui->openDoorAnimation->hide();

        if (ui->openDoorArrow->isVisible())
            ui->openDoorArrow->hide();

        if (ui->closeDoorAnimation->isHidden())
            ui->closeDoorAnimation->show();

        if (ui->closeDoorArrow->isHidden())
            ui->closeDoorArrow->show();
    }
    else
    {
        if (ui->openDoorAnimation->isVisible())
            ui->openDoorAnimation->hide();

        if (ui->openDoorArrow->isVisible())
            ui->openDoorArrow->hide();

        if (ui->closeDoorAnimation->isVisible())
            ui->closeDoorAnimation->hide();

        if (ui->closeDoorArrow->isVisible())
            ui->closeDoorArrow->hide();
    }

    if (autocook.cook.steps[autocook.currentStepIndex].type == Define::Preheat)
    {
        if (ui->preheatIcon->isHidden())
            ui->preheatIcon->show();

        if (ui->preheatLabel->isHidden())
            ui->preheatLabel->show();

        if (ui->preheatGauge->isHidden())
            ui->preheatGauge->show();

        ui->preheatGauge->setMaximum(autocook.cook.steps[autocook.currentStepIndex].temp);
        ui->preheatGauge->setMinimum(autocook.startTemp);
        ui->preheatGauge->setValue(oven->currentTemp());
    }
    else
    {
        if (ui->preheatIcon->isVisible())
            ui->preheatIcon->hide();

        if (ui->preheatLabel->isVisible())
            ui->preheatLabel->hide();

        if (ui->preheatGauge->isVisible())
            ui->preheatGauge->hide();
    }

    if (selectedStepIndex != lastViewStepIndex)
    {
        lastViewStepIndex = selectedStepIndex;
        ui->stepIndicator->setCurrentIndex(selectedStepIndex);
    }

    CookStep showingStep = autocook.cook.steps[selectedStepIndex];
    if (Define::classify(showingStep.type) == Define::DoorClass)
    {
        if (ui->cookStepIcon->isVisible())
            ui->cookStepIcon->hide();

        if (ui->cookStepLabel->isVisible())
            ui->cookStepLabel->hide();

        if (ui->cookModeIcon->isVisible())
            ui->cookModeIcon->hide();

        if (ui->humidityGauge->isVisible())
            ui->humidityGauge->hide();

        if (ui->humidityGaugeButton->isVisible())
            ui->humidityGaugeButton->hide();

        if (ui->humidityLabel->isVisible())
            ui->humidityLabel->hide();

        if (ui->heatGauge->isVisible())
            ui->heatGauge->hide();

        if (ui->heatGaugeButton->isVisible())
            ui->heatGaugeButton->hide();

        if (ui->heatLabel->isVisible())
            ui->heatLabel->hide();

        if (ui->doorStepLabel->isHidden())
            ui->doorStepLabel->show();

        if (ui->cookStepAnimation->isHidden())
            ui->cookStepAnimation->show();

        if (showingStep.type != lastViewDoorType)
        {
            lastViewDoorType = showingStep.type;

            ui->doorStepLabel->setText(Define::name(showingStep.type));
            ui->cookStepAnimation->clear();
            switch (showingStep.type)
            {
            case Define::PutThermometer:
                ui->doorStepLabel->setText("중심 온도계 삽입");
                ui->cookStepAnimation->load(":/images/animation/thermometer_01.png");
                ui->cookStepAnimation->load(":/images/animation/thermometer_02.png");
                ui->cookStepAnimation->setGeometry((900-210)/2, 800, 210, 307);
                ui->cookStepAnimation->start(300);
                break;
            case Define::Load:
                ui->doorStepLabel->setText("식재료 적재");
                ui->cookStepAnimation->load(":/images/animation/load_01.png");
                ui->cookStepAnimation->load(":/images/animation/load_02.png");
                ui->cookStepAnimation->load(":/images/animation/load_03.png");
                ui->cookStepAnimation->load(":/images/animation/load_04.png");
                ui->cookStepAnimation->load(":/images/animation/load_03.png");
                ui->cookStepAnimation->load(":/images/animation/load_02.png");
                ui->cookStepAnimation->load(":/images/animation/load_01.png");
                ui->cookStepAnimation->setGeometry((900-264)/2, 800, 264, 307);
                ui->cookStepAnimation->start(300);
                break;
            case Define::Cut:
                ui->doorStepLabel->setText("자르기");
                ui->cookStepAnimation->load(":/images/animation/cut_01.png");
                ui->cookStepAnimation->load(":/images/animation/cut_02.png");
                ui->cookStepAnimation->load(":/images/animation/cut_03.png");
                ui->cookStepAnimation->setGeometry((900-264)/2, 800, 264, 307);
                ui->cookStepAnimation->start(300);
                break;
            case Define::Pour:
                ui->doorStepLabel->setText("물 붓기");
                ui->cookStepAnimation->load(":/images/animation/pour_01.png");
                ui->cookStepAnimation->load(":/images/animation/pour_02.png");
                ui->cookStepAnimation->load(":/images/animation/pour_03.png");
                ui->cookStepAnimation->load(":/images/animation/pour_04.png");
                ui->cookStepAnimation->setGeometry((900-264)/2, 800, 264, 307);
                ui->cookStepAnimation->start(300);
                break;
            default:
                ui->doorStepLabel->hide();
                ui->cookStepAnimation->hide();
            }
        }
    }
    else
    {
        if (ui->doorStepLabel->isVisible())
            ui->doorStepLabel->hide();

        if (ui->cookStepAnimation->isVisible())
            ui->cookStepAnimation->hide();

        if (ui->cookStepIcon->isHidden())
            ui->cookStepIcon->show();

        if (ui->cookStepLabel->isHidden())
            ui->cookStepLabel->show();

        if (ui->cookModeIcon->isHidden())
            ui->cookModeIcon->show();

        if (ui->humidityGauge->isHidden())
            ui->humidityGauge->show();

        if (ui->humidityGaugeButton->isHidden())
            ui->humidityGaugeButton->show();

        if (ui->humidityLabel->isHidden())
            ui->humidityLabel->show();

        if (ui->heatGauge->isHidden())
            ui->heatGauge->show();

        if (ui->heatGaugeButton->isHidden())
            ui->heatGaugeButton->show();

        if (ui->heatLabel->isHidden())
            ui->heatLabel->show();

        if (showingStep.type != lastViewCookType)
        {
            lastViewCookType = showingStep.type;

            ui->cookStepIcon->setPixmap(Define::icon(showingStep.type));
            ui->cookStepLabel->setText(Define::name(showingStep.type));
        }

        if (showingStep.mode != lastViewCookMode)
        {
            lastViewCookMode = showingStep.mode;

            switch (showingStep.mode)
            {
            case Define::SteamMode:
                ui->cookModeIcon->setPixmap(steamModeIcon);
                break;
            case Define::CombiMode:
                ui->cookModeIcon->setPixmap(combiModeIcon);
                break;
            case Define::DryMode:
                ui->cookModeIcon->setPixmap(dryModeIcon);
                break;
            case Define::InvalidClass:
                ui->cookModeIcon->hide();
                break;
            }
        }

        ui->humidityGauge->setValue(showingStep.humidity);

        int humidity;
        if (showingCurrentHumidity)
            humidity = oven->currentHumidity();
        else
            humidity = showingStep.humidity;

        if (humidity != lastViewHumidity)
        {
            lastViewHumidity = humidity;
            ui->humidityLabel->setText(QString("%1%").arg(humidity));
        }

        ui->heatGauge->setValue(showingStep.temp);

        int temp;
        if (showingCurrentTemp)
            temp = oven->currentTemp();
        else
            temp = showingStep.temp;

        if (temp != lastViewTemp)
        {
            lastViewTemp = temp;
            ui->heatLabel->setText(QString("%1℃").arg(temp));
        }
    }
}

void AutoCookWindow::checkCook()
{
    int lastStepIndex = autocook.currentStepIndex;
    if (autocook.advance())
    {
        if (lastStepIndex != autocook.currentStepIndex)
            selectedStepIndex = autocook.currentStepIndex;

        if (autocook.done())
            checkCookTimer.stop();
    }

    updateView();
}

void AutoCookWindow::startProcess(int process)
{
    if (processSelected)
        return;

    processSelected = true;

    Define::Process p = (Define::Process) process;
    switch (p)
    {
    case Define::CookAgain:
    {
        close();

        AutoCookWindow *w = new AutoCookWindow(parentWidget(), cook);
        w->setWindowModality(Qt::WindowModal);
        w->showFullScreen();
        w->raise();

        break;
    }
    case Define::MakeCrisper:
    {
        selectedProcess = (Define::Process) process;

        CookStep &step = autocook.cook.steps[autocook.cook.steps.size() - 1];

        CookStep newStep = step;
        newStep.type = Define::MakeCrispy;
        newStep.humidity = 0;
        newStep.temp += 10;
        newStep.time = 0;
        newStep.humidification = 0;
        newStep.dehumidification = 0;
        autocook.cook.steps.append(newStep);
        autocook.currentStepIndex = autocook.cook.steps.size() - 1;
        ui->stepIndicator->setMaximum(autocook.cook.steps.size() - 1);
        returnToCurrentStep();

        Oven *oven = Oven::getInstance();
        oven->setHumidity(0);
        oven->setTemp(step.temp + 10);
        oven->startCooking();

        checkProcessTimer.start(100);
        break;
    }
    case Define::KeepWarm:
    {
        processSelected = false;
        selectedProcess = (Define::Process) process;

        KeepWarmPopup *p = new KeepWarmPopup(this);
        p->showFullScreen();
        p->raise();
        break;
    }
    }
}

void AutoCookWindow::checkProcess()
{
    if (!processSelected)
        return;

    switch (selectedProcess)
    {
    case Define::MakeCrisper:
    {
        Oven *oven = Oven::getInstance();
        if (oven->currentTemp() >= oven->temp())
        {
            oven->stopCooking();
            checkProcessTimer.stop();
            processSelected = false;
        }
        break;
    }
    default:
        break;
    }

    updateView();
}

void AutoCookWindow::returnToCurrentStep()
{
    selectedStepIndex = autocook.currentStepIndex;
    showingDifferentStep = false;
    updateView();
}

void AutoCookWindow::showCurrentHumidity()
{
    showingCurrentHumidity = true;
    updateView();
}

void AutoCookWindow::showCurrentTemp()
{
    showingCurrentTemp = true;
    updateView();
}

void AutoCookWindow::on_humidityGaugeButton_pressed()
{
    showCurrentHumidityTimer.start();
}

void AutoCookWindow::on_humidityGaugeButton_released()
{
    if (showCurrentHumidityTimer.isActive())
        showCurrentHumidityTimer.stop();

    if (showingCurrentHumidity)
    {
        showingCurrentHumidity = false;
        updateView();
    }
}

void AutoCookWindow::on_heatGaugeButton_pressed()
{
    showCurrentTempTimer.start();
}

void AutoCookWindow::on_heatGaugeButton_released()
{
    if (showCurrentTempTimer.isActive())
        showCurrentTempTimer.stop();

    if (showingCurrentTemp)
    {
        showingCurrentTemp = false;
        updateView();
    }
}

void AutoCookWindow::on_backButton_clicked()
{
    Oven::getInstance()->stop();
    close();
}

void AutoCookWindow::on_showPrevStepButton_clicked()
{
    if (selectedStepIndex > 0)
    {
        selectedStepIndex--;
        updateView();
    }

    returnToCurrentStepTimer.start();
}

void AutoCookWindow::on_showNextStepButton_clicked()
{
    if (selectedStepIndex + 1 < autocook.cook.steps.size())
    {
        selectedStepIndex++;
        updateView();
    }

    returnToCurrentStepTimer.start();
}