#include "minidisplay.h"

#include <QPainter>

#include <QTimer>

const int KMaxReadAttempt=100;

MiniDisplay::MiniDisplay(QQuickItem *parent):

    QQuickItem(parent),

    iReadAttempt(0),

    iBrightness(iDisplay.MaxBrightness()),

    iAfterAnimatingCallback(NULL),

    iWindow(NULL),

    iFrameCount(0)

{

    // By default, QQuickItem does not draw anything. If you subclass

    // QQuickItem to create a visual item, you will need to uncomment the

    // following line and re-implement updatePaintNode()

    // setFlag(ItemHasContents, true);

    //

    //qDebug() << "New MiniDisplay";

}

MiniDisplay::~MiniDisplay()

{

    //qDebug() << "Delete MiniDisplay";

    close();

}

void MiniDisplay::open()

{

    if (iDisplay.Open())

    {

        iDisplay.SetBrightness(iBrightness);

        emit opened();

        emit statusChanged();

    }

    else

    {

        emit openError();

    }

}

void MiniDisplay::close()

{

    //qDebug() << "MiniDisplay::close";

    //Try to put back ourframe position to RAM 0,0 which is a multiple of 128

    if (iDisplay.IsOpen())

    {

        emit closing();

        if (iDisplay.DisplayPositionY()%128!=0)

        {

            //qDebug() << "SwapBuffer to put back our frame position to zero " << iDisplay.DisplayPositionY();

            iDisplay.SwapBuffers();

        }

    }

    iDisplay.Close();

    disconnectRenderLoop();

    emit closed();

    emit statusChanged();

}

bool MiniDisplay::isOpen()

{

    return iDisplay.IsOpen();

}

void MiniDisplay::clear()

{

    if (!iDisplay.IsOpen()) return;

    //

    iDisplay.Clear();

}

void MiniDisplay::fill()

{

    if (!iDisplay.IsOpen()) return;

    //

    iDisplay.SetAllPixels(0xFF);

}

void MiniDisplay::swapBuffers()

{

    if (!iDisplay.IsOpen()) return;

    //

    iDisplay.SwapBuffers();

}

void MiniDisplay::requestPowerStatus()

{

    if (!iDisplay.IsOpen()) return;

    iDisplay.RequestPowerSupplyStatus();

    QTimer::singleShot(4, this, SLOT(readTimer()));

    iReadAttempt=0;

}

void MiniDisplay::requestDeviceId()

{

    if (!iDisplay.IsOpen()) return;

    iDisplay.RequestDeviceId();

    QTimer::singleShot(4, this, SLOT(readTimer()));

    iReadAttempt=0;

}

void MiniDisplay::requestFirmwareVersion()

{

    if (!iDisplay.IsOpen()) return;

    iDisplay.RequestFirmwareRevision();

    QTimer::singleShot(4, this, SLOT(readTimer()));

    iReadAttempt=0;

}

/**

 * @brief setFont

 * @param aFont

 */

void MiniDisplay::setFont(const QFont& aFont)

{

    iFont=aFont;

    iFont.setStyleStrategy(QFont::NoAntialias);

    QString strDemo="0123456789ABCDEF";

    QFontMetrics metrics(iFont);

    int w=metrics.boundingRect(strDemo).width();

    int h=metrics.height();

    //int h=metrics.boundingRect(strDemo).height();

    QSize size(w,h);

    //Rendering in mono is quite broken we need RGB32

    QImage image(size,QImage::Format_RGB32);

    image.fill(0xFFFFFFFF);

    //Draw some text into our image

    {

        QPainter painter(&image);

        painter.setPen(0xFF000000);

        painter.setFont(iFont);

        painter.drawText(0,metrics.ascent(),strDemo);

    }

    //Save image as PNG for validation

    //image.save("font.png");

    //

    renderImage(&image);

}

/**

 * @brief MiniDisplay::renderWindow

 */

void MiniDisplay::renderOwnWindow()

{

    QImage image=window()->grabWindow();

    //image.save("window.png");

    renderImage(&image);

}

/**

 * @brief MiniDisplay::render

 * @param aWindow

 */

void MiniDisplay::renderWindow(QQuickWindow* aWindow)

{

    //if (!iDisplay.IsOpen()) return;

    QImage image=aWindow->grabWindow();

    //image.save("window.png");

    renderImage(&image);

}

/**

 * @brief MiniDisplay::render

 * @param aImage

 */

void MiniDisplay::renderImage(QImage* aImage)

{

    if (!iDisplay.IsOpen())

    {

        return;

    }

    //Convert our image into a bit array

    int w=aImage->width();

    int h=aImage->height();

    int pixelCount=w*h;

    BitArray bits(pixelCount);

    for (int i=0;i<w;i++)

        {

        for (int j=0;j<h;j++)

            {

            QRgb color=aImage->pixel(i,j);

            if (color!=0xffffffff)

                {

                bits.SetBit(i*h+j);

                }

            }

        }

    //Just blit it then

    iDisplay.BitBlit(bits,w,h,0,0);

}

/**

Connect to the render loop of the given window.

This is achieved using the afterAnimating event.

If any JavaScript callback is provided it will be called on every frame.

@brief MiniDisplay::connectRenderLoop

@param aWindow The window to connect to.

@param aFunction An optional JavaScript callback function

 */

void MiniDisplay::connectRenderLoop(QQuickWindow* aWindow, QJSValue aFunction)

{

    QObject::connect(aWindow, SIGNAL(afterAnimating()),

                     this,  SLOT(onAfterAnimating()));

    iAfterAnimatingCallback = aFunction;

    iWindow = aWindow;

}

/**

@brief MiniDisplay::disconnectRenderLoop

*/

void MiniDisplay::disconnectRenderLoop()

{

    if (iWindow)

    {

        QObject::disconnect(iWindow, SIGNAL(afterAnimating()),this,  SLOT(onAfterAnimating()));

        iWindow = NULL;

        iAfterAnimatingCallback = NULL;

        iFrameCount=0;

    }

}

/**

Once connected to a window render loop this is called on every frame.

@brief MiniDisplay::onAfterAnimating

*/

void MiniDisplay::onAfterAnimating()

{

    //qDebug() << frame << "MiniDisplay::onAfterAnimating";

    /*

    if (iAfterAnimatingCallback.isCallable())

    {

        iAfterAnimatingCallback.call();

    }*/

    //renderWindow(iWindow);

    //swapBuffers();

    //Interrestingly rendering will suspend when we stop changing our text field content

    //if (frame%8==0)

    {

        if (iAfterAnimatingCallback.isCallable())

        {

            iAfterAnimatingCallback.call(QJSValueList() << iFrameCount);

        }

    }

    iFrameCount++;

}

/**

 * @brief MiniDisplay::setPixel

 * @param x

 * @param y

 * @param on

 */

void MiniDisplay::setPixel(int x, int y, bool on)

{

    if (!iDisplay.IsOpen())

    {

        return;

    }

    iDisplay.SetPixel(x,y,on);

}

/**

 * @brief MiniDisplay::offScreenMode

 * @return

 */

bool MiniDisplay::offScreenMode()

{

   return iDisplay.OffScreenMode();

}

/**

 * @brief MiniDisplay::setOffScreenMode

 * @param aOn

 */

void MiniDisplay::setOffScreenMode(bool aOn)

{

    if (!iDisplay.IsOpen())

    {

        return;

    }

    iDisplay.SetOffScreenMode(aOn);

}

/**

 * @brief MiniDisplay::vendor

 * @return

 */

QString MiniDisplay::vendor()

{

    return QString::fromWCharArray(iDisplay.Vendor());

}

/**

 * @brief MiniDisplay::product

 * @return

 */

QString MiniDisplay::product()

{

    return QString::fromWCharArray(iDisplay.Product());

}

/**

 * @brief MiniDisplay::serialNumber

 * @return

 */

QString MiniDisplay::serialNumber()

{

    return QString::fromWCharArray(iDisplay.SerialNumber());

}

/**

 * @brief MiniDisplay::readTimer

 * Called when our read timer completes.

 * We then attempt to complete our pending display request.

 * We typically attempt to read an input report from our HID device.

 */

void MiniDisplay::readTimer()

{

    if (!iDisplay.IsOpen()) return;

    if (!iDisplay.RequestPending()) return;

    iReadAttempt++;

    GP1212A01A::Request request = iDisplay.AttemptRequestCompletion();

    if (!request)

    {

        if (iReadAttempt<KMaxReadAttempt)

        {

            //Will try again later

            QTimer::singleShot(4, this, SLOT(readTimer()));

        }

        return;

    }

    //TODO: Find a way to remove device specific stuff from here

    if (request==GP1212A01A::ERequestFirmwareRevision)

    {

        QString version=QString::fromLocal8Bit((const char*)iDisplay.InputReport().Buffer()+1);

        emit firmwareVersion(version);

    }

    else if (request==GP1212A01A::ERequestDeviceId)

    {

        QString id=QString::fromLocal8Bit((const char*)iDisplay.InputReport().Buffer()+1);

        emit deviceId(id);

    }

    else if (request==GP1212A01A::ERequestPowerSupplyStatus)

    {

        emit powerStatus(iDisplay.PowerOn());

    }

}

int MiniDisplay::maxBrightness() const

{

    return iDisplay.MaxBrightness();

}

int MiniDisplay::minBrightness() const

{

    return iDisplay.MinBrightness();

}

int MiniDisplay::brightness() const

{

    return iBrightness;

}

void MiniDisplay::setBrightness(int aBrightness)

{

    //Still track the brightness when disconnected

    iBrightness=aBrightness;

    if (!iDisplay.IsOpen()) return;

    iDisplay.SetBrightness(aBrightness);

}

/**

@brief MiniDisplay::frameDifferencing

@return

*/

bool MiniDisplay::frameDifferencing() const

{

    return iDisplay.FrameDifferencing();

}

/**

@brief MiniDisplay::setFrameDifferencing

@param aOn

*/

void MiniDisplay::setFrameDifferencing(bool aOn)

{

    iDisplay.SetFrameDifferencing(aOn);

}

QPoint MiniDisplay::framePosition() const

{

    return QPoint(iDisplay.DisplayPositionX(),iDisplay.DisplayPositionX());

}

void MiniDisplay::setFramePosition(const QPoint& aPoint)

{

    iFramePosition = aPoint;

    if (!iDisplay.IsOpen()) return;

    iDisplay.SetDisplayPosition(aPoint.x(),aPoint.y());

}