#include "mcsmainwidget.h"
#include "ui_mcsmainwidget.h"

#include <QToolBar>
#include <QToolButton>
#include <QInputDialog>
#include <QStyleFactory>
#include <QMdiSubWindow>
#include <QDebug>
#include <QSettings>
#include <QTimer>
#include <QFile>
#include <QTextStream>
#include <QInputDialog>
#include <QFileDialog>
#include <QDesktopWidget>
#include <QPainter>
#include <QFileInfo>
#include <QActionGroup>
#include <QLabel>
#include <QImage>
#include <QVector>
#include <QSpinBox>
#include <QCursor>
#include <QMouseEvent>
#include <QWheelEvent>
#include <QDirIterator>
#include <QDebug>
#include <QFormLayout>
#include <QGridLayout>
#include <QDesktopWidget>
#include <QComboBox>
#include <QInputDialog>
#include <QStyleFactory>
#include <QMessageBox>
#include <QApplication>
#include <QShortcut>
#include <QDialog>
#include <QMenu>

#include "DockManager.h"
#include "DockWidget.h"
#include "DockAreaWidget.h"
#include "DockAreaTitleBar.h"
#include "DockAreaTabBar.h"
#include "FloatingDockContainer.h"
#include "DockComponentsFactory.h"

//#include <QtScript/QScriptEngine>
//#include <QtScriptTools/QScriptEngineDebugger>

#include <QPluginLoader>
#include <QtPlugin>
#include <QLibraryInfo>

#include "mcsvirtualjoystickwidget.h"

#include "ads_workbench.h"
#include "ads_debug.h"
#include "adsmonitorwidget.h"
#include "ads_rawmsgwidget.h"
#include "ads_pluginloader.h"

#include "ads_driver1553.h"

#define SETT_FILE "./gmcs.ini"
#define SETT_LAYOUT_FILE "./gmcs_layout.ini"

class McsMainWidget::Private: public IAdsWorkBench
{
public:
  McsMainWidget& w;
  QMainWindow* hostWindow;

  AdsMonitorWidget* adsMon;

  IAdsApplication* app;

  QString defIniFile;

  QComboBox& cbRunState;
  //QGridLayout& lyRawData;
  QActionGroup& grpBusCtrl;
  QActionGroup& grpBusMon;

  QPixmap imgVcrRec;
  QPixmap imgVcrStop;
  QPixmap imgVcrPause;
  QPixmap imgMonRun;
  QPixmap imgMonAcq;

  QIcon iconMonOff;
  QIcon iconMonRunning;
  QIcon iconMonError;
  QIcon iconMonSomeErrors;

  ads::CDockWidget* appDockWidget;
  QVector<ads::CDockWidget*> dockedWidgets;

  AdsRawDataView rawDataView;

  McsVirtualJoystickDialog* joy;

  //Mouse Management
  typedef QMap<int, IAdsMouseGrabber*> mouse_grabber_map_t;

  mouse_grabber_map_t mouse_grabber_map;
  IAdsMouseGrabber* activeGrabber;
  QPoint grabberBeginPos;

  QToolBar* mainToolBar;

  ads::CDockManager* DockManager;
  QToolButton* mmenu_button;
  QMenu* mcsMenu;

  void installMouseGrabber(int k, IAdsMouseGrabber& grabber)
  {
    joy->setGrabber(&grabber);
    mouse_grabber_map[k]=&grabber;
  }
  virtual QMainWindow& mainWindow()
  {
    return *hostWindow;
  }

  virtual void addAppDockWidget(QWidget* wd, const QString& name)
  {
      if (wd==0)
      {
        return;
      }

      //auto wdock= new QDockWidget(name); //, &w);
      //wdock->setObjectName(name);
      //wd->setParent(wdock);
      //wdock->setWidget(wd);

      auto wdock=new ads::CDockWidget(name); //wd->objectName());
      wdock->setWidget(wd); //, ads::CDockWidget::ForceNoScrollArea);

      DockManager->addDockWidgetTab(ads::CenterDockWidgetArea, wdock);

      Q_EMIT w.adsDockCreated(wdock, "MCS");

      //w.addDockWidget(Qt::RightDockWidgetArea, wdock); //Qt::RightDockWidgetArea, wdock);

      if (appDockWidget==0)
      {
          //w.addDockWidget(Qt::LeftDockWidgetArea, wdock); //Qt::RightDockWidgetArea, wdock);
          appDockWidget=wdock;
      }
      else
      {
           //w.tabifyDockWidget(appDockWidget, wdock);
           //appDockWidget=wdock;
      }
      dockedWidgets.push_back(wdock);
  }

  virtual QTabWidget* getTabArea()
  {
    return 0; //w.ui->tabWidget;
  }

  virtual void addShortcut(QAction *act)
  {
    //w.ui->menuShortcut->addAction(act);
  }

  bool activateMouseGrabber(int k)
  {
    if (activeGrabber)
    {
      abortMouseGrabber();
      return true;
    }

    if (mouse_grabber_map.contains(k))
    {
      //qDebug()<<"Ativate Grabber";

      grabberBeginPos=QCursor::pos();
      QRect r=QApplication::desktop()->screenGeometry(grabberBeginPos);
      QCursor::setPos(r.center());
      activeGrabber=mouse_grabber_map[k];
      activeGrabber->activate(QCursor::pos());

      const QCursor* const c=activeGrabber->getCursor();

      if (c)
        w.grabMouse(*c);

      if (activeGrabber->needMouseTraking())
        w.setMouseTracking(true);

      return true;
    }
    return true;
  }
  void abortMouseGrabber()
  {
    //qDebug()<<"Abort Grabber";
    if (activeGrabber)
      activeGrabber->abort();
    w.setMouseTracking(false);
    w.releaseMouse();
    activeGrabber=0;
  }

  void deactivateMouseGrabber()
  {
    if (activeGrabber)
    {
      //qDebug()<<"Decativate Grabber";
      activeGrabber->deactivate();
      w.setMouseTracking(false);
      w.releaseMouse();
      activeGrabber=0;
      QCursor::setPos(grabberBeginPos);
    }
  }

  Private(McsMainWidget* mainWindget, QMainWindow* mainWin):
      w(*mainWindget),
      hostWindow(mainWin),
      adsMon(0),
      cbRunState(*new QComboBox),
      //lyRawData(*new QGridLayout),
      grpBusCtrl(*new QActionGroup(mainWindget)),
      grpBusMon(*new QActionGroup(mainWindget))
  {
  }

  void initialize()
  {
    //hostWindow=0;
    defIniFile="./default.mcs";

    QPixmap base(":/qt-project.org/styles/commonstyle/images/dvd-32.png");
    QPixmap baseMon(":/qt-project.org/styles/commonstyle/images/viewdetailed-32.png");

    imgVcrRec=base;
    imgVcrStop=base;
    imgVcrPause=base;

    const int sz=32-24;
    {
      QPixmap tmp(":/qt-project.org/styles/commonstyle/images/media-pause-32.png");

      QPainter p(&imgVcrPause);
      p.drawPixmap(sz, sz, tmp);
    }
    {
      QPixmap tmp(":/qt-project.org/styles/commonstyle/images/media-play-32.png");

      QPainter p(&imgVcrRec);
      p.drawPixmap(sz, sz, tmp);
    }
    {
      QPixmap tmp(":/qt-project.org/styles/commonstyle/images/media-stop-32.png");

      QPainter p(&imgVcrStop);
      p.drawPixmap(sz, sz, tmp);
    }

    {
      QPixmap tmp(32, 32);

      {
        tmp.fill(Qt::gray);
        //QPainter p(&tmp);
        //p.setPen(Qt::black);
        //p.setBrush(Qt::gray);
        //p.drawEllipse(16, 16, 15, 15);
        iconMonOff.addPixmap(tmp);
      }
      {
        tmp.fill(Qt::green);
        //QPainter p(&tmp);
        //p.setPen(Qt::black);
        //p.setBrush(Qt::green);
        //p.drawEllipse(16, 16, 15, 15);
        iconMonRunning.addPixmap(tmp);
      }
      {
        tmp.fill(Qt::red);
        //QPainter p(&tmp);
        //p.setPen(Qt::black);
        //p.setBrush(Qt::red);
        //p.drawEllipse(16, 16, 15, 15);
        iconMonError.addPixmap(tmp);
      }
      {
        tmp.fill(Qt::yellow);
        //QPainter p(&tmp);
        //p.setPen(Qt::black);
        //p.setBrush(Qt::red);
        //p.drawEllipse(16, 16, 15, 15);
        iconMonSomeErrors.addPixmap(tmp);
      }

    }

    {
      imgMonRun=baseMon;
      imgMonAcq=baseMon;


      {
        QPixmap tmp(":/qt-project.org/styles/commonstyle/images/media-play-32.png");
        QPainter p(&imgMonRun);
        p.drawPixmap(sz, sz, tmp);
      }
      {
        QPixmap tmp(":/qt-project.org/styles/commonstyle/images/standardbutton-save-32.png");
        QPainter p(&imgMonAcq);
        p.drawPixmap(sz, sz, tmp);
      }
    }

    rawDataView.initialize(0);
    for(int i=0; i<32; ++i)
      w.addDataWidget(rawDataView.wRawData[i], i);

    activeGrabber=0;
    app=0;

    grpBusCtrl.setExclusive(false);
    grpBusCtrl.setExclusive(false);

    cbRunState.addItems(
            QStringList()<<"NULL"<<"DEVICE ERR"<<"READY"<<"HALT"<<"RUNNING"<<"No RESPONSE"<<"MSG ERRORS"<<"MONITOR");
    cbRunState.setCurrentIndex(0);
    cbRunState.setEnabled(false);
    //cbRunState.setEditable(true);
    cbRunState.setStyleSheet(
      "  QComboBox { padding: 0 0 0 2px;} "
      "  :disabled { color: black; font: bold; }"
      "  ::drop-down { "
      "  position: absolute;"
      "  left: 0;"
      "  subcontrol-origin: content;"
      "  border-style: none;"
      "  width: 0px;"
      "  border-width: 0;"
      " }");
    QFont f=cbRunState.font();
    f.setBold(true);
    cbRunState.setFont(f);
    /*
    cbRunState.setItemData(0, Qt::gray, Qt::BackgroundRole);
    cbRunState.setItemData(1, Qt::red, Qt::BackgroundRole);
    cbRunState.setItemData(3, Qt::white, Qt::BackgroundRole);
    cbRunState.setItemData(4, Qt::green, Qt::ForegroundRole); //Qt::BackgroundRole);
    */    
  }
  ~Private()
  {
    //if (adsMon)
    //  delete adsMon;
  }
};

static IAdsWorkBench* mcsWorkbenchInstance;

IAdsWorkBench& IAdsWorkBench::instance()
{
  if (!mcsWorkbenchInstance)
    abort();
  return *mcsWorkbenchInstance;
}

McsMainWidget::McsMainWidget(ads::CDockManager *dockManager, QMainWindow *parent) :
    QWidget(0),
    ui(new Ui::McsMainWidget),
    p_(*new Private(this, parent))
{
    mcsWorkbenchInstance=&p_;

    ui->setupUi(this);

    p_.DockManager=dockManager;

    p_.initialize();

    //setStyleSheet("QMainWindow::separator { background-color: darkgray; width: 2px; height: 2px; }");

    ui->actionLoad->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/standardbutton-open-16.png"));
    ui->actionReload_default->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/file-16.png"));
    ui->actionSave->setIcon(QIcon( ":/qt-project.org/styles/commonstyle/images/standardbutton-save-16.png"));
    ui->actionSave_As->setIcon((QIcon(":/qt-project.org/styles/commonstyle/images/newdirectory-16.png")));
    ui->actionQuit->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/standardbutton-close-16.png"));

    ui->actionBusRun->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/media-play-16.png"));
    ui->actionBusOneFrame->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/media-skip-forward-16.png"));
    ui->actionBusStop->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/media-pause-16.png"));

    ui->actionVCR_Rec->setIcon(p_.imgVcrRec);
    ui->actionVCR_Pause->setIcon(p_.imgVcrPause);
    ui->actionVCR_Stop->setIcon(p_.imgVcrStop);
    ui->actionVCR_Rec->setVisible(true);
    ui->actionVCR_Pause->setVisible(false);
    ui->actionVCR_Stop->setVisible(false);

    ui->actionBusOneFrame->setVisible(false);
    ui->actionBusMonitorAcq->setVisible(false);

    ui->actionMonitorStatus->setIcon(p_.iconMonOff);
    ui->actionBusMonitor->setIcon(p_.imgMonRun);
    ui->actionBusMonitorAcq->setIcon(p_.imgMonAcq);
    ui->actionBusMonitorReset->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/refresh-32.png"));

    ui->actionDeviceReset->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/refresh-32.png"));
    ui->actionDevice_Info->setIcon(QIcon(":/qt-project.org/styles/commonstyle/images/refresh-32.png"));

    p_.grpBusCtrl.addAction(ui->actionBusRun);
    p_.grpBusCtrl.addAction(ui->actionBusOneFrame);
    p_.grpBusCtrl.addAction(ui->actionBusStop);

    p_.grpBusCtrl.addAction(ui->actionBusMonitor);

    p_.grpBusMon.addAction(ui->actionBusMonitorAcq);
    //p_.grpBusMon.addAction(ui->actionVCR_Rec);
    p_.grpBusMon.addAction(ui->actionVCR_Pause);
    p_.grpBusMon.addAction(ui->actionVCR_Stop);

    p_.mainToolBar=new QToolBar("MCS");

#if 0
    WindowMenu* wm=new WindowMenu(tr("&Windows"), this);
    wm->addSeparator();
    wm->addAction("Style...", this, SLOT(selectStyle()));
    //wm->setMdi(ui->mdiArea);
    //menuBar()->addMenu(wm);
    //ui->tabWidget->setVisible(false);
    //ui->tabWidget->setEnabled(false);

      ui->mainToolBar->insertWidget(ui->actionBusRun, &p_.cbRunState);
#endif

      //p_.mainToolBar->insertWidget(ui->actionBusRun, &p_.cbRunState);
      p_.mainToolBar->setIconSize(QSize(16,16));

      if (0)
      {
          QStyle* st=QApplication::style();

          p_.mmenu_button=new QToolButton;
          p_.mmenu_button->setText("MCS Menu");
          p_.mmenu_button->setIcon(st->standardIcon(QStyle::SP_ArrowDown)); //QIcon(":/icons/icons/list89.png"));
          p_.mmenu_button->setContextMenuPolicy(Qt::ActionsContextMenu);
          p_.mmenu_button->setPopupMode(QToolButton::InstantPopup);

          p_.mmenu_button->addAction(ui->actionLoad);
          p_.mmenu_button->addAction(ui->actionSave);
          p_.mainToolBar->addWidget(p_.mmenu_button);
      }
      p_.mainToolBar->addAction(ui->actionMonitorStatus);
      p_.mainToolBar->addWidget(&p_.cbRunState);
      p_.mainToolBar->addAction(ui->actionBusRun);
      p_.mainToolBar->addSeparator();
      p_.mainToolBar->addAction(ui->actionBusMonitor);
      p_.mainToolBar->addAction(ui->actionVCR_Rec);

      //p_.mainToolBar->addAction(ui->actionShow_monitor);

      updateBusState(true, false, false);

      //ui->tabWidget->setTabIcon(0, QIcon(":/trolltech/qmessagebox/images/qtlogo-64.png"));

      //ui->dockWidget->setVisible(false);

      updateDefaultFile(p_.defIniFile);

#if 0
      {
        QMainWindow::DockOptions d=dockOptions();
        d&= ~QMainWindow::AnimatedDocks;
        d|=QMainWindow::AllowNestedDocks;
        d|=QMainWindow::AllowTabbedDocks;

        setDockOptions(d);

        //setAnimated(false);
      }
#endif
      AdsDebug::log_print("Avionic Data Smart Starting...");

    //p_.DockManager = new ads::CDockManager(this);

    p_.hostWindow->addToolBar(p_.mainToolBar);


    p_.joy=new McsVirtualJoystickDialog(0);

    auto hortcut = new QShortcut(QKeySequence(tr("Ctrl+Q", "Joystick")),
                               parent);
    connect(hortcut, &QShortcut::activated, this, [this]() { p_.joy->activate();});

    if (Ads1553Manager::monitorOnly())
        ui->actionBusMonitor->setChecked(true);

    QTimer::singleShot(0, this, SLOT(postInit()));

}

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


void McsMainWidget::postInit()
{
    {
        p_.mcsMenu=new QMenu("MCS");
        p_.mcsMenu->addAction(ui->actionLoad);
        p_.mcsMenu->addAction(ui->actionSave);
        p_.mcsMenu->addAction(ui->actionSave_As);
        p_.mcsMenu->addAction(ui->actionReload_default);

        //Q_EMIT appMenuCreated(p_.mcsMenu);
    }

  //AdsDebug::createDebugWindows(this);

  //QScriptValue scriptWin = theScriptEngine->newQObject(this);
  //theScriptEngine->globalObject().setProperty("ads", scriptWin);

  /*
  importScriptEtension("qt.core");
  importScriptEtension("qt.gui");
  importScriptEtension("qt.network");
  importScriptEtension("qt.xml");
  importScriptEtension("qt.uitools");
  */
  QString startScript;

  QSettings s(SETT_FILE, QSettings::IniFormat);
  s.beginGroup("SystemConfig");
  bool enable_debug=s.value("debug", true).toBool();
  enable_debug=true;

  QVariant v=s.value("LibraryPaths");
  if (v.canConvert(QVariant::StringList))
  {
    QStringList sl=v.toStringList();
    foreach(QString p, sl)
      QCoreApplication::addLibraryPath(p);
    if (enable_debug)
      qDebug()<<"Library Paths: "<<QCoreApplication::libraryPaths();
  }
  if (enable_debug)
    qDebug()<<QCoreApplication::applicationDirPath();

  if (s.value("scriptEnable", true).toBool())
  {
    v=s.value("scriptImportExtension");
    if (v.canConvert(QVariant::StringList))
    {
      QStringList sl=v.toStringList();
      //foreach(QString p, sl)
      //  importScriptEtension(p);
    }

    //startScript=s.value("startupScript", "./gmcs_init.qs").toString();
  }

  QString avb_driver=s.value("avbDriver").toString();
  s.endGroup();

  IAvbDriver* the_avb_driver=AdsPluginLoader::loadAvbDriver(avb_driver, &s);
  if (the_avb_driver)
    Ads1553Manager::setDriver(the_avb_driver);
  else
    exit(0);

  p_.addAppDockWidget(this, "MSG1553");

  //widget BusMonitor alla schermata principale
  p_.adsMon=new AdsMonitorWidget(this);
  p_.addAppDockWidget(p_.adsMon, "Bus Monitor");

  //ui->tabWidget->addTab(p_.adsMon, QIcon(":/images/images/emac-icon32.png"), "Bus Monitor");
  //QDockWidget* dw=new QDockWidget("Bus Monitor");
  //addDockWidget(Qt::LeftDockWidgetArea, dw);

  connect(&Ads1553Manager::instance(), SIGNAL(messageListChanged()), SLOT(_onMessageListChanged()));
  connect(&Ads1553Manager::instance(), SIGNAL(runStatusChanged(Ads1553Manager::run_sts_t)), SLOT(_onRunStatusChanged(Ads1553Manager::run_sts_t)));
  connect(&Ads1553Manager::instance(), SIGNAL(commStatusChanged(Ads1553Manager::com_sts_t)), SLOT(updateComStatus(Ads1553Manager::com_sts_t)));
  connect(ui->comboBox_SelectMsg, SIGNAL(currentIndexChanged(int)), SLOT(_onRawMessageSlection_changed(int)));
  _onMessageListChanged();

  if (!startScript.isEmpty())
  {
    QFile f(startScript);
    f.open(QIODevice::ReadOnly);
    if (!f.isReadable())
      qDebug()<<"Cannot open script script "<<startScript;
    else
    {
      qDebug()<<"Running initialization script "<<startScript;
      QTextStream stream(&f);
      QString program=stream.readAll();

      ///*QScriptValue val=*/theScriptEngine->evaluate(program, startScript);
    }
  }


  p_.app=AdsCreateApplicationInstance(p_);

  //restoreSettings();
  QString devName=Ads1553Manager::instance().getDriver()->getDeviceName();
  QString appTitle("");
  QString icdTitle("");

  if (p_.app)
  {
    appTitle=p_.app->getAppTitle();
    icdTitle=p_.app->getIcdName();

    //setWindowTitle(windowTitle()+": "+QString(p_.app->getAppTitle()));
    p_.app->restoreSettings();
    updateDefaultFile(p_.app->defaultSettingsFilename());
  }

  QString tmp=windowTitle()+": "+appTitle+"-"+icdTitle+" ["+devName+"]";
  setWindowTitle(tmp);
  //updateDefaultFile(p_.defIniFile);

  QTimer::singleShot(0, this, SLOT(postInit2()));
}

void McsMainWidget::postInit2()
{
  AdsDebug::createDebugWindows(p_.hostWindow); //this);
  AdsDebug::instance().startMonitoring();
  //Ads1553Manager::instance().run();
  p_.adsMon->updateDataList();

  bool ok=restoreSettings();
  if (!ok)
  {
      //ads::CDockWidget* wd=p_.dockedWidgets[0];
      for(int i=1; i<p_.dockedWidgets.size(); ++i)
      {
          //tabifyDockWidget(wd, p_.dockedWidgets[i]);
          //wd=p_.dockedWidgets[i];
      }
  }

  //grabGesture(Qt::PanGesture);
  //grabGesture(Qt::PinchGesture);
  //grabGesture(Qt::SwipeGesture);

    Q_EMIT appMenuCreated(p_.mcsMenu);
    Q_EMIT appReady();
}

void McsMainWidget::addDataWidget(QWidget * w, int wnum)
{
  ui->dataLayout->addWidget(w, 1+(wnum/2), wnum % 2);
}

void McsMainWidget::updateBusState(bool err, bool bc_run, bool mon_run)
{
  static int p_r_sts=-1;

  if (err)
  {
    p_.grpBusCtrl.setDisabled(true);
    p_.grpBusMon.setDisabled(true);

    p_.cbRunState.setCurrentIndex(0);

    //ui->actionMonitorStatus->setIcon(p_.iconMonError);
    p_r_sts=-1;
  }
  else if (bc_run!=p_r_sts)
  {
      p_r_sts=bc_run;

      if (!p_.grpBusCtrl.isEnabled())
        p_.grpBusCtrl.setEnabled(true);

      ui->actionBusMonitor->setChecked(mon_run);

      if (bc_run)
      {
          //if (!ui->actionBusRun->isChecked())
          {
              p_.cbRunState.setCurrentIndex(4);
              ui->actionBusRun->setChecked(true);
              ui->actionBusOneFrame->setChecked(false);
              ui->actionBusOneFrame->setEnabled(false);
              //ui->actionMonitorStatus->setIcon(p_.iconMonRunning);
          }

      }
      else if (mon_run)
      {
          p_.cbRunState.setCurrentIndex(7);
          ui->actionBusRun->setChecked(false);
          ui->actionBusOneFrame->setChecked(false);
          ui->actionBusOneFrame->setEnabled(true);
      }
      else
      {
          //if (ui->actionBusRun->isChecked())
          {
            p_.cbRunState.setCurrentIndex(3);
            ui->actionBusRun->setChecked(false);
            ui->actionBusOneFrame->setChecked(false);
            ui->actionBusOneFrame->setEnabled(true);
            //ui->actionMonitorStatus->setIcon(p_.iconMonOff);
          }

      }
  }
}

void McsMainWidget::updateDefaultFile(const QString & f)
{
  QString tmp="Reload Default ("+f+")";

  QFileInfo fi(f);

  ui->actionReload_default->setText(tmp);
  ui->actionReload_default->setEnabled(fi.isReadable());
}

void McsMainWidget::saveSettings()
{
#if 0
  QSettings s(SETT_LAYOUT_FILE, QSettings::IniFormat);

  s.beginGroup("MainWindow");
    s.setValue("windowState", QMainWindow::saveState());
    s.setValue("geometry", saveGeometry());

    s.setValue("DockingState", p_.DockManager->saveState());

    //s.setValue("defInit", p_.defIniFile);
  s.endGroup();

  s.beginGroup("DbgWindows");
  s.setValue("dbgWin", ui->actionShow_monitor->isChecked());
  s.endGroup();
#endif
}

bool McsMainWidget::restoreSettings()
{
#if 0
  //QFileInfo f(SETT_LAYOUT_FILE);

  bool settings_readable=QFileInfo(SETT_LAYOUT_FILE).isReadable();
  if (settings_readable)
  {
    QSettings s(SETT_LAYOUT_FILE, QSettings::IniFormat);

    s.beginGroup("DbgWindows");

    if (s.value("dbgWin").toBool())
        ui->actionShow_monitor->trigger(); //setChecked(true);
    s.endGroup();

    s.beginGroup("MainWindow");

    restoreGeometry(s.value("geometry").toByteArray());
    restoreState(s.value("windowState").toByteArray());

    //QString tmp=s.value("defInit").toString();
    //if (!tmp.isEmpty())
    //  p_.defIniFile=tmp;
    //p_.DockManager->restoreState(s.value("DockingState").toByteArray());
    s.endGroup();
  }
#endif
  if (p_.app)
    p_.app->restoreSettings();

  return true; //settings_readable;
}

static QList<QDialog*> openDlgLst;

bool McsMainWidget::close()
{
    saveSettings();
    if (p_.app)
      p_.app->saveSettings();

    return McsMainWidget::close();
    //return QMainWindow::close();
}

void McsMainWidget::closeEvent(QCloseEvent */*evn*/)
{
  /*
  if (!closeDocument())
    evn->ignore();
  else
  {
    wbSaveState();

    ui->mdiArea->closeAllSubWindows();

    if (p_.prj)
    {
      p_.prj->stop();
    }

    theScriptDebugger->standardWindow()->close();
    delete theScriptDebugger;

    evn->accept();
  }
  */

  saveSettings();

  //int r=QMessageBox::question(this, "Avionics 1553", "Save message data?", QMessageBox::Yes, QMessageBox::No|QMessageBox::Default);
  //
  //if (p_.app && (r==QMessageBox::Yes))
  //  p_.app->saveSettings();

  Ads1553Manager::instance().shutdown();

  //if (theScriptDebugger)
  //{
  //  theScriptDebugger->standardWindow()->close();
  //}
  {
    QDialog* d;
    foreach(d, openDlgLst)
    {
      if (d && d->isVisible())
        d->hide();
    }
  }
}



#include "plugindialog.h"



void McsMainWidget::on_actionShow_monitor_triggered()
{
    AdsDebug::createDebugWindows(p_.hostWindow);
    AdsDebug::instance().startMonitoring();

    ui->actionShow_monitor->setCheckable(true);
    ui->actionShow_monitor->setChecked(true);
    ui->actionShow_monitor->setEnabled(false);
}


void McsMainWidget::on_rawShowHex_stateChanged(int s)
{
  bool hex=s==Qt::Checked;

  p_.rawDataView.setHexMode(hex);
}

void McsMainWidget::_onRunStatusChanged(Ads1553Manager::run_sts_t sts)
{
  updateBusState(sts<Ads1553Manager::sts_ready, sts & Ads1553Manager::sts_bc_running, sts & Ads1553Manager::sts_mon_running);
}

void McsMainWidget::_onRawMessageSlection_changed(int i)
{
  //int i=ui->comboBox_SelectMsg->currentIndex();

  Ads1553MsgQ* msg=(Ads1553MsgQ*)ui->comboBox_SelectMsg->itemData(i).toUInt();
  const ads_1553msg_t* const rawInfo=msg ? msg->rawInfo() : 0;

  p_.rawDataView.connect(msg);

  if (rawInfo)
  {
    QString tmp;

    avb_1553_terminal_t* dst=rawInfo->desc.target;
    avb_1553_terminal_t* src=rawInfo->desc.target_rtrt_tx;
    if (rawInfo->desc.tr==avb_tx)
    {
        avb_1553_terminal_t* tmp=src;
        src=dst;
        dst=tmp;

    }
    tmp=QString("%1(%2)-%3(%4)-%5-%6-%7")
        .arg(src->nickName)
        .arg(src->adr)
        .arg(dst->nickName)
        .arg(dst->adr)
        .arg(rawInfo->desc.tr ? 'T' : 'R')
        .arg(rawInfo->desc.sa)
        .arg(rawInfo->desc.wc);
    if (rawInfo->desc.moninal_frequency>0)
      tmp+=QString("[%1Hz]").arg(rawInfo->desc.moninal_frequency);
    //else if (rawInfo->desc.moninal_frequency<0)
    //  tmp+=QString("[<%1Hz]").arg(-rawInfo->desc.moninal_frequency);

    ui->msgCode->setText(tmp);
    ui->groupBox_RawData->setTitle(rawInfo->desc.longName);
  }
}

void McsMainWidget::_onMessageListChanged()
{
  int n=Ads1553Manager::instance().numOfMessages();
  ui->comboBox_SelectMsg->clear();
  ui->comboBox_SelectMsg->addItem("<no-msg>", 0);
  for(int i=0; i<n; ++i)
  {
    Ads1553MsgQ* msg=Ads1553Manager::instance().getMsgObj(i);
    ui->comboBox_SelectMsg->addItem(msg->objectName(), (unsigned int)msg);
  }
  ui->comboBox_SelectMsg->setCurrentIndex(0);
}

void McsMainWidget::on_actionBusRun_triggered(bool checked)
{
  if (checked)
  {
      if (ui->actionBusMonitor->isChecked())
          Ads1553Manager::instance().run_monitor(); //ui->actionBusMonitor->trigger();
      else
          Ads1553Manager::instance().run();
  }
  else
    Ads1553Manager::instance().stop();
}

void McsMainWidget::on_actionBusStop_toggled(bool /*checked*/)
{
    //if (checked)
    //    Ads1553Manager::instance().stop();
}

void McsMainWidget::on_actionBusOneFrame_triggered(bool checked)
{
    if (checked)
    {
        if (ui->actionBusMonitor->isChecked())
            Ads1553Manager::instance().run_monitor(); //ui->actionBusMonitor->trigger();
        else
            Ads1553Manager::instance().run(false);
    }
}

void McsMainWidget::on_actionBusMonitor_changed()
{
   p_.grpBusMon.setEnabled(ui->actionBusMonitor->isChecked());
}

void McsMainWidget::on_actionBusMonitor_triggered(bool /*checked*/)
{
#if 0
    if (checked)
        Ads1553Manager::instance().run_monitor();
    else
    {
        if (!ui->actionBusRun->isChecked())
          Ads1553Manager::instance().stop_monitor();
    }
#endif
}

void McsMainWidget::on_actionDump_Ads_Data_triggered()
{
  int n=AdsDataManager::logicDataCount();
  AdsDebug::log_print(QString("Ads Logic Data: %1").arg(n));
  for(int i=0; i<n; ++i)
  {
    AdsLogicData* const d=AdsDataManager::getLogicData(i);
    if (!d)
      break;
    AdsDebug::log_print(QString("  %1").arg(d->objectName()));
  }
}

void McsMainWidget::on_actionDump_Ads_Action_triggered()
{
  int n=AdsDataManager::dataActionCount();
  AdsDebug::log_print(QString("Ads Data Action: %1").arg(n));
  for(int i=0; i<n; ++i)
  {
    AdsDataAction* const d=AdsDataManager::getDataAction(i);
    if (!d)
      break;
    AdsDebug::log_print(QString("  %1").arg(d->objectName()));
  }
}

void McsMainWidget::cursorGoto(int x, int y, unsigned int /*flags*/)
{
   IAdsMouseGrabber* g=p_.mouse_grabber_map.value(Qt::Key_Control, 0);
   if (g)
       g->cursorGotoXY(x, y);
}

void McsMainWidget::on_actionMonitorStatus_triggered()
{
    //ui->tabWidget->setCurrentWidget(p_.adsMon);
}

void McsMainWidget::updateComStatus(Ads1553Manager::com_sts_t sts)
{
  static Ads1553Manager::com_sts_t old_s=Ads1553Manager::sts_comm_null;

  //enum com_sts_t { sts_comm_null=0, sts_comm_device_err, sts_comm_idle, sts_comm_ok, sts_comm_some_errors, sts_comm_error};
  if (old_s==sts)
    return;
  old_s=sts;
  switch(sts)
  {
  case Ads1553Manager::sts_comm_null:
  case Ads1553Manager::sts_comm_idle:
    ui->actionMonitorStatus->setIcon(p_.iconMonOff);
    break;
  case Ads1553Manager::sts_comm_ok:
    ui->actionMonitorStatus->setIcon(p_.iconMonRunning);
    break;
  case Ads1553Manager::sts_comm_some_errors:
    ui->actionMonitorStatus->setIcon(p_.iconMonSomeErrors);
    break;
  default:
    ui->actionMonitorStatus->setIcon(p_.iconMonError);
    break;
  }

}

QObject* McsMainWidget::adsDataManager()
{
    return AdsDataManager::instance();
}

//#include "objectcontroller.h"
#include "qadsplot.h"
#include "QStandardItemModel"
#include "QStandardItem"
#include "QTreeView"

static void populateList(QStandardItem& sl, QObject* obj, bool showUnnamed, int level)
{
  //static unsigned int obj_count;

  if (!obj)
    return;

  //if (level==0)
  //  obj_count=0;

  //QString indent=QString("%1: %2").arg(obj_count).arg(' ', level*4);
  QStandardItem* item;
  if (!obj->objectName().isEmpty() || showUnnamed)
  {

    QString name=obj->objectName().isEmpty() ? obj->metaObject()->className() : obj->objectName();
    item=new QStandardItem(name);
    item->setData((uint)obj);
    item->setToolTip(obj->metaObject()->className());
    sl.appendRow(item);
  }
  else
    return;

  const QObjectList& list=obj->children();
  foreach(QObject* c, list)
    populateList(*item, c, showUnnamed, level+1);
}

void McsMainWidget::on_actionQT_Properties_triggered()
{
#if 0
  static ObjectInspectorDialog* ocw;
  if (!ocw)
  {
    ocw=new ObjectInspectorDialog(this);
    ocw->registerObject(this);
    ocw->registerObject(qApp);

    openDlgLst.append(ocw);
  }
  ocw->show();
  //QStringList strLst;
  //QList<QObject*> objLst;
  QStandardItemModel sl;

  bool showUnnamed=true; //appProperties.showUnnameObjects();

  populateList(*sl.invisibleRootItem(), qApp, showUnnamed, 0);
  populateList(*sl.invisibleRootItem(), this, showUnnamed, 0);

  //QString res=QInputDialog::getItem(this, QString("Object Properties"), QString("Select the Object:"), strLst, 0, false, &ok);
  QTreeInputDialog d("Select Object to inspect");
  d.setModel(&sl);
  d.setParentSelectable(true);
  if (d.exec()==QDialog::Accepted)
  {
    QObject* obj=(QObject*)d.w->currentIndex().data(Qt::UserRole+1).toUInt();
    if (obj)
    {
      QString dName=QString("Properties: %1").arg(obj->objectName());
      ObjControlDialog dlg(dName, obj, false, this);
      dlg.exec();
    }
  }
  sl.clear();
#endif
}

//#include <Conan.h>

void McsMainWidget::showConan()
{
/*
  static conan::ConanWidget* widget;
  if (!widget)
  {
    widget=new conan::ConanWidget;
    widget->AddRootObject(qApp);
    widget->AddRootObject(this);
    //widget.AddRootObject (someOtherObject); // optional
  }
  widget->show ();
*/
}

void McsMainWidget::on_actionLoad_triggered()
{
    QString tmp=QFileDialog::getOpenFileName(this,
                                            "MCS: Load data",
                                            QString(),
                                            "INI (*.ini);;All files (*.*)");
    if (tmp.isEmpty())
        return;
  p_.app->restoreSettings(tmp);
}

void McsMainWidget::on_actionReload_default_triggered()
{
    p_.app->restoreSettings("");
}

void McsMainWidget::on_actionSave_triggered()
{
  p_.app->saveSettings();
}

void McsMainWidget::on_actionSave_As_triggered()
{
    QString tmp=QFileDialog::getSaveFileName(this,
                                            "MCS: Save data",
                                            QString(),
                                            "INI (*.ini);;All files (*.*)");
    if (tmp.isEmpty())
        return;

    p_.app->saveSettings(tmp);

}

QWidget* GrifoMcsMainWidget(ads::CDockManager* dockManager, QMainWindow* parent, bool monitor_only)
{
    Ads1553Manager::setMonitorOnly(monitor_only);

    return new McsMainWidget(dockManager, parent);
}

void McsMainWidget::on_actionVCR_Rec_triggered(bool checked)
{
    Ads1553Manager::setMonitorSave(checked);
}