#include "FutabaVfd.h"

//#include <stdlib.h>

#include <string.h>

//

//

//

//

//

//

FutabaVfdCommand::FutabaVfdCommand():/*iBuffer(NULL),*/iSize(0),iMaxSize(0)

    {

    }

FutabaVfdCommand::~FutabaVfdCommand()

    {

    //Delete();

    }

/**

*/

void FutabaVfdCommand::Reset()

    {

    memset(iReports,0,sizeof(iReports));

    }

/**

*/

/*

void FutabaVfdCommand::Create(int aMaxSize)

    {

    iBuffer=new unsigned char[aMaxSize];

    if (iBuffer)

        {

        iMaxSize = aMaxSize;

        iSize = 0;

        }

    }

*/

/**

*/

/*

void FutabaVfdCommand::Delete()

{

    delete[] iBuffer;

    iBuffer = NULL;

    iMaxSize = 0;

    iSize = 0;

}

*/

//

// class GP1212A01A

//

GP1212A01A::GP1212A01A():

	iDisplayPositionX(0),iDisplayPositionY(0),

    iOffScreenMode(true),

    iFrameNext(NULL),

    iFrameCurrent(NULL),

    iFramePrevious(NULL),

    iFrameAlpha(NULL),

    iFrameBeta(NULL),

    iFrameGamma(NULL),

    iNeedFullFrameUpdate(0),

    iRequest(ERequestNone),iPowerOn(false)

	{

	//ResetBuffers();

	}

/**

*/

GP1212A01A::~GP1212A01A()

	{

    delete iFrameAlpha;

    iFrameAlpha=NULL;

    //

    delete iFrameBeta;

    iFrameBeta=NULL;

    //

    delete iFrameGamma;

    iFrameGamma=NULL;

    //

    iFrameNext=NULL;

    iFrameCurrent=NULL;

    iFramePrevious=NULL;

    //

    iNeedFullFrameUpdate=0;

	}

/**

*/

int GP1212A01A::Open()

	{

	int success = HidDevice::Open(KFutabaVendorId,KFutabaProductIdGP1212A01A,NULL);

	if (success)

		{

        //Allocate both frames

        delete iFrameAlpha;

        iFrameAlpha=NULL;

        iFrameAlpha=new BitArray(KGP12xFrameBufferPixelCount);

        //

        delete iFrameBeta;

        iFrameBeta=NULL;

        iFrameBeta=new BitArray(KGP12xFrameBufferPixelCount);

        //

        delete iFrameGamma;

        iFrameGamma=NULL;

        iFrameGamma=new BitArray(KGP12xFrameBufferPixelCount);

        //

        iFrameNext=iFrameAlpha;

        iFrameCurrent=iFrameBeta;

        iFramePrevious=iFrameGamma;

        //To make sure it is synced properly

        iNeedFullFrameUpdate=0;

        //

		SetNonBlocking(1);

        //Since we can't get our display position we force it to our default

		//This makes sure frames are in sync from the start

        //Clever clients will have taken care of putting back frame (0,0) before closing

		SetDisplayPosition(iDisplayPositionX,iDisplayPositionY);

		}

	return success;

	}

/**

*/

void GP1212A01A::SetPixel(unsigned char aX, unsigned char aY, bool aOn)

	{

	//

	//int byteOffset=(aX*HeightInPixels()+aY)/8;

	//int bitOffset=(aX*HeightInPixels()+aY)%8;

    //iNextFrame[byteOffset] |= ( (aOn?0x01:0x00) << bitOffset );

    if (iOffScreenMode)

        {

        if (aOn)

            {

            iFrameNext->SetBit(aX*HeightInPixels()+aY);

            }

        else

            {

            iFrameNext->ClearBit(aX*HeightInPixels()+aY);

            }

        }

    else

        {

        //Just specify a one pixel block

        SetPixelBlock(aX,aY,0x00,0x01,aOn);

        }

	}

/**

*/

void GP1212A01A::BitBlit(const BitArray& aBitmap, int aSrcWidth, int aSrcHeight, int aTargetX, int aTargetY) const

	{

	//TODO: amend loop values so that we don't keep on looping past our frame buffer dimensions.

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

		{

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

			{

            iFrameNext->SetBitValue((aTargetX+i)*HeightInPixels()+aTargetY+j,aBitmap[+i*aSrcHeight+j]);

			}

		}

	}

/**

Clear our client side back buffer.

Call to SwapBuffers must follow to actually clear the display.

*/

void GP1212A01A::Clear()

    {

    //memset(iNextFrame->Ptr(),0x00,FrameBufferSizeInBytes());

    if (iOffScreenMode)

        {

        iFrameNext->ClearAll();

        }

    else

        {

        SendClearCommand();

        }

    }

/**

Set all pixels on our screen to the desired value.

This operation is performed off screen to avoid tearing.

@param 8 pixels pattern

*/

void GP1212A01A::SetAllPixels(unsigned char aPattern)

	{

	//With a single buffer

	//unsigned char screen[2048]; //One screen worth of pixels

	//memset(screen,0xFF,sizeof(screen));

	//SetPixelBlock(0,0,63,sizeof(screen),screen);

    if (iOffScreenMode)

        {

        memset(iFrameNext->Ptr(),aPattern,FrameBufferSizeInBytes());

        }

    else

        {

        //Using pattern SetPixelBlock variant.

        SetPixelBlock(0,0,63,FrameBufferSizeInBytes(),aPattern);

        }

	//

	}

/**

Set the defined pixel block to the given value.

@param X coordinate of our pixel block starting point.

@param Y coordinate of our pixel block starting point.

@param The height of our pixel block.

@param The size of our pixel data. Number of pixels divided by 8.

@param The value set to 8 pixels used as a pattern.

*/

void GP1212A01A::SetPixelBlock(unsigned char aX, unsigned char aY, int aHeight, int aSize, unsigned char aValue)

	{

	OffScreenTranslation(aX,aY);

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=(aSize<=report.Size()-10?aSize+0x08:64); //Report length. -10 is for our header first 10 bytes. +8 is for our Futaba header size

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=0xF0; //Command ID

    report[5]=aX;   //X

    report[6]=aY;   //Y

    report[7]=aHeight; //Y length before return. Though outside the specs, setting this to zero apparently allows us to modify a single pixel without touching any other.

	report[8]=aSize>>8; //Size of pixel data in bytes (MSB)

	report[9]=aSize;	//Size of pixel data in bytes (LSB)

    int sizeWritten=MIN(aSize,report.Size()-10);

    memset(report.Buffer()+10, aValue, sizeWritten);

    Write(report);

    int remainingSize=aSize;

    //We need to keep on sending our pixel data until we are done

    while (report[1]==64)

        {

        report.Reset();

        remainingSize-=sizeWritten;

        report[0]=0x00; //Report ID

        report[1]=(remainingSize<=report.Size()-2?remainingSize:64); //Report length, should be 64 or the remaining size

        sizeWritten=(report[1]==64?63:report[1]);

        memset(report.Buffer()+2, aValue, sizeWritten);

        Write(report);

        }

	}

/**

Set the defined pixel block to the given value.

@param X coordinate of our pixel block starting point.

@param Y coordinate of our pixel block starting point.

@param The height of our pixel block.

@param The size of our pixel data. Number of pixels divided by 8.

@param Pointer to our pixel data.

*/

void GP1212A01A::SetPixelBlock(unsigned char aX, unsigned char aY, int aHeight, int aSize, unsigned char* aPixels)

    {

	OffScreenTranslation(aX,aY);

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=(aSize<=report.Size()-10?aSize+0x08:64); //Report length. -10 is for our header first 10 bytes. +8 is for our Futaba header size

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=0xF0; //Command ID

    report[5]=aX;   //X

    report[6]=aY;   //Y

    report[7]=aHeight; //Y length before return. Though outside the specs, setting this to zero apparently allows us to modify a single pixel without touching any other.

	report[8]=aSize>>8; //Size of pixel data in bytes (MSB)

	report[9]=aSize;	//Size of pixel data in bytes (LSB)

    int sizeWritten=MIN(aSize,report.Size()-10);

    memcpy(report.Buffer()+10, aPixels, sizeWritten);

    Write(report);

    int remainingSize=aSize;

    //We need to keep on sending our pixel data until we are done

    while (report[1]==64)

        {

        report.Reset();

        remainingSize-=sizeWritten;

        report[0]=0x00; //Report ID

        report[1]=(remainingSize<=report.Size()-2?remainingSize:64); //Report length, should be 64 or the remaining size

        sizeWritten=(report[1]==64?63:report[1]);

        memcpy(report.Buffer()+2, aPixels+(aSize-remainingSize), sizeWritten);

        Write(report);

        }

    }

/**

Using this function is advised against as is causes tearing.

Use Clear instead.

*/

void GP1212A01A::SendClearCommand()

	{

    //1BH,5BH,32H,4AH

    //Send Clear Display Command

	FutabaVfdReport report;

	report[0]=0x00; //Report ID

	report[1]=0x04; //Report length

	report[2]=0x1B; //Command ID

	report[3]=0x5B; //Command ID

	report[4]=0x32; //Command ID

	report[5]=0x4A; //Command ID

	Write(report);

	}

/**

Change our display position within our buffer.

*/

void GP1212A01A::SetDisplayPosition(DW aDw,unsigned char aX, unsigned char aY)

    {

    //1BH,5BH,Dw,Px,Py

    //Send Display Position Settings Command

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=0x05; //Report length

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=aDw;  //Specify our DW

    report[5]=aX;   //X coordinate of our DW top-left corner

    report[6]=aY;   //Y coordinate of our DW top-left corner

    Write(report);

    }

/**

Change our display position within our buffer.

*/

void GP1212A01A::SetDisplayPosition(unsigned char aX, unsigned char aY)

	{

	//Specs apparently says both DW should remain the same

	//Just don't ask

    SetDisplayPosition(GP1212A01A::DW1,aX,aY);

    SetDisplayPosition(GP1212A01A::DW2,aX,aY);

	iDisplayPositionX=aX;

	iDisplayPositionY=aY;

	}

/**

Provide Y coordinate of our off screen buffer.

*/

unsigned char GP1212A01A::OffScreenY() const

	{

	//Overflowing is fine this is just what we want

	return iDisplayPositionY+HeightInPixels();

	}

/**

Put our off screen buffer on screen.

On screen buffer goes off screen.

*/

void GP1212A01A::SwapBuffers()

	{

	//Only perform buffer swapping if off screen mode is enabled

	if (OffScreenMode())

		{

		//Send host back buffer to device back buffer

        if (iNeedFullFrameUpdate<3)

            {

            //TODO: enable this once SendModifiedPixelBlocks works

            //iNeedFullFrameUpdate++;

            SetPixelBlock(0,0,63,FrameBufferSizeInBytes(),iFrameNext->Ptr());

            }

        else

            {

            SendModifiedPixelBlocks();

            }

		//Swap device front and back buffer

		SetDisplayPosition(iDisplayPositionX,OffScreenY());

		//Swap host buffers

        //BitArray* nextFrame=iFrameNext;

        //iFrameCurrent = iFramePrevious;

        //iFrameNext = iFramePrevious;

        BitArray* previousFrame=iFramePrevious;

        iFramePrevious = iFrameCurrent;

        iFrameCurrent = iFrameNext;

        iFrameNext = previousFrame;

		}

	}

/**

 * @brief GP1212A01A::SendModifiedPixelBlocks

 * Compare our back and front buffer and send to the device only the modified pixels.

 * TODO: Get this working at some point.

 */

void GP1212A01A::SendModifiedPixelBlocks()

    {

    //The largest pixel block we can sanely send with one report is 16*16

    //const int KBlocksPerRow = WidthInPixels()/16; //16

    //const int KBlocksPerColumn = HeightInPixels()/16; //4

    int w=WidthInPixels();

    int h=HeightInPixels();

    BitArray block(16*16);

    //TODO: optimize with memcmp and 16 inc

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

        {

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

            {

            //aX*HeightInPixels()+aY

            if ((*iFrameNext)[i*h+j]!=(*iFramePrevious)[i*h+j])

                {

                //We need to update that pixel

                SetPixelBlock(i,j,0,1,((*iFrameNext)[i*h+j]?0x01:0x00));

                //SetDisplayPosition(iDisplayPositionX,OffScreenY());

                //SetDisplayPosition(iDisplayPositionX,OffScreenY());

                //SetPixelBlock(i,j,15,32,iNextFrame->Ptr()+offset);

                }

            }

        }

    /*

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

        {

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

            {

            //aX*HeightInPixels()+aY

            int offset=(i*w/8)+(j/8);

            if (memcmp(iNextFrame->Ptr()+offset,iCurrentFrame->Ptr()+offset,32 )) //32=(16*16/8)

                {

                //We need to update that block

                for (int x=i;x<i+16;x++)

                    {

                    for (int y=i;y<j+16;y++)

                        {

                        block.SetBitValue((x-i)*h+(y-j),(*iNextFrame)[x*h+y]);

                        }

                    }

                SetPixelBlock(i,j,15,32,block.Ptr());

                //SetDisplayPosition(iDisplayPositionX,OffScreenY());

                //SetDisplayPosition(iDisplayPositionX,OffScreenY());

                //SetPixelBlock(i,j,15,32,iNextFrame->Ptr()+offset);

                }

            }

        }

    */

    }

/**

Translate the given pixel coordinate according to our off screen mode.

*/

void GP1212A01A::OffScreenTranslation(unsigned char& aX, unsigned char& aY)

	{

	if (OffScreenMode())

		{

		aX+=WidthInPixels()-iDisplayPositionX;

		aY+=HeightInPixels()-iDisplayPositionY;

		}

	}

/**

*/

void GP1212A01A::ResetBuffers()

	{

    //iNextFrame->ClearAll();

    //memset(iFrameAlpha,0x00,sizeof(iFrameAlpha));

	//memset(iFrameBeta,0x00,sizeof(iFrameBeta));

	}

/**

*/

void GP1212A01A::RequestDeviceId()

    {

    if (RequestPending())

        {

        //Abort silently for now

        return;

        }

    //1BH,5BH,63H,49H,44H

    //Send Read ID command

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=0x05; //Report length

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=0x63; //Command ID

    report[5]=0x49; //Command ID

    report[6]=0x44; //Command ID

    if (Write(report)==report.Size())

        {

        iRequest=ERequestDeviceId;

        }

    }

/**

*/

void GP1212A01A::RequestFirmwareRevision()

    {

    if (RequestPending())

        {

        //Abort silently for now

        return;

        }

    //1BH,5BH,63H,46H,52H

    //Send Software Revision Read Command

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=0x05; //Report length

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=0x63; //Command ID

    report[5]=0x46; //Command ID

    report[6]=0x52; //Command ID

    if (Write(report)==report.Size())

        {

        iRequest=ERequestFirmwareRevision;

        }

    }

/**

*/

void GP1212A01A::RequestPowerSupplyStatus()

    {

    if (RequestPending())

        {

        //Abort silently for now

        return;

        }

    //1BH,5BH,63H,50H,4DH

    //Send Power Suppply Monitor Command

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=0x05; //Report length

    report[2]=0x1B; //Command ID

    report[3]=0x5B; //Command ID

    report[4]=0x63; //Command ID

    report[5]=0x50; //Command ID

    report[6]=0x4D; //Command ID

    if (Write(report)==report.Size())

        {

        iRequest=ERequestPowerSupplyStatus;

        }

    }

/**

This is for development purposes only.

Production application should stick to off-screen mode to avoid tearing.

*/

void GP1212A01A::ToggleOffScreenMode()

	{

    SetOffScreenMode(!iOffScreenMode);

	}

/**

 * @brief GP1212A01A::SetOffScreenMode

 * @param aOn

 * @return

 */

void GP1212A01A::SetOffScreenMode(bool aOn)

    {

    if (aOn==iOffScreenMode)

    {

        //Nothing to do here

        return;

    }

    iOffScreenMode=aOn;

    //Clean up our buffers upon switching modes

    SetDisplayPosition(0,0);

    Clear();

    SwapBuffers();

    Clear();

    }

/**

 */

GP1212A01A::Request GP1212A01A::AttemptRequestCompletion()

    {

    if (!RequestPending())

        {

        return ERequestNone;

        }

    int res=Read(iInputReport);

    if (!res)

        {

        return ERequestNone;

        }

    //Process our request

    if (CurrentRequest()==GP1212A01A::ERequestPowerSupplyStatus)

        {

        if (iInputReport[1]==0x4F && iInputReport[2]==0x4E)

            {

            iPowerOn = true;

            }

        else if (iInputReport[1]==0x4F && iInputReport[2]==0x46 && iInputReport[3]==0x46)

            {

            iPowerOn = false;

            }

        }

    Request completed=iRequest;

    //Our request was completed

    iRequest=ERequestNone;

    return completed;

    }

/**

Set our screen brightness.

@param The desired brightness level. Must be between MinBrightness and MaxBrightness.

*/

void GP1212A01A::SetBrightness(int aBrightness)

    {

    if (aBrightness<MinBrightness()||aBrightness>MaxBrightness())

        {

        //Brightness out of range.

        //Just ignore that request.

        return;

        }

    FutabaVfdReport report;

    report[0]=0x00; //Report ID

    report[1]=0x06; //Report size

    report[2]=0x1B; //Command ID

    report[3]=0x5C; //Command ID

    report[4]=0x3F; //Command ID

    report[5]=0x4C; //Command ID

    report[6]=0x44; //Command ID

    report[7]=0x30+aBrightness; //Brightness level

    Write(report);

    }