//////////////////////////////////////////////////////////////////////////////
/// \file   OSTC2cOperations.h
/// \brief  Implementing various operations for H&W OSTC2, mk2, 2n, 2c dive computer
/// \author JD Gascuel.
/// \sa     ComputerOperations.h
///
/// \copyright (c) 2011-2016 JD Gascuel. All rights reserved.
/// $Id$
//////////////////////////////////////////////////////////////////////////////
//
// BSD 2-Clause License:
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
//    this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
//    this list of conditions and the following disclaimer in the documentation
//    and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
//////////////////////////////////////////////////////////////////////////////

#include "OSTC2cOperations.h"

#include "HexFile.h"

#include "SettingsDialog.h"

#include "Utils/Exception.h"
#include "Utils/Log.h"
#include "Utils/ProgressEvent.h"

#include <QDateTime>
#include <QRegularExpression>

#define FIRMWARE_SIZE 0x17F40

// 64 bytes on Mk.2/2n/2c:
#define FIRMWARE_BLOCK_SIZE 0x40

//////////////////////////////////////////////////////////////////////////////

OSTC2cOperations::OSTC2cOperations()
    : HardwareOperations()
    , _computerFirmware(0)
    , _computerSerial(0)
{}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::readBank0(byte bank0[])
{
    _serial.sleep(100);
    _serial.purge();
    _serial.writeByte('g');
    _serial.readBlock(bank0, 256);
}

void OSTC2cOperations::writeBank0(const byte bank0[])
{
    _serial.sleep(100);
    _serial.purge();
    _serial.writeByte('d');
    int reply = _serial.readByte();
    if (reply != 'd')
        LOG_THROW("Write start");

    for (int a = 4; a < 256; ++a) {
        _serial.writeByte(bank0[a]);
        reply = _serial.readByte();
        if (reply != bank0[a])
            LOG_THROW("Write bank0 @ " << a);
    }

    _serial.sleep(500); // Allow OSTC2c some time to reboot
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::readBank1(byte bank1[256])
{
    _serial.sleep(100);
    _serial.purge();
    _serial.writeByte('j');
    _serial.readBlock(bank1, 256);
}

void OSTC2cOperations::getIdentity()
{
    byte bank0[256], bank1[256];
    memset(bank0, 0xFF, sizeof bank0);
    memset(bank1, 0xFF, sizeof bank1);

    //---- Get a memory dump:
    try {
        readBank0(bank0);
        readBank1(bank1);
    } catch (ReadTimeout) {
        LOG_THROW("No reply from OSTC Mk.2, 2n or 2c...");
    }

    // Sanity check:
    if (bank0[65] == 0xFF || bank1[1] > 99 || bank1[2] > 99)
        LOG_THROW("Not an OSTC Mk.2, 2n or 2c...");

    _computerSerial = bank0[0] + bank0[1] * 256;
    _computerFirmware = bank1[1] * 100 + bank1[2];
    _customText = QString::fromLatin1((char *) bank0 + 65, 25).section('}', 0, 0);

    _description = QString("%1 #%2, v%3.%4, %5")
                       .arg(model())
                       .arg(_computerSerial)
                       .arg(bank1[1])
                       .arg(bank1[2], 2, 10, QChar('0'))
                       .arg(_customText);
}

int OSTC2cOperations::firmware() const
{
    return _computerFirmware;
}

int OSTC2cOperations::serialNumber() const
{
    return _computerSerial;
}

QString OSTC2cOperations::customText() const
{
    return _customText;
}

//////////////////////////////////////////////////////////////////////////////
#if 0
QRegExp OSTC2cOperations::portTemplate() const
{
#if defined(Q_OS_MAC)
    return QRegExp("tty.usbserial-.*", Qt::CaseInsensitive);
#elif defined(Q_OS_LINUX)
    // Seems ok for debian, ubuntu, redhat, CentOS and SUSE (google dixit)
    return QRegExp("ttyUSB.*", Qt::CaseSensitive);
#elif defined(Q_OS_WIN)
    return QRegExp("COM.*", Qt::CaseSensitive);
#endif
}
#endif
QRegularExpression OSTC2cOperations::portTemplate() const
{
#if defined(Q_OS_MAC)
    return QRegularExpression("tty.usbserial-.*", QRegularExpression::CaseInsensitiveOption);
#elif defined(Q_OS_LINUX)
    return QRegularExpression("ttyUSB.*"); // default: case-sensitive
#elif defined(Q_OS_WIN)
    return QRegularExpression("COM.*"); // default: case-sensitive
#endif
}
QStringList OSTC2cOperations::listPorts() const
{
    return listUSBPorts();
}

//////////////////////////////////////////////////////////////////////////////

QString OSTC2cOperations::model() const
{
    return "OSTC2c";
}

QString OSTC2cOperations::description()
{
    return _description;
}

//////////////////////////////////////////////////////////////////////////////

HardwareOperations::CompanionFeatures OSTC2cOperations::supported() const
{
    // No ICON.
    return CompanionFeatures(PARAMETERS | DATE | NAME | DUMPSCREEN | FIRMWARE | HELIUM_DIVE
                             | CCR_DIVE);
}

//////////////////////////////////////////////////////////////////////////////

QString OSTC2cOperations::firmwareTemplate() const
{
    return "mk2_*.hex";
}

//////////////////////////////////////////////////////////////////////////////

bool OSTC2cOperations::connect()
{
    try {
        LOG_TRACE("Connecting " << Settings::port);
        _serial.open(Settings::port, "OSTC2c");
        getIdentity();
        return true;
    } catch (const Exception &e) {
        _serial.close();
        LOG_THROW("Cannot connect " << Settings::port << ": " << e.what());
    }
    return false;
}

//////////////////////////////////////////////////////////////////////////////

QSize OSTC2cOperations::nameSize() const
{
    return QSize(25, 1);
}

void OSTC2cOperations::writeText(const QString &msg)
{
    // No hardware support for that. Just skip it, as it is done when
    // writting bank1...
    LOG_TRACE(msg);
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::connectServiceMode()
{
    try {
        _serial.open(Settings::port, "OSTC2c");

        _serial.writeByte(0xC1);
        _serial.sleep(500); // 0.50 sec for bootloader to start.

        //---- Send C1C1 to start upgrading firmware -----------------------------
        unsigned char pic = 0;
        unsigned char ok = '?';
        for (int retry = 0; retry < 10; ++retry) {
            _serial.writeByte(0xC1);
            _serial.sleep(5);
            _serial.writeByte(0xC1);
            _serial.sleep(5);

            try {
                pic = _serial.readByte();
                ok = _serial.readByte();
                break;
            } catch (const ReadTimeout &) {
                if (retry == 9)
                    LOG_THROW("Cannot start firmware upgrade: timeout.");

                LOG_INFO("Connecting OSTC2c (" << (retry + 1) << "/10)...");
            }
        }

        //---- Check PIC type ----------------------------------------------------
        LOG_TRACE("Pic = " << int(pic));
        if (!pic)
            LOG_THROW("Cannot sync firmware upgrade. Cannot detect chip");

        if (pic != 0x57 || ok != 'K')
            LOG_THROW("Cannot sync firmware upgrade. Bad chip " << int(pic) << " " << ok);

        _serial.sleep(50); // Wait 0.050 sec here.
        return;
    } catch (const Exception &e) {
        _serial.close();
        LOG_THROW("Cannot connect " << Settings::port << ": " << e.what());
    }
    return;
}

//////////////////////////////////////////////////////////////////////////////

bool OSTC2cOperations::disconnect(bool /*closing*/)
{
    if (!_serial.isOpen())
        return false;

    LOG_TRACE("Disconnecting.");

    _serial.purge();
    _serial.close();

    return true;
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::setDate(const QDateTime &date)
{
    unsigned char buffer[6];
    buffer[0] = date.time().hour();
    buffer[1] = date.time().minute();
    buffer[2] = date.time().second();
    buffer[3] = date.date().month();
    buffer[4] = date.date().day();
    buffer[5] = date.date().year() % 100;

    _serial.sleep(100); // Make sure last command is finished.
    _serial.purge();
    _serial.writeByte('b'); // 0x62

    unsigned char reply = _serial.readByte();
    if (reply != 'b')
        LOG_THROW("sync time");

    _serial.writeBlock(buffer, sizeof buffer);
    _serial.sleep(100);
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::setName(const QString &newName)
{
    QByteArray padded = (newName + QString(25, '}')).left(25).toLatin1();

    byte bank0[256] = {0};
    readBank0(bank0);
    memcpy(bank0 + 65, padded.constData(), 25);
    writeBank0(bank0);

    // Then get the new identity:
    getIdentity();
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::setIcons(const QString & /*fileName*/)
{
    LOG_THROW("Not supported");
}

//////////////////////////////////////////////////////////////////////////////

QImage OSTC2cOperations::dumpScreen() const
{
    QImage image(320, 240, QImage::Format_RGB32);

    //---- Send dump screen command -------------------------------------
    unsigned char reply;
    _serial.writeByte('l');
    reply = _serial.readByte();

    if (reply != 'l')
        LOG_THROW("Dumpscreen command failed: " << (int) reply);

    //---- Read image ----------------------------------------------------
    int percent = 0;
    try {
        for (int x = 0; x < 320; ++x) {
            int p = x / 16; // 5% steps
            if (p != percent) {
                PROGRESS(p, 320 / 16);
                percent = p;
            }
            int pix = 0, count = 0;

            for (int y = 0; y < 240; ++y, --count) {
                if (count <= 0) {
                    count = _serial.readByte();

                    if ((count & 0x80) == 0)
                        pix = 0;
                    else if ((count & 0xC0) == 0xC0) {
                        pix = 0xFFFF;
                        count &= 0x3F;
                    } else {
                        unsigned char bpix[2];
                        _serial.readBlock(bpix, 2);
                        pix = (bpix[0] << 8) + bpix[1];
                        count &= 0x3F;
                    }
                    count++;
                }
                // Bit extension 5bits --> 8bits:
                //      12345123.45 = (12345 * 0b100001) / 4
                //      12345612.3456 = (123456 * 0xb1000001) / 16
                int r = (31 & (pix >> 11)) * 255 / 31;
                int g = (63 & (pix >> 5)) * 255 / 63;
                int b = (31 & pix) * 255 / 31;
                image.setPixel(x, y, qRgb(r, g, b));
            }
        }
    } catch (ReadTimeout) {
        LOG_THROW("Missing image data...");
    }

    //---- Done ----------------------------------------------------------
    PROGRESS_RESET();
    LOG_INFO("Screen dumped.");
    return image;
}

//////////////////////////////////////////////////////////////////////////////

void OSTC2cOperations::loadFirmware(HexFile &hex, const QString &fileName) const
{
    hex.allocate(FIRMWARE_SIZE);
    hex.load(fileName);

    //---- Patch Firmware intialization GOTO ---------------------------------
    memcpy((void *) (hex.data() + 0x17F38), // To bootloader vector
           (void *) (hex.data() + 0x00000), // From fw reset code
           8);                              // Up to 8 bytes...

    static unsigned char byteCode[8] = {
        0xA0,
        0xEF,
        0xBF,
        0xF0, // goto 0x1F740 (bootloader 19k)
        0x00,
        0x00, // nop
        0x00,
        0x00 // nop
    };
    memcpy((void *) (hex.data() + 0x00000), // To OSTC reset vector
           (void *) (byteCode),             // From go back to bootloader.
           8);                              // Up to 8 bytes...
}

//////////////////////////////////////////////////////////////////////////////

static void uploadBlock(Serial &serial, const HexFile &hex, size_t addr)
{
    const unsigned char count = FIRMWARE_BLOCK_SIZE;
    assert(0 < count && count < 255);
    assert((addr + count) <= FIRMWARE_SIZE);
    unsigned char reply = 0;

    unsigned char header[4];
    header[0] = 0x1F & (addr >> 16);
    header[1] = 0xFF & (addr >> 8);
    header[2] = 0xFF & (addr);
    header[3] = count;

    unsigned char crc = header[0] + header[1] + header[2] + header[3];
    for (int i = 0; i < count; ++i)
        crc += hex.data()[addr + i];
    crc = -crc; // Sum should make zero.

    try {
        serial.writeBlock(header, sizeof header);
        serial.writeBlock(hex.data() + addr, count);
        serial.writeByte(crc);
    } catch (...) {
        goto WriteFailed;
    }

    serial.sleep(20); // 18msec for a FLASH row write, plus VAT.

    reply = serial.readByte();
    if (reply != 'K') {
        serial.close();
        LOG_THROW(QString("Bad checksum at 0x%1").arg((unsigned int) addr, 0, 16, QChar('0')));
    }
    return;

WriteFailed:
    serial.close();

    LOG_THROW(QString("Write failed"));
}

void OSTC2cOperations::upgradeFW(const QString &fileName)
{
    //---- Load and check firmware ---------------------------------------
    LOG_TRACE("Loading firmware '" << fileName << "'.");
    HexFile hex;
    loadFirmware(hex, fileName);

    //---- Enter uart_115k_bootloader ----------------------------------------
    connectServiceMode();

    //---- Let's do it -------------------------------------------------------
    int percent = 0;

    for (size_t addr = FIRMWARE_BLOCK_SIZE; addr < FIRMWARE_SIZE; addr += FIRMWARE_BLOCK_SIZE) {
        int p = int((addr * 200.0f) / float(FIRMWARE_SIZE) + 0.5f);
        if (p > percent) {
            PROGRESS(percent, 200);
            percent = p;
        }
        uploadBlock(_serial, hex, addr);
    }
    PROGRESS(200, 200);
    uploadBlock(_serial, hex, 0);

    PROGRESS_RESET();
    LOG_INFO("Upgrade FW send.");

    // More than 500ms --> receive timeout.
    _serial.sleep(600);
}

void OSTC2cOperations::getSignal()
{
    return;
}

void OSTC2cOperations::getAllHeader(unsigned char *pBuffer)
{
    return;
}
void OSTC2cOperations::writeAllHeader(unsigned char *pBuffer)
{
    return;
}

void OSTC2cOperations::getAllSamples(unsigned char *pBuffer)
{
    return;
}
void OSTC2cOperations::writeAllSamples(unsigned char *pBuffer)
{
    return;
}
//////////////////////////////////////////////////////////////////////////////