/*
 * Copyright (C) 2011-2012 Doug Brown
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 */

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "programmer.h"
#include "aboutbox.h"
#include <QFileDialog>
#include <QMessageBox>
#include <QDebug>
#include <QSettings>

static Programmer *p;

#define selectedCapacityKey     "selectedCapacity"
#define verifyAfterWriteKey     "verifyAfterWrite"
#define verifyWhileWritingKey   "verifyWhileWriting"
#define selectedEraseSizeKey    "selectedEraseSize"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    writeFile(NULL),
    readFile(NULL),
    writeBuffer(NULL),
    readBuffer(NULL)
{
    initializing = true;
    // Make default QSettings use these settings
    QCoreApplication::setOrganizationName("Doug Brown");
    QCoreApplication::setOrganizationDomain("downtowndougbrown.com");
    QCoreApplication::setApplicationName("SIMMProgrammer");
    QSettings settings;

    p = new Programmer();
    ui->setupUi(this);
    hideFlashIndividualControls();
    ui->pages->setCurrentWidget(ui->notConnectedPage);
    ui->actionUpdate_firmware->setEnabled(false);

    // Fill in the list of SIMM chip capacities (programmer can support anywhere up to 8 MB of space)
    ui->simmCapacityBox->addItem("128 KB (4 x 256Kb/chip)", QVariant(128 * 1024));
    ui->simmCapacityBox->addItem("256 KB (4 x 512Kb/chip)", QVariant(256 * 1024));
    ui->simmCapacityBox->addItem("512 KB (4 x 1Mb/chip)", QVariant(512 * 1024));
    ui->simmCapacityBox->addItem("1 MB (4 x 2Mb/chip)", QVariant(1 * 1024 * 1024));
    ui->simmCapacityBox->addItem("2 MB (4 x 4Mb/chip)", QVariant(2 * 1024 * 1024));
    ui->simmCapacityBox->addItem("4 MB (2 x 16Mb/chip)", QVariant(4 * 1024 * 1024));
    ui->simmCapacityBox->addItem("8 MB (4 x 16Mb/chip)", QVariant(8 * 1024 * 1024));

    // Select 2 MB by default (it's what most people will want), or load last-used setting
    QVariant selectedCapacity = settings.value(selectedCapacityKey, QVariant(2 * 1024 * 1024));
    int selectedIndex = ui->simmCapacityBox->findData(selectedCapacity);
    if (selectedIndex != -1)
    {
        ui->simmCapacityBox->setCurrentIndex(selectedIndex);
    }

    // Fill in the list of verification options
    ui->verifyBox->addItem("Don't verify", QVariant(NoVerification));
    ui->verifyBox->addItem("Verify while writing", QVariant(VerifyWhileWriting));
    ui->verifyBox->addItem("Verify after writing", QVariant(VerifyAfterWrite));

    // Decide whether to verify while writing, after writing, or never.
    // This would probably be better suited as an enum rather than multiple bools,
    // but I started out with it as a single bool, so for backward compatibility,
    // I simply added another bool for the "verify while writing" capability.
    bool verifyAfterWrite = settings.value(verifyAfterWriteKey, false).toBool();
    bool verifyWhileWriting = settings.value(verifyWhileWritingKey, true).toBool();
    selectedIndex = 0;
    if (verifyWhileWriting)
    {
        selectedIndex = ui->verifyBox->findData(VerifyWhileWriting);
    }
    else if (verifyAfterWrite)
    {
        selectedIndex = ui->verifyBox->findData(VerifyAfterWrite);
    }
    else
    {
        selectedIndex = ui->verifyBox->findData(NoVerification);
    }

    if (selectedIndex != -1)
    {
        ui->verifyBox->setCurrentIndex(selectedIndex);
    }

    // Fill in list of "write first xxx bytes" options
    ui->howMuchToWriteBox->addItem("Erase/write entire SIMM", QVariant(0));
    ui->howMuchToWriteBox->addItem("Only erase/write first 256 KB", QVariant(256*1024));
    ui->howMuchToWriteBox->addItem("Only erase/write first 512 KB", QVariant(512*1024));
    ui->howMuchToWriteBox->addItem("Only erase/write first 1 MB", QVariant(1024*1024));
    ui->howMuchToWriteBox->addItem("Only erase/write first 1.5 MB", QVariant(3*512*1024));
    ui->howMuchToWriteBox->addItem("Only erase/write first 2 MB", QVariant(2*1024*1024));

    // Select "erase entire SIMM" by default, or load last-used setting
    QVariant selectedEraseSize = settings.value(selectedEraseSizeKey, QVariant(0));
    selectedIndex = ui->howMuchToWriteBox->findData(selectedEraseSize);
    if (selectedIndex != -1)
    {
        ui->howMuchToWriteBox->setCurrentIndex(selectedIndex);
    }

    ui->chosenWriteFile->setText("");
    ui->chosenReadFile->setText("");
    writeFileValid = false;
    readFileValid = false;
    ui->writeToSIMMButton->setEnabled(false);
    ui->readFromSIMMButton->setEnabled(false);
    ui->progressBar->setValue(0);
    ui->statusLabel->setText("");
    ui->cancelButton->setEnabled(false);

    connect(p, SIGNAL(writeStatusChanged(WriteStatus)), SLOT(programmerWriteStatusChanged(WriteStatus)));
    connect(p, SIGNAL(writeTotalLengthChanged(uint32_t)), SLOT(programmerWriteTotalLengthChanged(uint32_t)));
    connect(p, SIGNAL(writeCompletionLengthChanged(uint32_t)), SLOT(programmerWriteCompletionLengthChanged(uint32_t)));
    connect(p, SIGNAL(writeVerifyTotalLengthChanged(uint32_t)), SLOT(programmerVerifyTotalLengthChanged(uint32_t)));
    connect(p, SIGNAL(writeVerifyCompletionLengthChanged(uint32_t)), SLOT(programmerVerifyCompletionLengthChanged(uint32_t)));
    connect(p, SIGNAL(electricalTestStatusChanged(ElectricalTestStatus)), SLOT(programmerElectricalTestStatusChanged(ElectricalTestStatus)));
    connect(p, SIGNAL(electricalTestFailLocation(uint8_t,uint8_t)), SLOT(programmerElectricalTestLocation(uint8_t,uint8_t)));
    connect(p, SIGNAL(readStatusChanged(ReadStatus)), SLOT(programmerReadStatusChanged(ReadStatus)));
    connect(p, SIGNAL(readTotalLengthChanged(uint32_t)), SLOT(programmerReadTotalLengthChanged(uint32_t)));
    connect(p, SIGNAL(readCompletionLengthChanged(uint32_t)), SLOT(programmerReadCompletionLengthChanged(uint32_t)));
    connect(p, SIGNAL(identificationStatusChanged(IdentificationStatus)), SLOT(programmerIdentifyStatusChanged(IdentificationStatus)));
    connect(p, SIGNAL(firmwareFlashStatusChanged(FirmwareFlashStatus)), SLOT(programmerFirmwareFlashStatusChanged(FirmwareFlashStatus)));
    connect(p, SIGNAL(firmwareFlashTotalLengthChanged(uint32_t)), SLOT(programmerFirmwareFlashTotalLengthChanged(uint32_t)));
    connect(p, SIGNAL(firmwareFlashCompletionLengthChanged(uint32_t)), SLOT(programmerFirmwareFlashCompletionLengthChanged(uint32_t)));
    connect(p, SIGNAL(programmerBoardConnected()), SLOT(programmerBoardConnected()));
    connect(p, SIGNAL(programmerBoardDisconnected()), SLOT(programmerBoardDisconnected()));
    connect(p, SIGNAL(programmerBoardDisconnectedDuringOperation()), SLOT(programmerBoardDisconnectedDuringOperation()));
    p->startCheckingPorts();

    // Set up the multi chip flasher UI -- connect signals
    connect(ui->chosenFlashIC1File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenFlashIC2File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenFlashIC3File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenFlashIC4File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));

    connect(ui->chosenReadIC1File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenReadIC2File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenReadIC3File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->chosenReadIC4File, SIGNAL(textEdited(QString)), SLOT(updateFlashIndividualControlsEnabled()));

    connect(ui->flashIC1CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->flashIC2CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->flashIC3CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->flashIC4CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));

    connect(ui->readIC1CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->readIC2CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->readIC3CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));
    connect(ui->readIC4CheckBox, SIGNAL(clicked()), SLOT(updateFlashIndividualControlsEnabled()));

    connect(ui->selectFlashIC1Button, SIGNAL(clicked()), SLOT(selectIndividualWriteFileClicked()));
    connect(ui->selectFlashIC2Button, SIGNAL(clicked()), SLOT(selectIndividualWriteFileClicked()));
    connect(ui->selectFlashIC3Button, SIGNAL(clicked()), SLOT(selectIndividualWriteFileClicked()));
    connect(ui->selectFlashIC4Button, SIGNAL(clicked()), SLOT(selectIndividualWriteFileClicked()));

    connect(ui->selectReadIC1Button, SIGNAL(clicked()), SLOT(selectIndividualReadFileClicked()));
    connect(ui->selectReadIC2Button, SIGNAL(clicked()), SLOT(selectIndividualReadFileClicked()));
    connect(ui->selectReadIC3Button, SIGNAL(clicked()), SLOT(selectIndividualReadFileClicked()));
    connect(ui->selectReadIC4Button, SIGNAL(clicked()), SLOT(selectIndividualReadFileClicked()));

    initializing = false;
}

MainWindow::~MainWindow()
{
    delete p;
    delete ui;
}

void MainWindow::on_selectWriteFileButton_clicked()
{
    QString filename = QFileDialog::getOpenFileName(this, "Select a ROM image:");
    if (!filename.isNull())
    {
        writeFileValid = true;
        ui->chosenWriteFile->setText(filename);
        ui->writeToSIMMButton->setEnabled(true);
    }
}

void MainWindow::on_selectReadFileButton_clicked()
{
    QString filename = QFileDialog::getSaveFileName(this, "Save ROM image as:");
    if (!filename.isNull())
    {
        readFileValid = true;
        ui->chosenReadFile->setText(filename);
        ui->readFromSIMMButton->setEnabled(true);
    }
}

void MainWindow::on_readFromSIMMButton_clicked()
{
    // Ensure we don't think we're in buffer writing/reading mode...we're reading to
    // an actual file.
    if (writeBuffer)
    {
        delete writeBuffer;
        writeBuffer = NULL;
    }
    if (readBuffer)
    {
        delete readBuffer;
        readBuffer = NULL;
    }
    if (readFile)
    {
        readFile->close();
        delete readFile;
    }
    readFile = new QFile(ui->chosenReadFile->text());
    if (readFile)
    {
        if (!readFile->open(QFile::WriteOnly))
        {
            delete readFile;
            readFile = NULL;
            programmerReadStatusChanged(ReadError);
            return;
        }
        resetAndShowStatusPage();
        p->readSIMM(readFile);
        qDebug() << "Reading from SIMM...";
    }
    else
    {
        programmerReadStatusChanged(ReadError);
    }
}

void MainWindow::on_writeToSIMMButton_clicked()
{
    // Ensure we don't think we're in buffer writing/reading mode...we're writing
    // an actual file.
    if (writeBuffer)
    {
        delete writeBuffer;
        writeBuffer = NULL;
    }
    if (readBuffer)
    {
        delete readBuffer;
        readBuffer = NULL;
    }
    if (writeFile)
    {
        writeFile->close();
        delete writeFile;
    }
    writeFile = new QFile(ui->chosenWriteFile->text());
    if (writeFile)
    {
        if (!writeFile->open(QFile::ReadOnly))
        {
            delete writeFile;
            writeFile = NULL;
            programmerWriteStatusChanged(WriteError);
            return;
        }
        resetAndShowStatusPage();

        uint howMuchToErase = ui->howMuchToWriteBox->itemData(ui->howMuchToWriteBox->currentIndex()).toUInt();
        if (howMuchToErase == 0)
        {
            p->writeToSIMM(writeFile);
        }
        else
        {
            p->writeToSIMM(writeFile, 0, howMuchToErase);
        }
        qDebug() << "Writing to SIMM...";
    }
    else
    {
        programmerWriteStatusChanged(WriteError);
    }
}

void MainWindow::on_chosenWriteFile_textEdited(const QString &newText)
{
    QFileInfo fi(newText);
    if (!newText.isEmpty() && fi.exists() && fi.isFile())
    {
        ui->writeToSIMMButton->setEnabled(true);
        writeFileValid = true;
    }
    else
    {
        ui->writeToSIMMButton->setEnabled(false);
        writeFileValid = false;
    }
}

void MainWindow::on_chosenReadFile_textEdited(const QString &newText)
{
    QFileInfo fi(newText);
    if (!newText.isEmpty() && fi.dir().exists())
    {
        ui->readFromSIMMButton->setEnabled(true);
        readFileValid = true;
    }
    else
    {
        ui->readFromSIMMButton->setEnabled(false);
        readFileValid = false;
    }
}

void MainWindow::programmerWriteStatusChanged(WriteStatus newStatus)
{
    switch (newStatus)
    {
    case WriteErasing:
        if (writeBuffer)
        {
            ui->statusLabel->setText("Erasing chip(s) to be flashed (this may take a few seconds)...");
        }
        else
        {
            ui->statusLabel->setText("Erasing SIMM (this may take a few seconds)...");
        }
        break;
    case WriteCompleteNoVerify:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        QMessageBox::information(this, "Write complete", "The write operation finished.");

        returnToControlPage();
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteCompleteVerifyOK:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        QMessageBox::information(this, "Write complete", "The write operation finished, and the contents were verified successfully.");

        returnToControlPage();
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteVerifying:
        resetAndShowStatusPage();
        break;
    case WriteVerifyStarting:
        ui->statusLabel->setText("Verifying SIMM contents...");
        break;
    case WriteVerifyError:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Verify error", "An error occurred reading the SIMM contents for verification.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteVerifyCancelled:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Verify cancelled", "The verify operation was cancelled.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteVerifyTimedOut:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Verify timed out", "The verify operation timed out.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteVerificationFailure:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        // The verify failure code is somewhat complicated so it's best to put
        // it elsewhere.
        handleVerifyFailureReply();
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteError:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Write error", "An error occurred writing to the SIMM.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteNeedsFirmwareUpdateBiggerSIMM:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Firmware update needed", "The programmer board needs a firmware update to support a larger SIMM. Please update the firmware and try again.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteNeedsFirmwareUpdateVerifyWhileWrite:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Firmware update needed", "The programmer board needs a firmware update to support the \"verify while writing\" capability. Please update the firmware and try again.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteNeedsFirmwareUpdateErasePortion:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Firmware update needed", "The programmer board needs a firmware update to support the \"erase only a portion of the SIMM\" capability. Please update the firmware and try again.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteNeedsFirmwareUpdateIndividualChips:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Firmware update needed", "The programmer board needs a firmware update to support the \"program individual chips\" capability. Please update the firmware and try again.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteCancelled:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Write cancelled", "The write operation was cancelled.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteEraseComplete:
        ui->statusLabel->setText("Writing SIMM...");
        break;
    case WriteEraseFailed:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Write error", "An error occurred erasing the SIMM.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteTimedOut:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Write timed out", "The write operation timed out.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteFileTooBig:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "File too big", "The file you chose to write to the SIMM is too big according to the chip size you have selected.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    case WriteEraseBlockWrongSize:
        if (writeFile)
        {
            writeFile->close();
            delete writeFile;
            writeFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Bad erase size", "The programmer cannot handle the erase size you chose.");
        if (writeBuffer)
        {
            writeBuffer->close();
            delete writeBuffer;
            writeBuffer = NULL;
        }
        break;
    }
}

void MainWindow::programmerWriteTotalLengthChanged(uint32_t totalLen)
{
    ui->progressBar->setMaximum((int)totalLen);
}

void MainWindow::programmerWriteCompletionLengthChanged(uint32_t len)
{
    ui->progressBar->setValue((int)len);
}

void MainWindow::programmerVerifyTotalLengthChanged(uint32_t totalLen)
{
    ui->progressBar->setMaximum((int)totalLen);
}

void MainWindow::programmerVerifyCompletionLengthChanged(uint32_t len)
{
    ui->progressBar->setValue((int)len);
}

void MainWindow::on_electricalTestButton_clicked()
{
    resetAndShowStatusPage();
    electricalTestString = "";
    p->runElectricalTest();
}

void MainWindow::programmerElectricalTestStatusChanged(ElectricalTestStatus newStatus)
{
    switch (newStatus)
    {
    case ElectricalTestStarted:
        ui->statusLabel->setText("Running electrical test (this may take a few seconds)...");
        qDebug() << "Electrical test started";
        break;
    case ElectricalTestPassed:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::information(this, "Test passed", "The electrical test passed successfully.");
        break;
    case ElectricalTestFailed:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Test failed", "The electrical test failed:\n\n" + electricalTestString);
        break;
    case ElectricalTestTimedOut:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Test timed out", "The electrical test operation timed out.");
        break;
    case ElectricalTestCouldntStart:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Communication error", "Unable to communicate with programmer board.");
        break;
    }
}

void MainWindow::programmerElectricalTestLocation(uint8_t loc1, uint8_t loc2)
{
    //qDebug() << "Electrical test error at (" << p->electricalTestPinName(loc1) << "," << p->electricalTestPinName(loc2) << ")";
    if (electricalTestString != "")
    {
        electricalTestString.append("\n");
    }

    electricalTestString.append(p->electricalTestPinName(loc1));
    electricalTestString.append(" shorted to ");
    electricalTestString.append(p->electricalTestPinName(loc2));
}

void MainWindow::programmerReadStatusChanged(ReadStatus newStatus)
{
    switch (newStatus)
    {
    case ReadStarting:
        ui->statusLabel->setText("Reading SIMM contents...");
        break;
    case ReadComplete:
        if (readFile)
        {
            readFile->close();
            delete readFile;
            readFile = NULL;
        }
        if (readBuffer)
        {
            finishMultiRead();
        }

        returnToControlPage();
        QMessageBox::information(this, "Read complete", "The read operation finished.");
        if (readBuffer)
        {
            delete readBuffer;
            readBuffer = NULL;
        }
        break;
    case ReadError:
        if (readFile)
        {
            readFile->close();
            delete readFile;
            readFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Read error", "An error occurred reading from the SIMM.");
        if (readBuffer)
        {
            delete readBuffer;
            readBuffer = NULL;
        }
        break;
    case ReadCancelled:
        if (readFile)
        {
            readFile->close();
            delete readFile;
            readFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Read cancelled", "The read operation was cancelled.");
        if (readBuffer)
        {
            delete readBuffer;
            readBuffer = NULL;
        }
        break;
    case ReadTimedOut:
        if (readFile)
        {
            readFile->close();
            delete readFile;
            readFile = NULL;
        }

        returnToControlPage();
        QMessageBox::warning(this, "Read timed out", "The read operation timed out.");
        if (readBuffer)
        {
            delete readBuffer;
            readBuffer = NULL;
        }
        break;
    }
}

void MainWindow::programmerReadTotalLengthChanged(uint32_t totalLen)
{
    ui->progressBar->setMaximum((int)totalLen);
}

void MainWindow::programmerReadCompletionLengthChanged(uint32_t len)
{
    ui->progressBar->setValue((int)len);
}

void MainWindow::programmerIdentifyStatusChanged(IdentificationStatus newStatus)
{
    switch (newStatus)
    {
    case IdentificationStarting:
        ui->statusLabel->setText("Identifying chips...");
        break;
    case IdentificationComplete:
    {
        ui->pages->setCurrentWidget(ui->controlPage);
        QString identifyString = "The chips identified themselves as:";

        // 4MB SIMM actually only has two chips
        if (p->SIMMCapacity() == 4*1024*1024)
        {
            for (int x = 0; x < 2; x++)
            {
                QString thisString;
                uint8_t manufacturer0 = 0, manufacturer1 = 0;
                uint8_t device0 = 0, device1 = 0;
                p->getChipIdentity(x*2, &manufacturer0, &device0);
                p->getChipIdentity(x*2+1, &manufacturer1, &device1);
                thisString.sprintf("\nIC%d: Manufacturer 0x%04X, Device 0x%04X", (x + 1), (((uint16_t)manufacturer1) << 8) | manufacturer0, (((uint16_t)device1) << 8) | device0);
                identifyString.append(thisString);
            }
        }
        else
        {
            for (int x = 0; x < 4; x++)
            {
                QString thisString;
                uint8_t manufacturer = 0;
                uint8_t device = 0;
                p->getChipIdentity(x, &manufacturer, &device);
                thisString.sprintf("\nIC%d: Manufacturer 0x%02X, Device 0x%02X", (x + 1), manufacturer, device);
                identifyString.append(thisString);
            }
        }

        QMessageBox::information(this, "Identification complete", identifyString);
        break;
    }
    case IdentificationError:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Identification error", "An error occurred identifying the chips on the SIMM.");
        break;
    case IdentificationTimedOut:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Identification timed out", "The identification operation timed out.");
        break;
    case IdentificationNeedsFirmwareUpdate:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Firmware update needed", "The programmer board needs a firmware update to support a larger SIMM. Please update the firmware and try again.");
        break;
    }
}

void MainWindow::programmerFirmwareFlashStatusChanged(FirmwareFlashStatus newStatus)
{
    switch (newStatus)
    {
    case FirmwareFlashStarting:
        ui->statusLabel->setText("Flashing new firmware...");
        break;
    case FirmwareFlashComplete:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::information(this, "Firmware update complete", "The firmware update operation finished.");
        break;
    case FirmwareFlashError:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Firmware update error", "An error occurred writing firmware to the device.");
        break;
    case FirmwareFlashCancelled:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Firmware update cancelled", "The firmware update was cancelled.");
        break;
    case FirmwareFlashTimedOut:
        ui->pages->setCurrentWidget(ui->controlPage);
        QMessageBox::warning(this, "Firmware update timed out", "The firmware update operation timed out.");
        break;
    }
}

void MainWindow::programmerFirmwareFlashTotalLengthChanged(uint32_t totalLen)
{
    ui->progressBar->setMaximum((int)totalLen);
}

void MainWindow::programmerFirmwareFlashCompletionLengthChanged(uint32_t len)
{
    ui->progressBar->setValue((int)len);
}


void MainWindow::on_actionUpdate_firmware_triggered()
{
    QString filename = QFileDialog::getOpenFileName(this, "Select a firmware image:");
    if (!filename.isNull())
    {
        resetAndShowStatusPage();
        p->flashFirmware(filename);
        qDebug() << "Updating firmware...";
    }
}

void MainWindow::on_identifyButton_clicked()
{
    resetAndShowStatusPage();
    p->identifySIMMChips();
}

void MainWindow::programmerBoardConnected()
{
    returnToControlPage();
    ui->actionUpdate_firmware->setEnabled(true);
}

void MainWindow::programmerBoardDisconnected()
{
    ui->pages->setCurrentWidget(ui->notConnectedPage);
    ui->actionUpdate_firmware->setEnabled(false);
}

void MainWindow::programmerBoardDisconnectedDuringOperation()
{
    ui->pages->setCurrentWidget(ui->notConnectedPage);
    ui->actionUpdate_firmware->setEnabled(false);
    // Make sure any files have been closed if we were in the middle of something.
    if (writeFile)
    {
        writeFile->close();
        delete writeFile;
        writeFile = NULL;
    }
    if (readFile)
    {
        readFile->close();
        delete readFile;
        readFile = NULL;
    }
    QMessageBox::warning(this, "Programmer lost connection", "Lost contact with the programmer board. Unplug it, plug it back in, and try again.");
}

void MainWindow::resetAndShowStatusPage()
{
    // Show indeterminate progress bar until communication succeeds/fails
    ui->progressBar->setRange(0, 0);
    ui->statusLabel->setText("Communicating with programmer (this may take a few seconds)...");
    ui->pages->setCurrentWidget(ui->statusPage);
}

void MainWindow::on_simmCapacityBox_currentIndexChanged(int index)
{
    uint32_t newCapacity = static_cast<uint32_t>(ui->simmCapacityBox->itemData(index).toUInt());
    p->setSIMMCapacity(newCapacity);
    QSettings settings;
    if (!initializing)
    {
        // If we're not initializing (it gets called while we're initializing),
        // go ahead and save this as the new default.
        settings.setValue(selectedCapacityKey, newCapacity);
    }
}

void MainWindow::on_verifyBox_currentIndexChanged(int index)
{
    if (index < 0) return;

    VerificationOption vo = static_cast<VerificationOption>(ui->verifyBox->itemData(index).toUInt());

    // Save this as the new default.
    QSettings settings;

    p->setVerifyMode(vo);

    if (!initializing)
    {
        if (vo == NoVerification)
        {
            settings.setValue(verifyAfterWriteKey, false);
            settings.setValue(verifyWhileWritingKey, false);
        }
        else if (vo == VerifyAfterWrite)
        {
            settings.setValue(verifyAfterWriteKey, true);
            settings.setValue(verifyWhileWritingKey, false);
        }
        else if (vo == VerifyWhileWriting)
        {
            settings.setValue(verifyAfterWriteKey, false);
            settings.setValue(verifyWhileWritingKey, true);
        }
    }
}

void MainWindow::on_howMuchToWriteBox_currentIndexChanged(int index)
{
    if (index < 0) return;

    uint32_t newEraseSize = static_cast<uint32_t>(ui->howMuchToWriteBox->itemData(index).toUInt());

    QSettings settings;
    if (!initializing)
    {
        // If we're not initializing (it gets called while we're initializing),
        // go ahead and save this as the new default.
        settings.setValue(selectedEraseSizeKey, newEraseSize);
    }
}

void MainWindow::on_actionAbout_SIMM_Programmer_triggered()
{
    AboutBox::instance()->show();
}

void MainWindow::handleVerifyFailureReply()
{
    // Make a comma-separated list of IC names from this list
    uint8_t badICMask = p->verifyBadChipMask();
    QString icList;
    bool first = true;
    for (int x = 0; x < 4; x++)
    {
        if (badICMask & (1 << x))
        {
            if (first)
            {
                // not IC0 through IC3; IC1 through IC4.
                // that's why I add one.
                icList.append(QString("IC%1").arg(x+1));
                first = false;
            }
            else
            {
                icList.append(QString(", IC%1").arg(x+1));
            }
        }
    }

    returnToControlPage();
    QMessageBox::warning(this, "Verify error", "The data read back from the SIMM did not match the data written to it. Bad data on chips: " + icList);
}

void MainWindow::on_flashIndividualEnterButton_clicked()
{
    showFlashIndividualControls();
    updateFlashIndividualControlsEnabled();
    ui->pages->setCurrentWidget(ui->flashChipsPage);
}

void MainWindow::on_returnNormalButton_clicked()
{
    hideFlashIndividualControls(); // to allow the window to be shrunk when not active
    ui->pages->setCurrentWidget(ui->controlPage);
}

void MainWindow::hideFlashIndividualControls()
{
    ui->chosenFlashIC1File->hide();
    ui->chosenFlashIC2File->hide();
    ui->chosenFlashIC3File->hide();
    ui->chosenFlashIC4File->hide();

    ui->chosenReadIC1File->hide();
    ui->chosenReadIC2File->hide();
    ui->chosenReadIC3File->hide();
    ui->chosenReadIC4File->hide();

    ui->flashIC1CheckBox->hide();
    ui->flashIC2CheckBox->hide();
    ui->flashIC3CheckBox->hide();
    ui->flashIC4CheckBox->hide();

    ui->readIC1CheckBox->hide();
    ui->readIC2CheckBox->hide();
    ui->readIC3CheckBox->hide();
    ui->readIC4CheckBox->hide();

    ui->selectFlashIC1Button->hide();
    ui->selectFlashIC2Button->hide();
    ui->selectFlashIC3Button->hide();
    ui->selectFlashIC4Button->hide();

    ui->selectReadIC1Button->hide();
    ui->selectReadIC2Button->hide();
    ui->selectReadIC3Button->hide();
    ui->selectReadIC4Button->hide();

    ui->multiFlashChipsButton->hide();
    ui->multiReadChipsButton->hide();

    ui->returnNormalButton->hide();
}

void MainWindow::showFlashIndividualControls()
{
    ui->chosenFlashIC1File->show();
    ui->chosenFlashIC2File->show();
    ui->chosenFlashIC3File->show();
    ui->chosenFlashIC4File->show();

    ui->chosenReadIC1File->show();
    ui->chosenReadIC2File->show();
    ui->chosenReadIC3File->show();
    ui->chosenReadIC4File->show();

    ui->flashIC1CheckBox->show();
    ui->flashIC2CheckBox->show();
    ui->flashIC3CheckBox->show();
    ui->flashIC4CheckBox->show();

    ui->readIC1CheckBox->show();
    ui->readIC2CheckBox->show();
    ui->readIC3CheckBox->show();
    ui->readIC4CheckBox->show();

    ui->selectFlashIC1Button->show();
    ui->selectFlashIC2Button->show();
    ui->selectFlashIC3Button->show();
    ui->selectFlashIC4Button->show();

    ui->selectReadIC1Button->show();
    ui->selectReadIC2Button->show();
    ui->selectReadIC3Button->show();
    ui->selectReadIC4Button->show();

    ui->multiFlashChipsButton->show();
    ui->multiReadChipsButton->show();

    ui->returnNormalButton->show();
}

void MainWindow::updateFlashIndividualControlsEnabled()
{
    int numWriteFilesChecked = 0;
    int numReadFilesChecked = 0;
    bool hasBadWriteFileName = false;
    bool hasBadReadFileName = false;

    QCheckBox * const flashBoxes[] = {ui->flashIC1CheckBox,
                                      ui->flashIC2CheckBox,
                                      ui->flashIC3CheckBox,
                                      ui->flashIC4CheckBox};
    QCheckBox * const readBoxes[] = {ui->readIC1CheckBox,
                                     ui->readIC2CheckBox,
                                     ui->readIC3CheckBox,
                                     ui->readIC4CheckBox};
    QPushButton * const flashSelectButtons[] = {ui->selectFlashIC1Button,
                                                ui->selectFlashIC2Button,
                                                ui->selectFlashIC3Button,
                                                ui->selectFlashIC4Button};
    QPushButton * const readSelectButtons[] = {ui->selectReadIC1Button,
                                               ui->selectReadIC2Button,
                                               ui->selectReadIC3Button,
                                               ui->selectReadIC4Button};
    QLineEdit * const flashChosenFileEdits[] = {ui->chosenFlashIC1File,
                                                ui->chosenFlashIC2File,
                                                ui->chosenFlashIC3File,
                                                ui->chosenFlashIC4File};
    QLineEdit * const readChosenFileEdits[] = {ui->chosenReadIC1File,
                                               ui->chosenReadIC2File,
                                               ui->chosenReadIC3File,
                                               ui->chosenReadIC4File};

    for (size_t x = 0; x < sizeof(flashBoxes)/sizeof(flashBoxes[0]); x++)
    {
        bool isChecked = flashBoxes[x]->isChecked();

        flashChosenFileEdits[x]->setEnabled(isChecked);
        flashSelectButtons[x]->setEnabled(isChecked);
        if (isChecked)
        {
            numWriteFilesChecked++;
            QFileInfo fi(flashChosenFileEdits[x]->text());
            if (flashChosenFileEdits[x]->text().isEmpty() || !fi.exists() || !fi.isFile())
            {
                hasBadWriteFileName = true;
            }
        }

        isChecked = readBoxes[x]->isChecked();

        readChosenFileEdits[x]->setEnabled(isChecked);
        readSelectButtons[x]->setEnabled(isChecked);
        if (isChecked)
        {
            numReadFilesChecked++;
            QFileInfo fi(readChosenFileEdits[x]->text());
            if (readChosenFileEdits[x]->text().isEmpty() || !fi.dir().exists())
            {
                hasBadReadFileName = true;
            }
        }
    }

    // All of the individual controls should be handled; now do the two main
    // buttons.
    if ((numWriteFilesChecked == 0) || hasBadWriteFileName)
    {
        ui->multiFlashChipsButton->setEnabled(false);
    }
    else
    {
        ui->multiFlashChipsButton->setEnabled(true);
    }

    if ((numReadFilesChecked == 0) || hasBadReadFileName)
    {
        ui->multiReadChipsButton->setEnabled(false);
    }
    else
    {
        ui->multiReadChipsButton->setEnabled(true);
    }
}

void MainWindow::selectIndividualWriteFileClicked()
{
    QString filename = QFileDialog::getOpenFileName(this, "Select a file to write to the chip:");
    if (!filename.isNull())
    {
        if (sender() == static_cast<QObject *>(ui->selectFlashIC1Button))
        {
            ui->chosenFlashIC1File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectFlashIC2Button))
        {
            ui->chosenFlashIC2File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectFlashIC3Button))
        {
            ui->chosenFlashIC3File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectFlashIC4Button))
        {
            ui->chosenFlashIC4File->setText(filename);
        }
        updateFlashIndividualControlsEnabled();
    }
}

void MainWindow::selectIndividualReadFileClicked()
{
    QString filename = QFileDialog::getSaveFileName(this, "Save binary file as:");
    if (!filename.isNull())
    {
        if (sender() == static_cast<QObject *>(ui->selectReadIC1Button))
        {
            ui->chosenReadIC1File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectReadIC2Button))
        {
            ui->chosenReadIC2File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectReadIC3Button))
        {
            ui->chosenReadIC3File->setText(filename);
        }
        else if (sender() == static_cast<QObject *>(ui->selectReadIC4Button))
        {
            ui->chosenReadIC4File->setText(filename);
        }
        updateFlashIndividualControlsEnabled();
    }
}

void MainWindow::on_multiFlashChipsButton_clicked()
{
    QCheckBox * const flashBoxes[] = {ui->flashIC1CheckBox,
                                      ui->flashIC2CheckBox,
                                      ui->flashIC3CheckBox,
                                      ui->flashIC4CheckBox};

    QLineEdit * const flashChosenFileEdits[] = {ui->chosenFlashIC1File,
                                                ui->chosenFlashIC2File,
                                                ui->chosenFlashIC3File,
                                                ui->chosenFlashIC4File};

    // Read up to four files and create a combined image that we flash using
    // the standard procedure...
    if (writeBuffer)
    {
        delete writeBuffer;
    }
    writeBuffer = new QBuffer();
    qint64 maxSize = 0;
    bool hadError = false;
    uint8_t chipsMask = 0;

    // Read each file and ensure it exists. Oh, and create the mask of which
    // chips we're flashing.
    QFile *files[sizeof(flashBoxes)/sizeof(flashBoxes[0])] = {NULL, NULL, NULL, NULL};
    for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
    {
        if (flashBoxes[x]->isChecked())
        {
            files[x] = new QFile(flashChosenFileEdits[x]->text());
            if (!files[x]->exists())
            {
                hadError = true;
            }
            if (files[x]->size() > maxSize)
            {
                maxSize = files[x]->size();
            }
            files[x]->open(QFile::ReadOnly);
            // Create our chip mask. chip mask is backward from IC numbering
            // (bit 0 = IC4, bit 1 = IC3, ...)
            chipsMask |= (1 << (3-x));
        }
    }

    // If there was an error or one of the files picked was too big,
    // error out.
    if (hadError || (maxSize > (p->SIMMCapacity() / 4)))
    {
        for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
        {
            if (files[x]) delete files[x];
        }

        programmerWriteStatusChanged(WriteError);
        return;
    }

    // Combine the (up to four) files into a single
    // interleaved file to send to the SIMM
    writeBuffer->open(QFile::ReadWrite);
    for (int x = 0; x < maxSize; x++)
    {
        // Go in reverse order through the files so the data is saved to
        // the SIMM in the correct order
        for (int y = (int)(sizeof(files)/sizeof(files[0])) - 1; y >= 0; y--)
        {
            char c = 0xFF;
            if (files[y] && !files[y]->atEnd())
            {
                files[y]->getChar(&c);

            }
            writeBuffer->putChar(c);
        }
    }

    // Discard the temporary files
    for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
    {
        if (files[x])
        {
            files[x]->close();
            delete files[x];
        }
    }

    // Now go back to the beginning of the file...
    // and write it!
    resetAndShowStatusPage();
    writeBuffer->seek(0);
    p->writeToSIMM(writeBuffer, chipsMask);
}

void MainWindow::on_multiReadChipsButton_clicked()
{
    QCheckBox * const readBoxes[] = {ui->readIC1CheckBox,
                                     ui->readIC2CheckBox,
                                     ui->readIC3CheckBox,
                                     ui->readIC4CheckBox};

    QLineEdit * const readChosenFileEdits[] = {ui->chosenReadIC1File,
                                               ui->chosenReadIC2File,
                                               ui->chosenReadIC3File,
                                               ui->chosenReadIC4File};

    // Prepare to read the files; when the read is complete we will save
    // the files as necessary
    if (readBuffer)
    {
        delete readBuffer;
    }
    readBuffer = new QBuffer();

    // Try to open each file to make sure it's writable first. Then close it.
    bool hadError = false;
    for (size_t x = 0; x < sizeof(readBoxes)/sizeof(readBoxes[0]); x++)
    {
        if (readBoxes[x]->isChecked())
        {
            QFile tmp(readChosenFileEdits[x]->text());
            if (!tmp.open(QFile::ReadWrite))
            {
                hadError = true;
            }
            else
            {
                tmp.close();
            }
        }
    }

    // If there was an error creating one of the files, bail out.
    if (hadError)
    {
        programmerReadStatusChanged(ReadError);
        return;
    }

    // Open up the buffer to read into
    readBuffer->open(QFile::ReadWrite);

    // Now start reading it!
    resetAndShowStatusPage();
    p->readSIMM(readBuffer);
}

void MainWindow::finishMultiRead()
{
    QCheckBox * const readBoxes[] = {ui->readIC1CheckBox,
                                     ui->readIC2CheckBox,
                                     ui->readIC3CheckBox,
                                     ui->readIC4CheckBox};

    QLineEdit * const readChosenFileEdits[] = {ui->chosenReadIC1File,
                                               ui->chosenReadIC2File,
                                               ui->chosenReadIC3File,
                                               ui->chosenReadIC4File};

    bool hadError = false;

    QFile *files[sizeof(readBoxes)/sizeof(readBoxes[0])] = {NULL, NULL, NULL, NULL};
    for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
    {
        if (readBoxes[x]->isChecked())
        {
            files[x] = new QFile(readChosenFileEdits[x]->text());
            if (!files[x]->open(QFile::WriteOnly))
            {
                hadError = true;
            }
        }
    }

    if (hadError)
    {
        for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
        {
            if (files[x]) delete files[x];
        }

        programmerReadStatusChanged(ReadError);
        return;
    }

    // Take the final read file and de-interleave it into separate chip files
    readBuffer->seek(0);
    while (!readBuffer->atEnd())
    {
        // Go in reverse order through the files so the data is saved to the
        // files in the correct order
        for (int y = (int)(sizeof(files)/sizeof(files[0])) - 1; y >= 0; y--)
        {
            char c = 0xFF;
            if (readBuffer->getChar(&c)) // grab a character...
            {
                // and as long as it was a success, stick it into the appropriate file
                // (IF we have one), or discard it if we didn't care about the chip
                // it went with.
                if (files[y])
                {
                    files[y]->putChar(c);
                }
            }
            else // no success? we're probably near end of SIMM. just discard it and close the file
            {
                files[y]->close();
                delete files[y];
                files[y] = NULL;
            }
        }
    }

    // Close the individual files that are remaining
    for (size_t x = 0; x < sizeof(files)/sizeof(files[0]); x++)
    {
        if (files[x])
        {
            files[x]->close();
            delete files[x];
        }
    }
}

void MainWindow::returnToControlPage()
{
    // Depending on what we were doing, return to the correct page
    if (writeBuffer || readBuffer)
    {
        ui->pages->setCurrentWidget(ui->flashChipsPage);
    }
    else
    {
        ui->pages->setCurrentWidget(ui->controlPage);
    }
}