#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());

 }