/*------------------------------------------------------------------------------
--  This file is a part of the SocExplorer Software
--  Copyright (C) 2011, Plasma Physics Laboratory - CNRS
--
--  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 3 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------*/
/*--                  Author : Alexis Jeandet
--                     Mail : alexis.jeandet@lpp.polytechnique.fr
----------------------------------------------------------------------------*/
#include <socexplorerengine.h>
#include "ahbuartplugin.h"
#include <unistd.h>
#include <errno.h>
#include <QApplication>
#include <QProgressBar>
#include <stdio.h>
#include <QThread>
#include <QCompleter>
#include <QStringList>
#include <QLineEdit>
#include <socexplorerproxy.h>

ahbuartplugin::ahbuartplugin(QWidget *parent):socexplorerplugin(parent,false)
{
    this->port =(rs232port_t)NULL;
    this->portMutex = new QMutex(QMutex::Recursive);
    this->UI = new ahbUartPluginUI();
    this->setWidget((QWidget*)this->UI);
    QObject::connect(this,SIGNAL(activateSig(bool)),this->UI,SLOT(setConnected(bool)));
    QObject::connect(this->UI,SIGNAL(connectPortsig(QString,int)),this,SLOT(togglePort(QString,int)));
//    this->pyObject = new ahbuartPywrapper(this);
//    QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(open(QString,int)),this,SLOT(open(QString,int)));
//    QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(close()),this,SLOT(close()));
//    QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(ReadBytes(uint,uint)),this,SLOT(ReadBytes(uint,uint)));
//    QObject::connect(((ahbuartPywrapper*)this->pyObject),SIGNAL(WriteBytes(uint,QList<QVariant>)),this,SLOT(WriteBytes(uint,QList<QVariant>)));
    QObject::connect(this->UI,SIGNAL(rescanPorts()),this,SLOT(updatePortList()));
    QObject::connect(this,SIGNAL(addReadBytes(int)),this->UI,SLOT(addReadBytes(int)));
    QObject::connect(this,SIGNAL(addWritenBytes(int)),this->UI,SLOT(addWritenBytes(int)));
    this->portListcompleter = NULL;
    this->scanDone = false;
    updatePortList();
}


ahbuartplugin::~ahbuartplugin()
{
    if(this->port!=(rs232port_t)NULL)
    {
        rs232close(this->port);
        this->port = (rs232port_t)NULL;
    }
    this->UI->close();
    this->UI->~ahbUartPluginUI();
}


void ahbuartplugin::closeMe()
{
    if(this->port!=(rs232port_t)NULL)
    {
        rs232close(this->port);
        this->port = (rs232port_t)NULL;
    }
    emit this->closePlugin(this);
}

int ahbuartplugin::registermenu(QMainWindow *menuHolder)
{
    this->menu = menuHolder->menuBar()->addMenu(tr("&AHB UART"));
    this->closeAction = this->menu->addAction(tr("Close plugin"));
    QObject::connect(this->closeAction,SIGNAL(triggered()),this,SLOT(closeMe()));
    return 1;
}


bool ahbuartplugin::checkConnection()
{
    QTime timeout;
    char test[5] ={(char)0x80,(char)0x80,(char)0,(char)0,(char)0};
    char test2[1024];
    int writen =0;
    int read = 0;
    timeout.start();
    SocExplorerEngine::message(this,"Check connection",2);
    QMutexLocker lock(portMutex);
    while(writen!=5)
    {
        writen+=rs232write(this->port,test+writen,5-writen);
        if(timeout.elapsed()>1000)
        {
            SocExplorerEngine::message(this,"Can't write any data on serial port",2);
            return false;
        }
    }
#ifdef WIN32
            usleep(1000);
#endif
    timeout.restart();
    int avail = 0;
    do
    {
        avail = rs232availablebytes(this->port);
        if(timeout.elapsed()>1000)
        {
            if(avail)
                rs232read(this->port,test2,avail);
            SocExplorerEngine::message(this,"Connection Error",2);
            return false;
        }
    }while(avail<4);
    read = rs232read(this->port,test2,avail);
    if(read>0)
    {
        SocExplorerEngine::message(this,"Connection Ok",2);
        return true;
    }
    else
    {
        SocExplorerEngine::message(this,"Connection Error",2);
        return false;
    }
}

void ahbuartplugin::connectPort(QString PortName, int baudrate)
{
    QTime timeout;
    SocExplorerEngine::message(this,"Try to connect to port "+PortName,2);
    timeout.start();
    QMutexLocker lock(portMutex);
    if(this->port==(rs232port_t)NULL)
    {
        SocExplorerEngine::message(this,"Open port "+PortName,2);
        this->port=rs232open((char*)PortName.toStdString().c_str());
    }
    if(this->port!=badPortValue)
    {
        SocExplorerEngine::message(this,"Port opened "+PortName,2);
        SocExplorerEngine::message(this,"Configure port "+PortName,2);
        rs232setup(this->port,8,baudrate,rs232parityNo,rs232OneStop);
        char test[7] ={(char)0x55,(char)0x51,(char)0x80,(char)0x80,(char)0x0,(char)0x0,(char)0x14};
        char test2[1024];
        SAFEWRITE(test,1,timeout,2000,return);
        SAFEWRITE((test+1),1,timeout,2000,return);
        rs232read(this->port,test2,512);
        int read = 0;
        for(int i=0;i<10;i++)
        {
            SocExplorerEngine::message(this,"Send test patern :0x55,0x55,0x80,0x80,0x0,0x0,0x14",2);
            SAFEWRITE(test+2,5,timeout,2000,return);
            SocExplorerEngine::message(this,"Read Result",2);
            read=rs232read(this->port,test2+read,16);
            SocExplorerEngine::message(this,QString("Get ") + QString::number(read) + " bytes",2);
            if(read>0)
            {
                SocExplorerEngine::message(this,"Flush port ",2);
                while(rs232read(this->port,test2,1)>0);
                this->Connected = true;
                SocExplorerEngine::message(this,QString("Connection success on ")+PortName,2);
                emit this->activate(true);
                if(this->scanDone==false)
                {
                    socexplorerproxy::loadChildSysDriver(this,"AMBA_PLUGIN");
                    this->scanDone=true;
                }
                this->UI->setSystemSpeed(this->detectSpeed());
                break;
            }
        }
    }
    else
    {
        SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
        this->port = (rs232port_t)NULL;
        this->Connected = false;
        emit this->activateSig(false);
        return;
    }
    if(this->Connected == false)
    {
        SocExplorerEngine::message(this,QString("Port not opened ")+PortName,2);
        rs232close(this->port);
        this->port = (rs232port_t)NULL;
        emit this->activateSig(false);
    }

}

bool ahbuartplugin::open(QString PortName,int baudrate)
{
    if(this->port!=(rs232port_t)NULL)
        this->close();
    this->UI->setconfig(PortName,baudrate);
    this->connectPort(PortName,baudrate);
    return (this->port!=(rs232port_t)NULL);
}

void ahbuartplugin::close()
{
    if(this->port!=(rs232port_t)NULL)
    {
        rs232close(this->port);
        this->port = (rs232port_t)NULL;
        this->Connected = false;
        emit this->activateSig(false);
    }
}

void ahbuartplugin::togglePort(QString PortName,int baudrate)
{
    if(this->port!=(rs232port_t)NULL)
    {
        this->close();
    }
    else
    {
        this->connectPort(PortName,baudrate);
    }
}


unsigned int ahbuartplugin::Read(unsigned int *Value,unsigned int count,unsigned int address)
{
    QTime timeout;
    timeout.start();
    unsigned int read=0;
    unsigned int cnt=count;
    unsigned int nextUpdateTrig=0,updateStep=1024;
    SocExplorerEngine::message(this,QString("Read ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
    if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
    {
        QMutexLocker lock(portMutex);
        if(!this->checkConnection())
        {
            this->Connected = false;
            emit this->activateSig(false);
            this->portMutex->unlock();
            return 0;
        }
        QProgressBar* progress=NULL;
        if(cnt>128)
            progress= SocExplorerEngine::getProgressBar("Reading on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
        char CMD[5];
        char* result = (char*)malloc(count*4);
        while(count>32)
        {
            CMD[0] = 0x80 |  (32-1);
            CMD[1] = (char)((address>>24)&0xFF);
            CMD[2] = (char)((address>>16)&0xFF);
            CMD[3] = (char)((address>>8)&0xFF);
            CMD[4] = (char)((address)&0xFF);
            SAFEWRITE(CMD,5,timeout,1000,return 0);
            timeout.restart();
            int avail=0;
            do{
                avail=rs232availablebytes(this->port);
                if(timeout.elapsed()>1000)
                {
                    rs232close(this->port);
                    this->port = (rs232port_t)NULL;
                    this->Connected = false;
                    emit this->activateSig(false);
                    return 0;
                }
            }while(avail<(32*4));
            rs232read(this->port,result+((cnt-count)*4),32*4);
            count-=32;
            address+=32*4;
            if(cnt>128)
            {

                if((cnt-count)>=nextUpdateTrig)
                {
                    progress->setValue(cnt-count);
                    qApp->processEvents();
                    nextUpdateTrig+=updateStep;
                }
            }
        }
        if(count>0)
        {
            CMD[0] = 0x80 |  (count-1);
            CMD[1] = (char)((address>>24)&0xFF);
            CMD[2] = (char)((address>>16)&0xFF);
            CMD[3] = (char)((address>>8)&0xFF);
            CMD[4] = (char)((address)&0xFF);
            SAFEWRITE(CMD,5,timeout,1000,return 0);
            timeout.restart();
            int avail=0;
            do{
                avail=rs232availablebytes(this->port);
                if(timeout.elapsed()>1000)
                {
                    rs232close(this->port);
                    this->port = (rs232port_t)NULL;
                    this->Connected = false;
                    emit this->activateSig(false);
                    return 0;
                }
            }while(avail<(count*4));
            rs232read(this->port,result+((cnt-count)*4),count*4);
        }
        if(cnt>128)
        {
            progress->setValue(cnt-count);
            qApp->processEvents();
        }
        for(int i=0;(unsigned int)i<cnt;i++)
        {
#if __BYTE_ORDER == __LITTLE_ENDIAN
//            for(int j =0;j<4;j++)
//            {
//                Value[i]= ((unsigned char)(result[i*4+j])) + Value[i]*256;
//            }
            Value[i]= socexplorerBswap32(((uint32_t*)result)[i]);
#elif __BYTE_ORDER == __BIG_ENDIAN
            Value[i]= ((uint32_t*)result)[i];
#endif
        }
        read = cnt*4;
        if(cnt>128)
            SocExplorerEngine::deleteProgressBar(progress);
        free(result);
    }
    emit this->addReadBytes(read);
    return read/4;
}

unsigned int ahbuartplugin::Write(unsigned int *Value,unsigned int count, unsigned int address)
{
    QTime timeout;
    timeout.start();
    unsigned int writen=0;
    unsigned int nextUpdateTrig=0,updateStep=1024;
    SocExplorerEngine::message(this,QString("Write ")+ QString::number(count) + QString(" words @0x")+ QString::number(address,16),2);
    if((this->port!= badPortValue)||(this->port!=(rs232port_t)NULL))
    {
        QMutexLocker lock(portMutex);
        if(!this->checkConnection())
        {
            emit this->activateSig(false);
            this->Connected = false;
            this->portMutex->unlock();
            return 0;
        }
        QProgressBar* progress = NULL;
        if(count>128)
            progress = SocExplorerEngine::getProgressBar("Writing on uart @0x"+QString::number(address,16)+" %v of "+QString::number(count)+" words ",count);
        int offset = 0;
        char* CMD= (char*)malloc((32*4)+5);
        writen=0;
        while(count>32)
        {
            CMD[0] = 0xC0 |  (32-1);
            CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
            CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
            CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
            CMD[4] = (char)(((unsigned int)address)&0xFF);
            for(int i=0;i<32;i++)
            {
#if __BYTE_ORDER == __LITTLE_ENDIAN
                CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
#elif __BYTE_ORDER == __BIG_ENDIAN
                CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
#endif
            }
            SAFEWRITE(CMD,((32*4)+5),timeout,1000,return 0);
            writen+=32;
            count-=32;
            offset+=32;
            address+=32*4;
            if(offset>=nextUpdateTrig && progress!=NULL)
            {
                progress->setValue(offset);
                qApp->processEvents();
                nextUpdateTrig +=updateStep;
            }

        }
        if(count>0)
        {
            CMD[0] = 0xC0 |  (count-1);
            CMD[1] = (char)(((unsigned int)address>>24)&0xFF);
            CMD[2] = (char)(((unsigned int)address>>16)&0xFF);
            CMD[3] = (char)(((unsigned int)address>>8)&0xFF);
            CMD[4] = (char)(((unsigned int)address)&0xFF);
            for(int i=0;(unsigned int) i<(count);i++)
            {
#if __BYTE_ORDER == __LITTLE_ENDIAN
                CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
                CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset])&0xFF);
#elif __BYTE_ORDER == __BIG_ENDIAN
                CMD[(i*4)+5] = (char)(((unsigned int)Value[i+offset])&0xFF);
                CMD[(i*4)+6] = (char)(((unsigned int)Value[i+offset]>>8)&0xFF);
                CMD[(i*4)+7] = (char)(((unsigned int)Value[i+offset]>>16)&0xFF);
                CMD[(i*4)+8] = (char)(((unsigned int)Value[i+offset]>>24)&0xFF);
#endif
            }
            SAFEWRITE(CMD,((count*4)+5),timeout,1000,return 0);
            writen+=count;
        }
        if(progress!=NULL)
        {
            progress->setValue(writen);
            qApp->processEvents();
            SocExplorerEngine::deleteProgressBar(progress);
        }
        free(CMD);
        emit this->addWritenBytes(writen*4);
        return writen;
    }
    return 0;
}




void ahbuartplugin::updatePortList()
{
    if(this->portListcompleter==(QCompleter*)NULL)
    {
        this->portListcompleter=new QCompleter(this);
        this->portListcompleter->setCaseSensitivity(Qt::CaseInsensitive);
        this->portListcompleterModel = new QStringListModel(this);
        this->portListcompleter->setModel(this->portListcompleterModel);
        this->UI->setCompleter(this->portListcompleter);
    }
    rs232portslist_t* portlist = rs232getportlist();
    rs232portslist_t* portlistenum = portlist;
    QStringList wordList;
    while(portlistenum!=NULL)
    {
        wordList << portlistenum->name;
        portlistenum = portlistenum->next;
    }
    rs232deleteportlist(portlist);
    this->portListcompleterModel->setStringList(wordList);
}

QVariantList ahbuartplugin::ReadBytes(unsigned int address, unsigned int count)
{
    unsigned int data[(count/4)+1];
    QVariantList result;
    this->Read(data,(count/4)+1,address);
    for(unsigned int i = 0;i<count/4;i++)
    {
        result.append(QVariant((int)(0x0FF&(data[i]>>24))));
        result.append(QVariant((int)(0x0FF&(data[i]>>16))));
        result.append(QVariant((int)(0x0FF&(data[i]>>8))));
        result.append(QVariant((int)(0x0FF&(data[i]))));
    }

    for(int i=0;i<(count%4);i++)
    {
        result.append(QVariant((int)(0x0FF&(data[count/4]>>((3-i)*8)))));
    }

    return result;
}

void ahbuartplugin::WriteBytes(unsigned int address, QList<QVariant> dataList)
{
    unsigned int data[dataList.count()/4];
    for(int i = 0;i<(dataList.count()/4);i++)
    {
        data[i] = 0x0FF & ((unsigned int)dataList.at(4*i).toUInt());
        data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+1).toUInt()));
        data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+2).toUInt()));
        data[i] =  (data[i]<<8) + (0x0FF & ((unsigned int)dataList.at((4*i)+3).toUInt()));
    }
    this->Write(data,dataList.count()/4,address);
}

int ahbuartplugin::detectSpeed()
{
    //scaler = (((system_clk*10)/(baudrate*8))-5)/10
    unsigned int ahbUartBaseAddress = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01,0x007,0);
//    unsigned int dsuBaseAddress = SocExplorerEngine::self()->getEnumDeviceBaseAddress(this,0x01,0x0017,0);
    unsigned int dsuBaseAddress = 0x90000000;
    unsigned int scaler = 0,dsuVal1=0,dsuVal2=0;
    int speed=0;
    QElapsedTimer time;
    if(dsuBaseAddress!=-1)
    {
        time.start();
        if( this->Read(&dsuVal1,1,dsuBaseAddress+0x08)==1)
        {
            usleep(1000*1000);
            qint64 el = time.elapsed();
            this->Read(&dsuVal2,1,dsuBaseAddress+0x08);
            if(dsuVal1!=dsuVal2)
                return ((dsuVal2-dsuVal1)/el)*1000;
        }
    }
    if(ahbUartBaseAddress!=-1)
    {
        if( this->Read(&scaler,1,ahbUartBaseAddress+0x0C)==1)
        {
            scaler&=0x3FFFF;
            speed = (int)(((double)scaler*10.0)+5.0)*((double)this->UI->baudRate()/10.0)*8.0;
//            speed = (int)((double)(scaler+1)*8.0*(double)this->UI->baudRate());
        }
    }
    return speed;
}

void ahbuartplugin::postInstantiationTrigger()
{
    if(this->scanDone && this->Connected)
    {
        this->UI->setSystemSpeed(this->detectSpeed());
    }
}