#include "qggrifobeamupform.h"
#include "ui_qggrifobeamupform.h"

#include <qgnetworkinterface.h>
#include "qgpropertywidget.h"

#include <QTreeWidgetItem>
#include <QGridLayout>
#include <QCheckBox>

#include <QHostInfo>
#include <QHostAddress>
#include <QNetworkInterface>

#include <QFileDialog>
#include <QDir>
#include <QUrl>
#include <QMessageBox>

#include <QDebug>
#include <QSettings>

#include <QDropEvent>
#include <QDragEnterEvent>
#include <QMimeData>
#include <QStyle>

#include "qzip.h"

#include "bsk_tftp_pfs.h"

#include <QRegExp>

#include "downloadablefile.h"

#include "mydebug.h"

#include "historydbform.h"

enum fpga_t
{
    fpga_no_specific = 0,
    fpga_carrier1_fpga1 = 1,
    fpga_carrier1_fpga2 = 2,
    fpga_carrier2_fpga1 = 3,
    fpga_carrier2_fpga2 = 4,
    fpga_digital_ctrl = 5
};

QString ShowFileInfo(const QString& fname, bool popup=true);

static QString probeNetworks(const QString& prefered_net, QComboBox* cb)
{
    unsigned int prefered_index=0;
    static bool privateSubnet=false;
    static QString preferedNetwork("127.0.0.1");

    if (!prefered_net.isEmpty())
        preferedNetwork=prefered_net;

    QHostInfo hi=QHostInfo::fromName(QHostInfo::localHostName());
    //ui->groupBox->setTitle(QString("Host: %1").arg(hi.hostName()));
    QList<QNetworkInterface> hal=QNetworkInterface::allInterfaces();
    if (hal.isEmpty())
    {
        MyDebug().logMsg(type_log_error,
                         origin_msg_generic,
                         "Network Config: NO HOST ADDRESSES");
        cb->addItem("<No Interface>");
        cb->setEnabled(false);
    }
    else
    {
        foreach(QNetworkInterface nif, hal)
        {
            //QList<QHostAddress> nhal=nif.allAddresses();
            QList<QNetworkAddressEntry> nhal=nif.addressEntries();
            foreach(QNetworkAddressEntry aentry, nhal)
            {
                bool private_subnet=false;

                QHostAddress a=aentry.ip();

                if (!(a.toString().startsWith("192.168") ||
                      a.toString().startsWith("169.254") ||
                      a.toString().startsWith("127.")))
                    continue;

                cb->addItem(QString("%1 (%2) [%3]").arg(nif.humanReadableName()).arg(a.toString()).arg(nif.index()), a.toString());
                int currentIndex=cb->count()-1;
                //if (a.toString().startsWith("192.168.0") ||a.toString().startsWith("192.168.2"))
                if (a.toString().startsWith(preferedNetwork))
                {
                    prefered_index=currentIndex;
                    private_subnet=true;
                    privateSubnet=privateSubnet;
                }
                cb->setItemData(currentIndex, private_subnet, Qt::UserRole+1);
                cb->setItemData(currentIndex, nif.index(), Qt::UserRole+2);

                //ui->comboBoxInterface->seIif (nif.flags() & QNetworkInterface::IsUp)
            }
        }
        if (prefered_index)
            cb->setCurrentIndex(prefered_index);
    }
    return hi.hostName();
}

#define MAX_TARGETS 64
struct targets_t
{
    unsigned int valid;
    QgGrifoDownloadSite sites[MAX_TARGETS];
};

static targets_t targets;

struct PgmSteps
{
    QLabel* lbl;
    QCheckBox* chk;
};
static PgmSteps pgmSteps[10];

QgGrifoBeamUpForm::QgGrifoBeamUpForm(QWidget *parent) :
    QWidget(parent),
    props(QgGrifoBeamupProperties::instance()),
    ui(new Ui::QgGrifoBeamUpForm),
    settings("./grifo_beamup.ini", QSettings::IniFormat)
{
    QStyle* st=QApplication::style();

    ui->setupUi(this);

    ui->tbRefresh->setIcon(st->standardIcon(QStyle::SP_DriveNetIcon)  //SP_BrowserReload)
                //QIcon(":/qt-project.org/styles/commonstyle/images/refresh-32.png")
                );

    ui->tbFileSelect->setIcon(st->standardIcon(QStyle::SP_FileIcon)
                //QIcon(":/qt-project.org/styles/commonstyle/images/standardbutton-open-32.png")
//":/qt-project.orqg/styles/commonstyle/images/file-32.png"
//":/qt-project.org/styles/commonstyle/images/filecontents-128.png"
    );

    ui->tbGo->setIcon(st->standardIcon(QStyle::SP_ArrowUp)
                //QIcon(":/qt-project.org/styles/commonstyle/images/up-32.png"
                      );

    ui->tbDropSelect->setIcon(st->standardIcon(QStyle::SP_FileDialogNewFolder)
                              //QIcon(":/qt-project.org/styles/commonstyle/images/newdirectory-32.png")
                                  );

    ui->tbSettings->setIcon(st->standardIcon(QStyle::SP_FileDialogListView)
                //QIcon(":/qt-project.org/styles/commonstyle/images/viewlist-32.png")
                                );

    ui->tbFileInfo->setIcon(st->standardIcon(QStyle::SP_FileDialogInfoView)
                //QIcon(":/qt-project.org/styles/commonstyle/images/viewdetailed-32.png")
                                  );

    entitiesForm=new QgGrifoDownloadEntitiesForm;

    int ipos=ui->verticalLayout->indexOf(ui->placeholder);
    ui->verticalLayout->insertWidget(ipos, entitiesForm);
    ui->placeholder->setVisible(false);

    ui->leMsg->setMaximumBlockCount(100);

    entitiesForm->setVisible(false);

    //QString host=populateNetworks(ui->cbNetowrkSelection);
    {
        QHostInfo hi=QHostInfo::fromName(QHostInfo::localHostName());
        QString host=QString("Host: %1").arg(hi.hostName());

        ui->hostName->setText(host);
    }

    ui->progressBar->setValue(0);
    ui->progressBar->setEnabled(false);
    ui->progressBar->setTextVisible(false);
    //setState(1);

    fileSelector.setObjectName("GrifoBeamUpFileSelector");
    fileSelector.setOption(QFileDialog::ReadOnly, true);

    fileSelector.setViewMode(QFileDialog::Detail);
    fileSelector.setNameFilters(
                QStringList()<<"archive (*.zip)"<<"Binary (*.bin)"<<"ELF (*.elf *.out)"<<"Any files (*)");

    connect(ui->tbFileSelect, &QToolButton::clicked, this,
            [this](bool)
    {
        QString tmp=fileSelector.directory().absolutePath();
        fileSelector.setOption(QFileDialog::ReadOnly, true);
        fileSelector.setFileMode(QFileDialog::AnyFile);
        fileSelector.setDirectory(tmp);

        if (fileSelector.exec())
        {
            ui->leFile->setText(fileSelector.selectedFiles().at(0));
            //stateReady();
            selectByFile(fileSelector.selectedFiles().at(0));
        }
    }
            );
    connect(ui->tbDropSelect, &QToolButton::clicked, this,
            [this](bool)
    {
        fileSelector.setFileMode(QFileDialog::Directory);
        if (fileSelector.exec())
        {
            selectWatchDir(fileSelector.selectedFiles().at(0));
            //ui->leDir->setText(fileSelector.selectedFiles().at(0));
            //fileWatcher.removePath(fileWatcher.)
            //fileWatcher.addPath(fileSelector.selectedFiles().at(0));
        }
    });

    connect(&fileWatcher, &QFileSystemWatcher::directoryChanged, this, &QgGrifoBeamUpForm::updateWatchedDirectory);
    connect(&fileWatcher, &QFileSystemWatcher::fileChanged, this, &QgGrifoBeamUpForm::updateWatchedFile);

    connect(ui->tbGo, &QToolButton::clicked, this, &QgGrifoBeamUpForm::uploadGo);
#if 0
    connect(&tftp, &QgGrifoBeamUpTftp::progressInfo, this,
            [this](int n, const QString& msg)
    {
        if (n==-1)
            ui->progressBar->setRange(0, 0);
        else
        {
            ui->progressBar->setRange(0, 100);
            ui->progressBar->setValue(n);
        }
        ui->progressLabel->setText(msg);
    });
    connect(&tftp, &QgGrifoBeamUpTftp::sendTerminated, this,
            [this]()
    {
        ui->progressBar->setRange(0, 100);
        ui->progressBar->setValue(100);
        showMessage("Completed"); //ui->progressLabel->setText("Completed");
        stateReady();
    });

    connect(&tftp, &QgGrifoBeamUpTftp::transferError, this,
            [this](int code, const QString& msg)
    {
        showMessage(QString("%1 (%2)").arg(msg).arg(code)); //ui->progressLabel->setText(QString("%1 (%2)").arg(msg).arg(code));
        ui->progressBar->reset();
        ui->progressBar->setRange(0, 100);
        ui->progressBar->setValue(0);
        ui->progressBar->setEnabled(false);
        QMessageBox::critical(this, QString(), QString("Transfer Error: %1 (%2)").arg(msg).arg(code));
        stateReady();        
    });

    connect(&tftp, &QgGrifoBeamUpTftp::serverHello, this,
            [this](unsigned int ip, int port, const QString& msg)
    {
        ui->leMsg->appendPlainText(msg); //setText(msg);
        serverHello(ip, port, msg);
    });
#endif

    //general configuration of app
    {
        QSettings& s=settings;//("./grifo_beamup.ini", QSettings::IniFormat);
        s.beginGroup("GrifoBeamUp");
        QString prefnet=s.value("preferedNetwork", QString("$127.0.0")).toString();
        if (prefnet.startsWith('$'))
            prefnet=prefnet.remove('$');

        probeNetworks(prefnet, ui->cbNetwork);

        QgNetworkInterface::setNetworkIP(prefnet);

        ui->leFile->setText(s.value("file", QString()).toString());
        fileSelector.restoreState(s.value("fileselector").toByteArray());
        s.endGroup();
    }


#if 0
    tftp.bind(QHostAddress(QgNetworkInterface::networkIP()));

    ui->tbNetwork->setText(netDlg->hostNetworkName());
    QgNetworkInterface::setNetworkIP(netDlg->hostAddress());

    connect(ui->tbNetwork, &QToolButton::clicked, this,
            [this](bool)
    {
        netDlg->exec();
        if (netDlg->result()==QDialog::Accepted)
        {
            QgNetworkInterface::setNetworkInterface(QHostAddress(netDlg->hostAddress()));
            ui->tbNetwork->setText(netDlg->hostNetworkName()); //QgNetworkInterface::networkIP());
        }
    });
#endif

    connect(ui->tbRefresh, &QToolButton::clicked, this,
            [this](bool)
    {
        refreshServers();
    });

    connect(ui->tbSettings, &QToolButton::clicked, this,
            [this](bool)
    {
        static QgPropertyDialog dlg(&props, this);
        dlg.show();

    });

    props.restoreSettings(settings);

    if (!props.property("lastDirectory").toString().isEmpty())
        fileSelector.setDirectory(props.property("lastDirectory").toString());

    pingTimer.setSingleShot(true);
    pingTimer.setInterval(2000);
    connect(&pingTimer, &QTimer::timeout, this,
            [this]()
    {
       ui->tbRefresh->setEnabled(true);
    });

    ui->cbTarget->setDuplicatesEnabled(false);
    ui->cbPartition->setDuplicatesEnabled(false);

    ui->cbTarget->addItem(QgNetworkInterface::networkIP()+":"+QString("%1").arg(props.property("tftpFirstPort").toInt()));

    connect(entitiesForm, &QgGrifoDownloadEntitiesForm::itemSelected, this,
            [this](void*xs, void*xp)
    {
            bsk_download_site_t* s=(bsk_download_site_t*)xs;
            bsk_download_partition_t* p=(bsk_download_partition_t*)xp;
            updateSelected(s, p);
    });

    stateReady();

    /*
     * Configuration target from file
    */
    readConfigFile();

    programmer=new FgpaProgrammer;

    connect(ui->leFile, &QLineEdit::editingFinished, this,
            [this]()
    {
        selectByFile(ui->leFile->text());
    });

    selectWatchDir(props.property("watchedDirectory").toString());

    setAcceptDrops(true);

    ui->groupBox->setEnabled(false);

    connect(entitiesForm, &QgGrifoDownloadEntitiesForm::fileDroppped, this, [this](QTreeWidgetItem* i, const QString& name)
    {
        selectByFile(name, i);
    });

    {
        QGridLayout* g=ui->gridLayout_2;
        for(int i=0; i<7; ++i)
        {
            pgmSteps[i].chk=new QCheckBox;
            if (i<1)
                pgmSteps[i].chk->setChecked(false);
            else
                pgmSteps[i].chk->setChecked(true);

            pgmSteps[i].lbl=new QLabel("...");
            g->addWidget(pgmSteps[i].chk, i+1, 0);
            g->addWidget(pgmSteps[i].lbl, i+1, 2);
        }
    }

    connect(programmer, &FgpaProgrammer::statusChanged, this, &QgGrifoBeamUpForm::statusUpdated, Qt::QueuedConnection);

    programmer->setSimulate(ui->cbSimulate->isChecked());
    programmer->setSRIOMemory(ui->cb_TargetAddress->isChecked());


    _dbHistory = dbHistory::instance();

    QHostInfo hi=QHostInfo::fromName(QHostInfo::localHostName());
    _dbHistory->setParam(hi.hostName());
    _dbHistory->refreshList();
}

QgGrifoBeamUpForm::~QgGrifoBeamUpForm()
{
    delete ui;
}



void QgGrifoBeamUpForm::updateSelected(const bsk_download_site_t* site,const bsk_download_partition_t* p)
{
    if (!site)
        return;

    MyDebug().logMsg(type_log_info,
                     origin_msg_generic,
                     QString("select: %1 %2").arg(site->name).arg(p->name));
    int ti=-1;
    for(int i=0; i<ui->cbTarget->count(); ++i)
    {
        bsk_download_site_t* is=(bsk_download_site_t*)ui->cbTarget->itemData(i).toULongLong();
        if (is==site)
        {
            ti=i;
            break;
        }
    }
    if (ti<0)
    {
        return;
    }
    ui->cbTarget->setCurrentIndex(ti);
    ui->cbPartition->clear();
    for(int i=0; i<bsk_download_site_t::k_max_partitions; ++i)
    {
        if (site->partitions[i].name[0]==0)
            break;
        ui->cbPartition->addItem(site->partitions[i].name, (unsigned long long)&site->partitions[i]);
    }
    ui->cbPartition->addItem("", 0);
    ui->cbPartition->setCurrentIndex(ui->cbPartition->count()-1);
    if (p)
    {
        for(int i=0; i<ui->cbPartition->count(); ++i)
        {
            if (ui->cbPartition->itemData(i).toULongLong()==(unsigned long long)p)
            {
                ui->cbPartition->setCurrentIndex(i);
            }
        }
    }

    if(_dbHistory != NULL)
    {
        delete _dbHistory;
        _dbHistory = NULL;
    }
}
#include <QProgressBar>

void QgGrifoBeamUpForm::selectByFile(const QString& fname, QTreeWidgetItem*)
{
    QFileInfo finfo(fname);
    QString n=finfo.fileName();

    DownloadableFile df;
    df.open(fname);
    BinaryFileInfo bfi=df.info();

    const TgtMatch* m=tgtMatchSet.lookup(n);
    if (m==0)
        m=tgtMatchSet.lookupArch(bfi.binaryInfo.archName());

    if (m)
    {
        bsk_download_site_t* s=0;
        bsk_download_partition_t* p=0;

        if (m->wi)
        {
            bool valid=bfi.binaryInfo.archName()==m->archName;

            m->wi->setDisabled(!valid);
            if (!valid)
                m->wi->setText(3, "Invadid format: "+finfo.fileName());
            else
                m->wi->setText(3, finfo.fileName());

            m->wi->setToolTip(3, finfo.absoluteFilePath()+ShowFileInfo(fname, false));
            QWidget* tmp=m->wi->treeWidget()->itemWidget(m->wi, 2);
            if (tmp)
            {
                QProgressBar* b=qobject_cast<QProgressBar*>(tmp);
                b->setVisible(true);
                b->setValue(0);
                //b->setFormat("pending");
            }
        }

        for(int i=0; i<ui->cbTarget->count(); ++i)
        {
            unsigned long long raws=ui->cbTarget->itemData(i).toULongLong();
            if (!raws)
            {
                continue;
            }
            s=(bsk_download_site_t*)raws;
            if (m->tgtName.compare(s->name, Qt::CaseInsensitive)!=0)
            {
                s=0;
                continue;
            }
            for(int j=0; j<bsk_download_site_t::k_max_partitions; ++j)
            {
                if (m->partName.compare(s->partitions[j].name))
                    break;
                if (m->partName.compare(s->partitions[j].name, Qt::CaseInsensitive)==0)
                {
                    p=(bsk_download_partition_t*)&s->partitions[j];
                    updateSelected(s, p);
                    //break;
                }
            }
            //break;
        }
        //updateSelected(s, p);
    }
}

void QgGrifoBeamUpForm::refreshServers()
{
    if (ui->cbNetwork->count()<1)
        return;

    if (ui->cbNetwork->isEnabled())
    {
        QString ip=ui->cbNetwork->itemData(ui->cbNetwork->currentIndex()).toString();

        bool match=ip.startsWith("127.0.", Qt::CaseInsensitive);

        if (match)
        {
            tftp.bindRemote(QHostAddress("127.0.0.1"), 50069);
            ui->cbTarget->setCurrentText(QString("%1:%2").arg("127.0.0.1").arg(50069));
        }
        else
        {
            tftp.bindRemote(QHostAddress(default_ip), 50069);
            ui->cbTarget->setCurrentText(QString("%1:%2").arg(default_ip).arg(50069));
        }

        QgNetworkInterface::setNetworkInterface(QHostAddress(ip));

        QgNetworkInterface::setNetworkIP(ip);
        MyDebug().logMsg(type_log_info,
                         origin_msg_tftp,
                         QString("%1").arg(QgNetworkInterface::networkIP()));
        tftp.bind(QHostAddress(QgNetworkInterface::networkIP()));
        ui->cbNetwork->setEnabled(false);
        ui->groupBox->setEnabled(true);
    }

    ui->tbRefresh->setEnabled(false);

    programmer->setTftp(&tftp);
#if 0
    entitiesForm->clear();
    ui->cbTarget->clear();
    ui->cbPartition->clear();

    ui->cbPartition->addItem("", 0);
    targets.valid=0;

    int last=props.property("tftpLastPort").toInt();
    for(int i=props.property("tftpFirstPort").toInt(); i<=last; ++i)
    {
        MyDebug()<<"Ping server:"<<i;
        tftp.pingServer(i);
    }
    pingTimer.start();
#endif
}

void QgGrifoBeamUpForm::serverHello(unsigned int /*ip*/, int /*port*/, const QString &/*msg*/)
{
#if 0
    QgGrifoDownloadSite* s=&targets.sites[targets.valid];

    memset(&s->site, 0, sizeof s->site);
    bsk_download_site_t* site=&s->site;

    int r=bsk_tftp_mfs_decode_site(site, msg.toLatin1().constData());

    site->media_address=ip;
    site->media_port=port;
    s->tgt=0;

    if (r==0)
    {
        TgtMatch* tgt=tgtMatchSet.lookupCSCI(site->name, site->address);
        if (tgt)
            s->tgt=tgt; //appName=tgt->appName;

        entitiesForm->addSite(s);
        QHostAddress ha(site->media_address);
        QString n=QString("%1:%2/%3").arg(ha.toString()).arg(site->media_port).arg(site->name);
        ui->cbTarget->addItem(n, (quint64)site);

        ++targets.valid;

        for(int i=0; i<bsk_download_site_t::k_max_partitions; ++i)
        {
            if (site->partitions[i].name[0]==0)
                break;

            QString queryStr=QString("$PGM:%1/$version$").arg(site->partitions[i].name);
            tftp.queryVersion(ip, port, queryStr);
        }
        pingTimer.start();
    }
    entitiesForm->setVisible(true);
#endif
}

void QgGrifoBeamUpForm::partitionUpdate(unsigned int /*ip*/, int /*port*/, const QString& /*msg*/)
{
}

void QgGrifoBeamUpForm::saveSettings()
{
    {
        QSettings& s=settings; //("./grifo_beamup.ini", QSettings::IniFormat);
        s.beginGroup("GrifoBeamUp");
        s.setValue("preferedNetwork", QString('$')+QgNetworkInterface::networkIP());
        s.setValue("file", ui->leFile->text());
        s.setValue("fileselector", fileSelector.saveState());
        props.setProperty("lastDirectory", fileSelector.directory().absolutePath());
        s.setValue("dirHistory", fileSelector.history());
        s.endGroup();

        props.saveSettings(settings);
    }
}

void QgGrifoBeamUpForm::updateWatchedDirectory(const QString& path)
{
    QDir dir(path);
    QStringList currentList=dir.entryList();
    QStringList changed;

    foreach(QString s, currentList)
    {
        bool hit=watchedFiles.contains(s);
        if (!hit)
            changed.append(s);
    }

    watchedFiles=currentList;

    MyDebug().logMsg(type_log_info,
                     origin_msg_generic,
                     QString("Directory update: %1 %2").arg(path).arg(changed.count()));

    if (changed.size()>0)
    {
        for(int i=0; i<changed.size(); ++i)
        {
            addPendingList(dir.absoluteFilePath(changed.at(0)));
            //ui->leFile->setText(dir.absoluteFilePath(changed.at(0)));
        }
    }
}

void QgGrifoBeamUpForm::updateWatchedFile(const QString& path)
{
    MyDebug().logMsg(type_log_info,
                     origin_msg_generic,
                     QString("File update: %1").arg(path));

}

void QgGrifoBeamUpForm::setState(int s)
{
    state=s;
    bool enable=false;
    if (state==0)
    {
        enable=true;
        //ui->cbNetowrkSelection->setEnabled(false);
        ui->tbGo->setText("Upload...");
    }
    else
        ui->tbGo->setText("Break...");

    //ui->tbNetwork->setEnabled(enable);
    ui->tbRefresh->setEnabled(enable);
    //ui->tbGo->setEnabled(enable);
    ui->tbFileSelect->setEnabled(enable);
    ui->tbDropSelect->setEnabled(enable);
    ui->leFile->setEnabled(enable);
    //ui->leDir->setEnabled(enable);
    ui->cbPartition->setEnabled(enable);
    ui->cbTarget->setEnabled(enable);

    entitiesForm->setEnabled(enable);

    if (enable)
    {
        if (ui->progressBar->minimum()==ui->progressBar->maximum())
        {
            ui->progressBar->setRange(0, 100);
            ui->progressBar->setValue(0);
            ui->progressBar->setEnabled(false);
        }
    }
    ui->groupBox->setEnabled(enable);
}

void QgGrifoBeamUpForm::stateReady()
{
    setState(0);
    if (pendingList.count())
    {
        QString tmp=pendingList.at(0);
        pendingList.pop_front();
        if (tmp.isEmpty())
        {
            return;
        }
        ui->leFile->setText(tmp);
        selectByFile(tmp);
        uploadGo();
    }
}

void QgGrifoBeamUpForm::stateBusy()
{
    setState(1);
}


void QgGrifoBeamUpForm::uploadGo()
{
    if (state!=0)
    {
        /*int r=*/QMessageBox::question(this, QString(), QString("Break operation?"));
        return;
    }
    int n=ui->cbTarget->currentIndex();

    //controlla se è stato selezionato un indirizzo target valido
    if (n<0)
    {
        ui->progressLabel->setText("Target not selected");
        QMessageBox::information(this, QString(), QString("File not selected"));
        return;
    }

    //controlla se il file da spedire è leggibile
    QFileInfo finfo(ui->leFile->text());
    if (!finfo.isReadable())
    {
        QMessageBox::critical(this, QString(), QString("File not readable"));
        return;
    }

    //controlla se l'indirizzo ftp del server a cui collegarci è valido
    QString tgtStr=ui->cbTarget->currentText();
    tgtStr="ftp://"+ui->cbTarget->currentText();
    QUrl url(tgtStr);
    if (!url.isValid())
    {
        QString msg=QString("Invalid URL %1").arg(tgtStr);
        ui->progressLabel->setText(msg);
        QMessageBox::critical(this, QString(), msg);
        return;
    }

    //apertura connessione con server tftp remoto
    QHostAddress ha(url.host());
    int port=url.port();
    tftp.bindRemote(ha, port);

    //ui->progressLabel->setText(tmp);
    {
        MyDebug().logMsg(type_log_info,
                         origin_msg_generic,
                         QString("Upload to %1 %2@%3:%4...").arg(tgtStr).arg("?").arg(ha.toString()).arg(port));
    }

    QString partName;
    n=ui->cbPartition->currentIndex();
    if (n>=0)
    {
        unsigned long long p=ui->cbPartition->currentData().toULongLong();
        if (p && !ui->cbPartition->currentText().isEmpty())
            partName="$PGM:"+ui->cbPartition->currentText()+"/%1";
    }

    if (partName=="")
    {
        partName ="$PGM:uploadfile/%1";
    }
    QString fnameStr=finfo.fileName();
#if 0
    {
        QZipReader zip(ui->leFile->text());
        QList<QZipReader::FileInfo> zlst=zip.fileInfoList();
        if(zlst.size())
        {
          QString tmpname=zlst.at(0).filePath;
          //standardDialog()->setFileInfo(QString("%1 (%2)").arg(tmpname).arg(params.simplifiedFileName));
          fnameStr+="("+tmpname+")";
        }
    }
#endif
    QString opmsg=QString("%1 -> %2/%3").arg(fnameStr).arg(ui->cbTarget->currentText()).arg(partName);

    showMessage(opmsg);

    int qr=QMessageBox::question(this, QString(), opmsg, QMessageBox::Yes|QMessageBox::No|QMessageBox::Abort);
    if (qr!=QMessageBox::Yes)
    {
        if (qr==QMessageBox::Abort)
            pendingList.clear();
        return;
    }

    //ui->progressLabel->setText("Upload start...");

    bool ok=tftp.sendFile(ui->leFile->text(), partName);

    //ui->tbNetwork->setEnabled(false);

    ui->lbOperation->setText(opmsg);
    if (ok)
    {
        stateBusy();
        //ui->tbGo->setEnabled(false);
        ui->progressBar->reset();
        ui->progressBar->setRange(0, 0);
        ui->progressBar->setEnabled(true);
    }
}

void QgGrifoBeamUpForm::dragEnterEvent(QDragEnterEvent * event)
{
    if (event->mimeData()->hasUrls())
    {
        QList<QUrl> lst=event->mimeData()->urls();
        if ((lst.size()>0) && lst.size()<10)
        {
            //if (lst.at(0).isLocalFile())
              event->acceptProposedAction();
        }
    }
}

void QgGrifoBeamUpForm::dropEvent(QDropEvent * event)
{
    QList<QUrl> lst=event->mimeData()->urls();
    if (lst.size()>0)
    {
        for(int i=0; i<lst.size(); ++i)
        {
            if (lst.at(i).isLocalFile())
            {
                //ui->leFile->setText(lst.at(0).path());
                //selectByFile(lst.at(0).path());

                addPendingList(lst.at(i).toLocalFile());
            }
        }
    }
}

void QgGrifoBeamUpForm::selectWatchDir(const QString& dName)
{
    if (dName.isEmpty())
        return;

    QDir dir(dName);
    if (!dir.isReadable())
        return;

    ui->leDir->setText(dName);
    fileWatcher.removePaths(fileWatcher.directories());
    fileWatcher.addPath(dName);
    props.setProperty("watchedDirectory", dName);
    watchedFiles.clear();
    watchedFiles=dir.entryList(QDir::Files|QDir::NoDotAndDotDot);
}

void QgGrifoBeamUpForm::addPendingList(const QString& file)
{
    pendingList.append(file);

    if (state==0)
    {
        stateReady();
        //ui->leFile->setText(lst.at(0).path());
        selectByFile(file); //lst.at(0).path());
        //uploadGo();
    }
}

void QgGrifoBeamUpForm::showMessage(const QString& msg)
{
    ui->progressLabel->setText(msg);
    ui->leMsg->appendPlainText(msg);
}

QString ShowFileInfo(const QString& fname, bool popup)
{
    DownloadableFile df;
    df.open(fname);
    BinaryFileInfo bfi=df.info();
    BinaryInfo bi=bfi.binaryInfo;
    QString infoText=
            "File: "+bfi.filename+"<p/>\n"
            +"&emsp;&emsp;Size: "+QString("%1").arg(bfi.uncompressed_size)+" ("+QString("%1").arg(bfi.compressed_size)+")<p/>\n"
            +"&emsp;&emsp;Container hash: "+bfi.file_md5+"<p/><p/>\n"
            +"File CRC32: "+QString("%1").arg(bfi.zip_crc32, 0, 16).toUpper()+"<p/>\n";

    infoText+=
            "  Name: <b>"+bi.m_name+"</b><p/>\n"
            +"  Version: <b>"+bi.m_version+" "+bi.m_bid+"</b><p/>\n"
            +"  Date: <b>"+bi.m_date+"</b><p/>\n"
            +"  IBC: "+bi.m_ibc+"<p/>\n"
            +"  P/N: "+bi.m_pn+"<p/>\n"
            +"  Part Type: "+bi.m_partType+"<p/>\n"
            +"  Architecture: "+bi.m_pn+" - "+bi.m_archName+"<p/>\n"
            +"  Format: "+bi.m_fmtName+"<p/>\n"
            +"  Generator: "+bi.m_generator+"<p/>\n"
            //+"  Version: "+bi.m_bid+"<p/>\n"
            +"  Info: "+bi.m_usr+"<p/>\n"
            +"  Host: "+bi.m_host+"<p/>\n"
            +"  Signature: "+bi.m_md5+"<p/>\n";

    if (popup)
        QMessageBox::information(0, "File: "+QString("</p>")+bfi.sourcefile, infoText);
    return infoText;
}

void QgGrifoBeamUpForm::on_tbFileInfo_clicked()
{
    ShowFileInfo(ui->leFile->text());
}



void QgGrifoBeamUpForm::on_btnStart_clicked(bool checked)
{

    //indivisuare il profilo da usare per le operazione di programmazione
    if (!getProfile(ui->sbSectorSize->value(),ui->sbBase->value()))
    {
        //profile not valid to program
        return;
    }

    profile.writeRamp = (ui->cbWriteRamp->checkState()==Qt::Checked);
    profile.verifyFinal = (ui->cbVerifyAll->checkState()==Qt::Checked);
    profile.verifySector = (ui->cbVerifySector->checkState()==Qt::Checked);
    profile.FileToSend = ui->leFile->text();

    QString address = QString("%1-%2").arg(profile.address_start_area).arg(profile.address_stop_area);
    QString srio = QString("%1@%2:%3").arg(profile.slotAddress).arg(profile.ip).arg(profile.port);
    int spi = int(profile.spiport);

    _dbHistory->addNewFile(profile.FileToSend,
                           db_error_no_error,
                           profile.fName,
                           db_status_started,
                           address,
                           srio,
                           spi);

    if (ui->cbSimulate->checkState()==Qt::Checked)
    {
        //è simulazione con dati di test
        if (checked)
            programmer->start(1, ui->sbSectorSize->value(), ui->sbBase->value());
        else
            programmer->start(0, ui->sbSectorSize->value(), ui->sbBase->value());
    }
    else
    {
        //non è simulazione
        programmer->start(profile);
    }
}

void QgGrifoBeamUpForm::statusUpdated(int sts, int progress, const QString& msg)
{
    pgmSteps[sts].lbl->setText(msg);
    if (progress>0)
        ui->progressBar->setValue(progress);
    else if (progress==0)
    {

    }
    else
    {
    }
}

void QgGrifoBeamUpForm::on_btnStart_clicked()
{

}

/*void QgGrifoBeamUpForm::on_pushButton_2_clicked()
{

}*/

/*void QgGrifoBeamUpForm::on_cbFPGA_currentIndexChanged(int index)
{

}*/

void QgGrifoBeamUpForm::on_btnReset_clicked()
{
    //indivisuare il profilo da usare per le operazione di programmazione
    if (!getProfile(ui->sbSectorSize->value(),ui->sbBase->value()))
    {
        //profile not valid to program
        return;
    }
    profile.FileToSend = ui->leFile->text();

    programmer->reset(profile);
}

void QgGrifoBeamUpForm::on_btnErase_clicked()
{
    programmer->erase(1, ui->sbSectorSize->value(), ui->sbBase->value());
}

void QgGrifoBeamUpForm::on_btnFlashID_clicked()
{
    //indivisuare il profilo da usare per le operazione di programmazione
    if (!getProfile(ui->sbSectorSize->value(),ui->sbBase->value()))
    {
        //profile not valid to program
        return;
    }
    profile.FileToSend = ui->leFile->text();
    programmer->readFlashID(profile);
}

void QgGrifoBeamUpForm::on_btnGetStatus_clicked()
{
    //indivisuare il profilo da usare per le operazione di programmazione
    if (!getProfile(ui->sbSectorSize->value(),ui->sbBase->value()))
    {
        //profile not valid to program
        return;
    }
    profile.FileToSend = ui->leFile->text();
    programmer->readStatusSPI(profile);
}

void QgGrifoBeamUpForm::on_btnFinish_clicked()
{
    //indivisuare il profilo da usare per le operazione di programmazione
    if (!getProfile(ui->sbSectorSize->value(),ui->sbBase->value()))
    {
        //profile not valid to program
        return;
    }
    profile.FileToSend = ui->leFile->text();
    programmer->terminate(profile);
}

void QgGrifoBeamUpForm::on_cbSimulate_clicked(bool checked)
{
    programmer->setSimulate(checked);
}

void QgGrifoBeamUpForm::on_tbGo_clicked()
{

}

void QgGrifoBeamUpForm::clearTargets()
{
    memset(&targets, 0, sizeof targets);
}

//***********************************************************************
// update Grifo Download Site
// Input parameters:    checked = true if I also have to view the golden area of the flash
//                                false if I have to display only the user area of the flash
// Returns:
//***********************************************************************
void QgGrifoBeamUpForm::updateGrifoDownloadSite(Qt::CheckState checked)
{
    //clear targets struct
    clearTargets();

    //clear treewidget for targets
    entitiesForm->clear();

    QString ip = "";

    //for every targets read from configuration files
    for (int i = 0; i<tgtMatchSet.db.count(); i++)
    {
        TgtMatch tgt = tgtMatchSet.db[i];
        if ((checked==Qt::Checked) ||
            (checked==Qt::Unchecked && tgt.firmware_area!=flash_firmware_area_golden))
        {
            MyDebug().logMsg(type_log_info,
                             origin_msg_generic,
                             QString("%1 %2 %3 %4 %5 %6").arg(tgt.appName).arg(tgt.slotAddress).arg(tgt.description).arg(tgt.partName).arg(tgt.matchStr).arg(tgt.archName));

            ip = tgt.ip;

            QHostAddress ha(ip);
            if (ha.toIPv4Address()<256)
            {
                QHostAddress dha(default_ip);
                auto tmp=dha.toIPv4Address() & 0xFFFFFF00;
                tmp|=ha.toIPv4Address();
                ip=QHostAddress(tmp).toString();
            }

            {//Site
                QgGrifoDownloadSite* s=&targets.sites[targets.valid];

                memset(&s->site, 0, sizeof s->site);
                bsk_download_site_t* site=&s->site;
                strncpy(site->address, tgt.slotAddress.toLatin1(), sizeof site->address);
                //int r=bsk_tftp_mfs_decode_site(site, msg.toLatin1().constData());
                //site->media_address=ip;
                //site->media_port=port;
                s->tgt=&tgt;
                s->site.media_address=QHostAddress(ip).toIPv4Address();
                s->site.media_port=tgt.port; //50069;

                strncpy(s->site.name, tgt.appName.toLatin1().constData(), sizeof s->site.name);
                ++targets.valid;

                entitiesForm->addSite(s);
            }
        }
    }
}

//***********************************************************************
// Read config file
// Input parameters:
// Returns:
//***********************************************************************
void QgGrifoBeamUpForm::readConfigFile()
{
    QSettings& xs=settings;
    xs.beginGroup("GrifoBeamUp");
    QString tgtlist=xs.value("tgtlist", QString("./grifo_beamup_targets.ini")).toString();
    xs.endGroup();
    QFileInfo finfo(tgtlist);

    if (!finfo.isReadable())
    {
        tgtlist=":/settings/targets.ini";
    }
    QSettings config(tgtlist, QSettings::IniFormat);

    //DEFAULT SECTION
    config.beginGroup("default");
    QString def_ip          = config.value("ip", QString("192.168.2.100")).toString();
    int def_port            = config.value("port", 69).toInt();
    QString def_part        = config.value("section", QString("OPER")).toString();
    QString def_target      = config.value("defTarget", QString("TGT-0")).toString();
    config.endGroup();

    default_ip = def_ip;

    //TARGET GROUP
    QStringList groups=config.childGroups();
    foreach(QString g, groups)
    {
        if (g.startsWith("TGT", Qt::CaseInsensitive))
        {
            config.beginGroup(g);

            QString appName     = config.value("appName").toString();
            QString tgtSection     = g;
            QString slotAddress = config.value("slotAddress", QString()).toString();
            QString name        = config.value("name", QString("CPU")).toString();
            QString part        = config.value("section", def_part).toString();
            QString filePrefix  = config.value("filePrefix").toString();
            QString description = config.value("description").toString();
            QString arch        = config.value("arch", QString("?")).toString();
            int port            = config.value("port", def_port).toInt();
            QString ip          = config.value("ip", def_ip).toString();

            slotAddress=slotAddress.remove('$');

            QString address_start_area      = config.value("addressStartArea", QString()).toString();
            QString address_stop_area       = config.value("addressStopArea", QString()).toString();
            flash_firmware_area_t  firmware_area = (flash_firmware_area_t)config.value("area", flash_firmware_area_user).toInt();
            flash_type_t type               = (flash_type_t)config.value("type", flash_type_xcku040).toInt();
            reg_moder_byteaddress_t byteaddress= (reg_moder_byteaddress_t)config.value("3_4Byte", bytes3address).toInt();
            reg_moder_qspiport_t spiPort    =  (reg_moder_qspiport_t)config.value("spiPort", primarySpiPort).toInt();

            config.endGroup();

            TgtMatch* tgt=tgtMatchSet.add(
                        appName,
                        slotAddress,
                        name,
                        part,
                        filePrefix,
                        description,
                        arch,
                        address_start_area,
                        address_stop_area,
                        firmware_area,
                        type,
                        byteaddress,
                        spiPort,
                        ip,
                        port,
                        tgtSection);

            if ((ui->cb_GoldenFlash->checkState()==Qt::Checked) ||
                   (ui->cb_GoldenFlash->checkState()==Qt::Unchecked && firmware_area!=flash_firmware_area_golden))
            {

                MyDebug().logMsg(type_log_info,
                                 origin_msg_generic,
                                 QString("%1 %2 %3 %4 %5 %6").arg(g).arg(appName).arg(slotAddress).arg(name).arg(filePrefix).arg(arch));

                QHostAddress ha(ip);
                if (ha.toIPv4Address()<256)
                {
                    QHostAddress dha(def_ip);
                    auto tmp=dha.toIPv4Address() & 0xFFFFFF00;
                    tmp|=ha.toIPv4Address();
                    ip=QHostAddress(tmp).toString();
                }
                //Site
                {//Site

                    QgGrifoDownloadSite* s=&targets.sites[targets.valid];

                    memset(&s->site, 0, sizeof s->site);
                    bsk_download_site_t* site=&s->site;
                    strncpy(site->address, slotAddress.toLatin1(), sizeof site->address);
                    //int r=bsk_tftp_mfs_decode_site(site, msg.toLatin1().constData());
                    //site->media_address=ip;
                    //site->media_port=port;
                    s->tgt=tgt;
                    s->site.media_address=QHostAddress(ip/*"192.168.2.101"*/).toIPv4Address();
                    s->site.media_port=port; //50069;

                    strncpy(s->site.name, tgt->appName.toLatin1().constData(), sizeof s->site.name);
                    ++targets.valid;
                    entitiesForm->addSite(s);

                }//Site
            }

            entitiesForm->setDefaultTarget(def_target);
        }
        else
        {
            MyDebug().logMsg(type_log_info,
                             origin_msg_generic,
                             QString("? %1").arg(g));
         }
    }

    entitiesForm->setVisible(true);
}


void QgGrifoBeamUpForm::on_cb_GoldenFlash_stateChanged()
{
    updateGrifoDownloadSite(ui->cb_GoldenFlash->checkState());
}

//***********************************************************************
// Show target info
// Input parameters:
//                      popup = display the dialog box
// Returns:             the complete string of target information
//***********************************************************************
QString QgGrifoBeamUpForm::ShowTargetInfo(bool popup)
{
    QString fName = entitiesForm->getFirstSelectedTarget();

    const TgtMatch* tgt=tgtMatchSet.lookupAppName(fName);

    if (!tgt)
        return QString("");

    QString infoText=
            "Target: <b>"+fName+"</b><p/>\n"
            +" &emsp;&emsp;Description: <b>"+QString("%1").arg(tgt->description)+"</b><p/>\n"
            +" &emsp;&emsp;appName: <b>"+QString("%1").arg(tgt->appName)+"</b><p/>\n"
            +" &emsp;&emsp;Name: <b>"+QString("%1").arg(tgt->tgtName)+"</b><p/>\n"
            +" &emsp;&emsp;Arch: <b>"+QString("%1").arg(tgt->archName)+"</b><p/>\n"
            +" &emsp;&emsp;Slot Address: <b>"+QString("%1").arg(tgt->slotAddress)+"</b><p/>\n"
            +"   &emsp;&emsp;IP:PORT: <b>"+QString("%1").arg(tgt->ip)+":"+QString("%1").arg(tgt->port)+"</b><p/>\n"
            +"  <p/>\n"
            +" FLASH: <p/>\n";

    if (tgt->type==flash_type_xcku040)
    {
        infoText+= "   ->&emsp;&emsp;Type: <b> XCKU040 </b><p/>\n";
    }
    else
    if(tgt->type==flash_type_xcku060)
    {
        infoText+= "   ->&emsp;&emsp;Type: <b> XCKU060 </b><p/>\n";
    }
    else
    {
        infoText+= "   ->&emsp;&emsp;Type: <b> XC7A200 </b><p/>\n";
    }

    if (tgt->firmware_area==flash_firmware_area_golden)
    {
        infoText+= "   ->&emsp;&emsp;Firmware area: <b> GOLDEN </b><p/>\n";
    }
    else
    {
        infoText+= "   ->&emsp;&emsp;Firmware area: <b> USER </b><p/>\n";
    }

    if (tgt->byteaddress==bytes3address)
    {
        infoText+= "   ->&emsp;&emsp;Address: <b> 3 bytes address </b><p/>\n";
    }
    else
    {
        infoText+= "   ->&emsp;&emsp;Address: <b> 4 bytes address </b><p/>\n";
    }

    infoText+= "   ->&emsp;&emsp;Start-Stop address: <b>"+QString("%1").arg(tgt->address_start_area)+"-"+QString("%1").arg(tgt->address_stop_area)+"</b><p/>\n";


    if (tgt->spiPort==primarySpiPort)
    {
        infoText+= "   ->&emsp;&emsp;SPI port: <b> use primary SPI interface port </b><p/>\n";
    }
    else
    {
        infoText+= "   ->&emsp;&emsp;SPI port: <b> use secondary SPI interface port</b><p/>\n";
    }


    if (popup)
        QMessageBox::information(0, "Target: "+fName, infoText);
    return infoText;
}



void QgGrifoBeamUpForm::on_btnGetTargetInfo_clicked()
{
    ShowTargetInfo(true);
}

//***********************************************************************
// Set profile, read information form selected fpga
// Input parameters:
// Returns:
//***********************************************************************
bool QgGrifoBeamUpForm::getProfile(unsigned int sectorSize,
                                   unsigned int baseOffset)
{
    QString fName = entitiesForm->getFirstSelectedTarget();

    const TgtMatch* tgt=tgtMatchSet.lookupAppName(fName);

    if (!tgt)
    {
        return false;
    }

    profile.fName = fName;

    bool bStatus= false;
    profile.address_start_area = QString(tgt->address_start_area).toUInt(&bStatus, 16);
    if (!bStatus)
    {
        return false;
    }
    profile.address_stop_area = tgt->address_stop_area.toUInt(&bStatus, 16);
    if (!bStatus)
    {
        return false;
    }
    profile.BaseAddress = tgt->address_start_area.toUInt(&bStatus, 16);
    if (!bStatus)
    {
        return false;
    }
    profile.BaseOffset = baseOffset;
    profile.byteddress = tgt->byteaddress;
    profile.ip = tgt->ip;
    profile.port = tgt->port;
    profile.SectorSize_KBytes = sectorSize;
    profile.slotAddress = tgt->slotAddress;
    profile.spiport = tgt->spiPort;

    if (tgt->type==flash_type_xcku040)
    {
        //xcku040
        profile.dimMbit = FLASH_128Mbit;
    }
    else
    {
        //xc7a200 and xcku060
        profile.dimMbit = FLASH_256Mbit;
    }

    profile.writeRamp = (ui->cbWriteRamp->checkState()==Qt::Checked);
    profile.verifyFinal = (ui->cbVerifyAll->checkState()==Qt::Checked);
    profile.verifySector = (ui->cbVerifySector->checkState()==Qt::Checked);

    return true;
}

void QgGrifoBeamUpForm::on_cb_TargetAddress_clicked(bool checked)
{
    programmer->setSRIOMemory(checked);
}

void QgGrifoBeamUpForm::on_btnGetValue_clicked()
{
    QString address = ui->sbGetValue->text();
    unsigned int len=256;
    char data[len];

    uint32_t dataInt[256];

    //legge mediante srio un valore presente in memoria all'indirizzo indicato
    QString remoteFile=QString("$SRIO:%1/%2+%3").arg(profile.slotAddress).arg(address, 0, 16).arg(len);


    MyDebug().logMsg(type_log_info,
                         origin_msg_srio,
                         QString("Command %1").arg(remoteFile));


    try
    {
        Q_EMIT programmer->readRequest(remoteFile, dataInt, len);

        //programmer->waitRxEvent();
    }
    catch (...)
    {
        MyDebug().logMsg(type_log_error,
                             origin_msg_tftp,
                             "not inizialized");
    }

    sprintf (data, "0x%8.8lX", (long unsigned int)dataInt[0]);

    ui->lblGetValue->setText(data);
}

void QgGrifoBeamUpForm::on_btnMem_clicked()
{
    ui->sbGetValue->setText(QString("0x%1").arg(BASE_ADDRESS_MEM,0,16));
}

void QgGrifoBeamUpForm::on_btnFPGA_clicked()
{
    ui->sbGetValue->setText(QString("0x%1").arg(BASE_ADDRESS_IF,0,16));
}

void QgGrifoBeamUpForm::on_btnHistory_clicked()
{
    HistoryDBForm HistoryDBWindow;

    HistoryDBWindow.setWindowTitle("History DB");

    HistoryDBWindow.setDB(_dbHistory);
    HistoryDBWindow.exec();
}

void QgGrifoBeamUpForm::on_btnAddHistory_clicked()
{
    //(QString _file, db_error_t _error, QString _where)
    QString fileName = ui->leFile->text();
    db_error_t _error = db_error_t(ui->cbError->currentIndex());
    db_status_t _status = db_status_t(ui->cbStatus->currentIndex());
    QString fName = entitiesForm->getFirstSelectedTarget();

    const TgtMatch* tgt=tgtMatchSet.lookupAppName(fName);

    if (!tgt)
        return;

    QString address = QString("%1-%2").arg(tgt->address_start_area).arg(tgt->address_stop_area);
    QString srio = QString("%1@%2:%3").arg(tgt->slotAddress).arg(tgt->ip).arg(tgt->port);
    int spi = int(tgt->spiPort);

    _dbHistory->addNewFile(fileName,
                           _error,
                           fName,
                           _status,
                           address,
                           srio,
                           spi);
}