configuration.cpp

#include "configuration.h"
#include "odbcutil.h"
#include "sql.h"
#include "overlay.h"
#include "data.h"
#include <QApplication>
#include <QFileDialog>
#include <QFile>
#include "routeviewtablemodel.h"
#include "webviewbridge.h"
#ifdef QTKEYCHAIN_VERSION_6
#include "securevault.h"
#endif

QDataStream &operator<<(QDataStream &out, const IntPair &pair) {
    out << pair.first << pair.second;
    return out;
}

QDataStream &operator>>(QDataStream &in, IntPair &pair) {
    in >> pair.first >> pair.second;
    return in;
}

Configuration::Configuration(QObject *parent) :
    QObject(parent)
{
 currentCityId = -1;
 qRegisterMetaType<Bounds>("Bounds");
 vault = new SecureVault(this);

}

#if 0
void Configuration::saveOldSettings()
{
 QSettings* settings;
 settings = new QSettings();
 settings->beginWriteArray("cities");
 settings->remove("");
 for(int i=0; i< cityList.count(); i++)
 {
  settings->setArrayIndex(i);
  City* c = cityList.at(i);
  //currCity->setName(c->name());
  settings->setValue("id", c->id);
  settings->setValue("name", c->name());
  settings->setValue("lat", c->center.lat());
  settings->setValue("lon", c->center.lon());
  settings->setValue("mapType", c->mapType);
  settings->setValue("mapId", c->mapId);
  settings->setValue("zoom", c->zoom);
  settings->setValue("currConnection", c->curConnectionId);
  settings->setValue("currConnectionUuid", c->connectionUniqueId().toString());
  settings->setValue("currExportConnId", c->curExportConnId);
  settings->setValue("AlphaRoutes", c->bAlphaRoutes);
  settings->setValue("noPanOpt", c->bNoPanOpt);
  settings->setValue("GeocoderRequest", c->bGeocoderRequest);
  settings->setValue("lastRoute", c->lastRoute);
  settings->setValue("lastRouteName", c->lastRouteName);
  settings->setValue("lastRouteEndDate", c->lastRouteEndDate);
  settings->setValue("displayStationMarkers", c->bDisplayStationMarkers);
  settings->setValue("displayTerminalMarkers", c->bDisplayTerminalMarkers);
  settings->setValue("displayRouteComments", c->bDisplayRouteComments);
  settings->setValue("showOverlay", c->bShowOverlay);
  settings->setValue("companyKey", c->companyKey);
  settings->setValue("routeSortType", c->routeSortType);
  settings->setValue("savedClipboard", c->savedClipboard);
  settings->setValue("userMap", c->bUserMap);
  settings->setValue("bounds", c->bounds().toString());
  settings->setValue("currOverlay", c->curOverlayId);
  //settings->setValue("selectedCompanies",SQL::instance()->list2String(c->selectedCompaniesList));
  settings->setValue("displayRoutesForGroup", c->bDisplayRoutesForSelectedCompanies);
  // QString abbreviationsStr;
  // for (QPair<QString,QString> pair: c->abbreviationsList) {
  //     abbreviationsStr.append(pair.first+":"+pair.second +",");
  // }
  // abbreviationsStr.chop(1);
  // settings->setValue("abbreviations", abbreviationsStr);
  settings->remove("abbreviations");

  //settings.setValue("connection",c->curConnectionId);
  settings->beginWriteArray("connections");
  settings->remove("");
  for(int j=0; j < c->connections.count(); j++)
  {
   Connection* cn = c->connections.at(j);
   if(cn->uniqueId().isNull())
       qDebug() << "invalid unique id " << cn->description() << " ";
   if(cn->cityName() != c->name())
    qDebug() << cn->cityName() << " not = " << c->name();
   settings->setArrayIndex(j);
   settings->remove("");
   settings->setValue("id", cn->id());
   settings->setValue("driver", cn->driver());
   settings->setValue("serverType", cn->servertype());
   settings->setValue("cityName", cn->cityName());
   settings->setValue("connectionType", cn->connectionType());
   settings->setValue("description",cn->description());
   settings->setValue("uniqueId", cn->uniqueId().toString());
   //settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());

   if(cn->connectionType()== "Sqlite")
   {
       settings->setValue("sqliteFileName", cn->sqlite_fileName());
   }
   else if(cn->connectionType()== "ODBC")
   {
       settings->setValue("DSN", cn->dsn());
       settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());
       settings->setValue("database", cn->database());
       settings->setValue("PWD", cn->pwd());
       settings->setValue("UID", cn->userId());
       settings->setValue("connectString",cn->connectString());
       settings->setValue("sslMode", cn->getSslMode());
       settings->setValue("pwdMethod", cn->getPwdMethod());
       settings->setValue("dsnCanBeUsed",cn->dsnCanBeUsed());
       if(cn->host() != "")
           settings->setValue("hostname", cn->host());
       if(cn->port() > 0)
           settings->setValue("port", cn->port());
   }
   else if(cn->connectionType()== "Direct")
   {
    settings->setValue("database", cn->database());
    settings->setValue("DSN", cn->dsn());
    //settings->setValue("driver", cn->driver());
    settings->setValue("PWD", cn->pwd());
    settings->setValue("UID", cn->userId());
    if(cn->host() != "")
     settings->setValue("hostname", cn->host());
    if(cn->port() > 0)
     settings->setValue("port", cn->port());
    settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());
    //settings->setValue("useSqlDatabase", cn->database());
   }
  }
  settings->endArray(); // connections

  settings->beginGroup("overlays");
  settings->remove("");
  settings->endGroup();
#if 0
  settings->beginWriteArray("overlays");
//  int oCount = c->overlayList.count();
  int j=-1;
  foreach(Overlay* ov, c->city_overlayMap->values())
  {
   if(ov->cityName != currCity->name)
    continue;
   j++;
   settings->setArrayIndex(j);
   settings->setValue("id", j);
   settings->setValue("name", ov->name);
   settings->setValue("description", ov->description);
   settings->setValue("opacity", ov->opacity);
   settings->setValue("minZoom", ov->minZoom);
   settings->setValue("maxZoom", ov->maxZoom);
   settings->setValue("bounds", ov->bounds().toString());
   settings->setValue("center", ov->sCenter);
   settings->setValue("source", ov->source);
   settings->setValue("urls", ov->urls);
   settings->setValue("isSelected", ov->isSelected);
   settings->setValue("WMTSUrl", ov->wmtsUrl);
   settings->setValue("city", c->name);
   settings->setValue("year", ov->year());
  }
  settings->endArray(); // overlays
#endif
  settings->setValue("currOverlay", c->curOverlayId);
 }
 settings->endArray(); // cities

 settings->beginGroup("query");
 settings->setValue("stop_query_on_error", q.b_stop_query_on_error);
 settings->setValue("sql_execute_after_loading", q.b_sql_execute_after_loading);
 settings->setValue("queryPath", q.s_query_path);
 settings->setValue("geometry", q.geometry);
 settings->endGroup();

 settings->beginGroup("routeView");
 settings->setValue("routeView_hidden_cols", rv.hiddenColumns);
 settings->setValue("routeView_moved_cols", rv.movedColumns);
 settings->setValue("routeView_state", rv.state);
 settings->setValue("routeView_columnCount", rv.columnCount);
 settings->endGroup();

 settings->beginGroup("streetView");
 settings->setValue("routeView_state", sv.state);
 settings->setValue("columnWidths", listToString( sv.colWidths));
 settings->endGroup();

 settings->beginGroup("dupSegmentView");
 settings->setValue("dupSegmentViewState", dsv.state);
 settings->endGroup();

 settings->beginGroup("dlgUpdateStreets");
 settings->setValue("state", dus.state);
 settings->setValue("columnWidths", listToString( dus.colWidths));
 settings->setValue("geometry", dus.geometry);
 settings->setValue("text1", dus.text1);
 settings->setValue("text2", dus.text2);
 settings->setValue("date", dus.date.toString("yyyy/MM/dd"));
 settings->endGroup();

 settings->beginGroup("editCityDialog");
 settings->setValue("state", ecd.state);
 settings->setValue("columnWidths", listToString( ecd.colWidths));
 settings->setValue("geometry", ecd.geometry);
 settings endGroup;

 settings->beginGroup("routeCommentsDlg");
 settings->setValue("state", rcd.state);
 settings->setValue("geometry", rcd.geometry);
 settings->setValue("hidden_cols", rcd.hiddenColumns);
 settings->setValue("columnCount", rcd.columnCount);
 settings->endGroup();

 settings->setValue("currCity", currentCityId);
 settings->setValue("showDebugMessages", bDisplayWebDebug);
 settings->setValue("runInBrowser", bRunInBrowser);
 settings->setValue("saveImageDir", saveImageDir);
 settings->setValue("showGMFeatures", bShowGMFeatures);
 settings->setValue("foreignKeyCheck", bForeignKeyCheck);
 settings->setValue("displayDebugMsgs", bDisplayDebugMsgs);
 settings->setValue("displayArrows", bDisplaySegmentArrows);
 settings->setValue("displayRouteOnReload",bDisplayRouteOnReload);
 settings->setValue("font",font.toString());
 settings->setValue("mapId", mapId);
 settings->setValue("mapType", mapType);
 settings->setValue("tileServerUrl", tileServerUrl);
 settings->setValue("mapSource", mapSource);

 settings->beginWriteArray("allowedSources");
 settings.remove("");
 //foreach (IntPair pair, allowedSources) {
 for(int i= 0; i < allowedSources.count(); i++){
     IntPair pair = allowedSources.at(i);
     settings->setArrayIndex((i));
    settings->setValue("allowedSource", pair.first);
    settings->setValue("allowed",pair.second);
 }
 settings->endArray();
}
#endif
void Configuration::saveSettings2()
{

    QSettings* settings;
    settings = new QSettings();
    if(settingsVersion == 0)
        settings->remove("");

    settings->beginGroup("Cities");
    for(int i=0; i< cityList.count(); i++)
    {
        City* c = cityList.at(i);
        //settings->setArrayIndex(i);
        settings->beginGroup(c->name());
        //currCity->setName(c->name());
        settings->setValue("id", c->id);
        settings->setValue("curUuid",c->curUuid);
        settings->setValue("name", c->name());
        settings->setValue("lat", c->center.lat());
        settings->setValue("lon", c->center.lon());
        settings->setValue("mapType", c->mapType);
        settings->setValue("mapId", c->mapId);
        settings->setValue("zoom", c->zoom);
        settings->setValue("currConnection", c->curConnectionId);
        settings->setValue("currConnectionUuid", c->connectionUniqueId().toString());
        settings->setValue("currExportConnId", c->curExportConnId);
        settings->setValue("AlphaRoutes", c->bAlphaRoutes);
        settings->setValue("noPanOpt", c->bNoPanOpt);
        settings->setValue("GeocoderRequest", c->bGeocoderRequest);
        settings->setValue("lastRoute", c->lastRoute);
        settings->setValue("lastRouteName", c->lastRouteName);
        settings->setValue("lastRouteEndDate", c->lastRouteEndDate);
        settings->setValue("displayStationMarkers", c->bDisplayStationMarkers);
        settings->setValue("displayTerminalMarkers", c->bDisplayTerminalMarkers);
        settings->setValue("displayRouteComments", c->bDisplayRouteComments);
        settings->setValue("showOverlay", c->bShowOverlay);
        settings->setValue("companyKey", c->companyKey);
        settings->setValue("routeSortType", c->routeSortType);
        settings->setValue("savedClipboard", c->savedClipboard);
        settings->setValue("userMap", c->bUserMap);
        settings->setValue("bounds", c->bounds().toString());
        settings->setValue("currOverlay", c->curOverlayId);

        //settings->setValue("selectedCompanies",SQL::instance()->list2String(c->selectedCompaniesList));
        settings->setValue("displayRoutesForGroup", c->bDisplayRoutesForSelectedCompanies);
        // QString abbreviationsStr;
        // for (QPair<QString,QString> pair: c->abbreviationsList) {
        //     abbreviationsStr.append(pair.first+":"+pair.second +",");
        // }
        // abbreviationsStr.chop(1);
        // settings->setValue("abbreviations", abbreviationsStr);
        settings->remove("abbreviations");
        settings->setValue("displayMapInBrowser",c->bDisplayMapInBrowser);
        settings->setValue("mapSource",c->mapSource);

        //settings.setValue("connection",c->curConnectionId);
        //settings->beginWriteArray("connections");
        settings->beginGroup("connections");
        settings->remove("");
        for(int j=0; j < c->connections.count(); j++)
        {
            Connection* cn = c->connections.at(j);
            if(cn->uniqueId().isNull())
                qDebug() << "invalid unique id " << cn->description() << " ";
            if(cn->cityName() != c->name())
                qDebug() << cn->cityName() << " not = " << c->name();
            //settings->setArrayIndex(j);
            if(cn->description().isEmpty())
                cn->setDescription(cn->cityName() + " " + cn->connectionType() + " " + cn->servertype() +" connection");
            settings->beginGroup(cn->description());
            QString currGroup = settings->group();
            settings->setValue("id", j);
            settings->setValue("driver", cn->driver());
            settings->setValue("serverType", cn->servertype());
            settings->setValue("cityName", cn->cityName());
            settings->setValue("connectionType", cn->connectionType());
            settings->setValue("description",cn->description());
            settings->setValue("uniqueId", cn->uniqueId().toString());
            //settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());

            if(cn->connectionType()== "Sqlite")
            {
                settings->setValue("sqliteFileName", cn->sqlite_fileName());
            }
            else if(cn->connectionType()== "ODBC")
            {
                settings->setValue("DSN", cn->dsn());
                settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());
                settings->setValue("database", cn->database());
                settings->setValue("PWD", cn->pwd());
                settings->setValue("UID", cn->userId());
                settings->setValue("connectString",cn->connectString());
                settings->setValue("sslMode", cn->getSslMode());
                settings->setValue("pwdMethod", cn->getPwdMethod());
                settings->setValue("dsnCanBeUsed",cn->dsnCanBeUsed());
                if(cn->host() != "")
                    settings->setValue("hostname", cn->host());
                if(cn->port() > 0)
                    settings->setValue("port", cn->port());
            }
            else if(cn->connectionType()== "Direct")
            {
                settings->setValue("database", cn->database());
                settings->setValue("DSN", cn->dsn());
                //settings->setValue("driver", cn->driver());
                settings->setValue("PWD", cn->pwd());
                settings->setValue("UID", cn->userId());
                if(cn->host() != "")
                    settings->setValue("hostname", cn->host());
                if(cn->port() > 0)
                    settings->setValue("port", cn->port());
                settings->setValue("defaultSqlDatabase", cn->defaultSqlDatabase());
                //settings->setValue("useSqlDatabase", cn->database());
            }
#ifdef QTKEYCHAIN_VERSION_6
            QString key;
            QString password;
            if(!cn->connectString().isEmpty())
                key = createSecureVaultKey(cn->connectString(), c, &password);
            else
            {
                key = createSecureVaultKey(cn, c);
                password = cn->pwd();
            }
            qDebug() << "secure vault key: " << key;
            vault = new SecureVault(this);
            if(!key.isEmpty())
            {
                vault->loadPassword(key, [=](const QString &password) {
                    if (password.isEmpty()) {
                        // qWarning() << "Could not retrieve password or password is empty."
                        //            << " key: "<< key;;
                        // return;
                        vault->savePassword(key, password);
                    }

                    // Your asynchronous callback logic continues inside this block
                    qDebug() << "Password successfully retrieved via vault instance!";
                    if(cn->pwd() == password)
                        cn->setPWD("");

                    // Example: Initiate your database connection
                    // this->initializeDatabaseConnection(password);
                });
                settings->setValue("PWD", "");

                if(!cn->connectString().isEmpty())
                {
                    QString cs = cn->connectString();
                    cs.replace(password, "");
                    cn->setConnectString(cs);
                    settings->setValue("connectString",cs);
                }
            }
        }
#endif
        settings->endGroup(); // end a single connection

        //settings->endArray(); // connections
        settings->endGroup(); // connections

        // settings->beginGroup("overlays");
        // settings->remove("");
        // settings->endGroup();

        settings->setValue("currOverlay", currCity->curOverlayId);
        settings->endGroup(); // city
    }
    //settings->endArray(); // cities
    settings->endGroup(); // cities

    settings->beginGroup("query");
    settings->setValue("stop_query_on_error", q.b_stop_query_on_error);
    settings->setValue("sql_execute_after_loading", q.b_sql_execute_after_loading);
    settings->setValue("queryPath", q.s_query_path);
    settings->setValue("geometry", q.geometry);
    settings->endGroup();

    settings->beginGroup("routeView");
    settings->setValue("routeView_hidden_cols", rv.hiddenColumns);
    settings->setValue("routeView_moved_cols", rv.movedColumns);
    settings->setValue("routeView_state", rv.state);
    settings->setValue("routeView_columnCount", rv.columnCount);
    settings->endGroup();

    settings->beginGroup("streetView");
    settings->setValue("routeView_state", sv.state);
    settings->setValue("columnWidths", listToString( sv.colWidths));
    settings->endGroup();

    settings->beginGroup("dupSegmentView");
    settings->setValue("dupSegmentViewState", dsv.state);
    settings->endGroup();

    settings->beginGroup("dlgUpdateStreets");
    settings->setValue("state", dus.state);
    settings->setValue("columnWidths", listToString( dus.colWidths));
    settings->setValue("geometry", dus.geometry);
    settings->setValue("text1", dus.text1);
    settings->setValue("text2", dus.text2);
    settings->setValue("date", dus.date.toString("yyyy/MM/dd"));
    settings->endGroup();

    settings->beginGroup("editCityDialog");
    settings->setValue("state", ecd.state);
    settings->setValue("columnWidths", listToString( ecd.colWidths));
    settings->setValue("geometry", ecd.geometry);
    settings->endGroup();

    settings->beginGroup("routeCommentsDlg");
    settings->setValue("state", rcd.state);
    settings->setValue("geometry", rcd.geometry);
    settings->setValue("hidden_cols", rcd.hiddenColumns);
    settings->setValue("columnCount", rcd.columnCount);
    settings->endGroup();

    //settings->beginGroup("General");
    settings->setValue("currCity", currentCityId);
    settings->setValue("showDebugMessages", bDisplayWebDebug);
    settings->setValue("runInBrowser", bRunInBrowser);
    settings->setValue("saveImageDir", saveImageDir);
    settings->setValue("showGMFeatures", bShowGMFeatures);
    settings->setValue("foreignKeyCheck", bForeignKeyCheck);
    settings->setValue("displayDebugMsgs", bDisplayDebugMsgs);
    settings->setValue("displayArrows", bDisplaySegmentArrows);
    settings->setValue("displayRouteOnReload",bDisplayRouteOnReload);
    settings->setValue("displayMimerDistance", bDisplayMimerDistance);
    settings->setValue("font",font.toString());
    settings->setValue("mapId", mapId);
    settings->setValue("mapType", mapType);
    settings->setValue("tileServerUrl", tileServerUrl);
    settings->setValue("mapSource", mapSource);
    settings->setValue("settingsVersion", 2);
    settings->setValue("googleMapsMapId", googleMapsMapId); // Cloud Map ID
    //settings->endGroup();

    settings->remove("currentOverlays");
    settings->beginWriteArray("currentOverlays");
    int i =0;
    foreach(Overlay* ov, currentOverlays)
    {
        settings->setArrayIndex(i++);
        settings->setValue("uuid", ov->_uuid.toString());
        settings->setValue("name",ov->name);
        settings->setValue("opacity", WebViewBridge::instance()->_opacity);
    }
    settings->endArray();

    settings->beginWriteArray("allowedSources");
    //foreach (IntPair pair, allowedSources) {
    // for(int i= 0; i < allowedSources.count(); i++){
    //     IntPair pair = allowedSources.at(i);
    QMapIterator<QString, bool> iter(allowedSources);
    i=0;
    while(iter.hasNext()) {
        iter.next();
        settings->setArrayIndex((i++));
        settings->setValue("allowedSource", iter.key());
        settings->setValue("allowed",iter.value());
    }
    settings->endArray();
}

void Configuration::getSettings()
{
   QSettings settings;
   qDebug() << settings.fileName();

   if(settings.value("settingsVersion").toInt() == 2)
   {
       settingsVersion = 2;
       getSettings2();
       return;
   }
   int size = settings.beginReadArray("cities");
   if( size == 0)
   {
      createDefaultSettings();
   }
#ifdef Q_OS_MACOS

   //bUseBundleResources = settings.value("useBundleResources",false).toBool();
   startCwd = cwd = QDir::currentPath();
   qDebug() << "starting configure with CWD = '" << cwd;

   if(cwd == "/")
       cwd.append("Applications");
   if(!cwd.contains("mapper.app"))
   {
       QDir dir(cwd + "/mapper.app");
       if(dir.exists())
           cwd.append("/mapper.app/Contents/MacOS");
       else
           QMessageBox::critical(nullptr, tr("error"),tr("mapper.app not found in %1").arg(cwd));

   }

   if( cwd.contains("/mapper.app/Contents/MacOS"))
   {
       //
      // QDir resources(cwd.remove("/mapper.app/Contents/MacOS") + "/Resources");
      //  if(resources.exists())
      //  {
           // running in development environment, set the cwd to that of the development.
       //if(bUseBundleResources)
           // cwd = cwd.remove("/mapper.app/Contents");

       cwd = cwd.remove("/MacOS");
       QDir::setCurrent(cwd);

           // QDir pDir(QDir::homePath() +"/Public/Mapper/Resources");
           // if(!pDir.exists())
           //  copyFiles(cwd + "/Resources", QDir::homePath() +"/Public/Mapper/Resources");
       //}
   }
   else
   {
   //     {
   //         //processCopyList();
       cwd = cwd.remove("/mapper.app/Contents");
       QDir::setCurrent(cwd);
   //     }
   }
#endif

   bool ok = Overlay::importXml("./Resources/overlays.xml");

   // load cities
   for(int i= 0; i < size; i++)
   {
      settings.setArrayIndex(i);
      City* nc = new City();
      nc->id = settings.value("id").toInt();
      nc->setName(settings.value("name").toString());
      if(!cityList.contains(nc))
      {
         cityList.append(nc);
         cityMap.insert(nc->name(), nc);
      }
      LatLng pt;
      //  qDebug() << "lat: " << settings.value("lat",35).toString();
      //  qDebug() << "lon: " << settings.value("lon",-90).toString();
      pt.setLat(settings.value("lat",35).toDouble());
      pt.setLon(settings.value("lon",-90).toDouble());
      nc->center = pt;

      nc->setBounds(Bounds(settings.value("bounds").toString()));
      if(!nc->bounds().isValid())
      {
         nc->setBounds(Bounds(LatLng(pt.lat()-.1, pt.lon()-.1), LatLng(pt.lat()+.1, pt.lon()+.1)));
      }
      if(nc->bounds().isValid()){
         cityBounds.insert(nc->name(), nc->bounds());
          if(!(nc->bounds().contains(pt)))
              nc->center = nc->bounds().center();
      }
      nc->mapType = settings.value("maptype","roadmap").toString();
      nc->mapId = settings.value("mapid","??").toString();
      nc->zoom = settings.value("zoom",12).toInt();
      nc->curConnectionId = settings.value("currConnection",0).toInt();
      nc->curExportConnId = settings.value("currExportConnId",0).toInt();
      nc->bAlphaRoutes = settings.value("AlphaRoutes").toBool();
      nc->bNoPanOpt = settings.value("noPanOpt").toBool();
      nc->bGeocoderRequest = settings.value("GeocoderRequest").toBool();
      nc->lastRoute = settings.value("lastRoute",0).toInt();
      nc->lastRouteName = settings.value("lastRouteName").toString();
      nc->lastRouteEndDate = settings.value("lastRouteEndDate").toString();
      nc->bDisplayStationMarkers = settings.value("displayStationMarkers",false).toBool();
      nc->bDisplayRouteComments = settings.value("displayRouteComments",false).toBool();
      nc->bDisplayTerminalMarkers = settings.value("displayTerminalMarkers",false).toBool();
      nc->bShowOverlay = settings.value("showOverlay").toBool();
      nc->companyKey = settings.value("companyKey").toInt();
      nc->routeSortType = settings.value("routeSortType").toInt();
      nc->savedClipboard = settings.value("savedClipboard").toString();
      nc->curOverlayId = settings.value("currOverlay", -1).toInt();
      nc->bUserMap = settings.value("userMap", false).toBool();
      if(nc->city_overlayMap->isEmpty())
         nc->bShowOverlay = false;
      // nc->selectedCompanies = settings.value("selectedCompanies","").toString();
      // QStringList sl = nc->selectedCompanies.split(",");
      // nc->selectedCompaniesList.clear();
      // for(int i=0; i < sl.count(); i++ )
      // {
      //     int companyKey = sl.at(i).toInt();
      //     if(companyKey > 0)
      //       nc->selectedCompaniesList.append(sl.at(i).toInt());
      // }
      remove("selectedCompanies");
      nc->bDisplayRoutesForSelectedCompanies = settings.value("displayRoutesForGroup",!nc->selectedCompaniesList.isEmpty()).toBool();
      // QString abbreviationsStr = settings.value("abbreviations").toString();
      // QStringList list =  abbreviationsStr.split(",");
      // nc->abbreviationsList.clear();
      // foreach(QString aPair, list)
      // {
      //     if(aPair.isEmpty())
      //         continue;
      //     QStringList values = aPair.split(":");
      //     nc->abbreviationsList.append(QPair<QString, QString>(values.at(0),values.at(1)));
      // }

      nc->setConnectionUniqueId(QUuid::fromString(settings.value("currConnectionUuid").toString()));
      QString baseAddr;
      baseAddr = QDir::currentPath() +QDir::separator() + "Resources" + QDir::separator()+"databases" + QDir::separator();

      int sizec = settings.beginReadArray("connections");
      // connections
      for(int j = 0; j < sizec; j++)
      {
         settings.setArrayIndex(j);
         QString uuid_string = settings.value("uniqueId").toString();
         QUuid uuid;
         if(uuid_string.isEmpty())
            uuid = QUuid::createUuid();
         else
            uuid = QUuid::fromString(uuid_string);
         Connection* ncn = new Connection(uuid);
         ncn->setId(settings.value("id", -1).toInt());
         ncn->setDescription(settings.value("description").toString());
         ncn->setDriver(settings.value("driver").toString());
         ncn->setServerType(settings.value("serverType").toString());
         ncn->setCityName(settings.value("cityName", nc->name()).toString());
         ncn->setConnectionType(settings.value("connectionType", "Direct").toString());
        //ncn->setUniqueId(QUuid::fromString(settings.value("uniqueId", QUuid::createUuid().toString()).toString()));
        if(ncn->id() == nc->curConnectionId)
           nc->setConnectionUniqueId(uuid);
        if(ncn->connectionType() == "Sqlite" || ncn->connectionType() == "Local")
        {
          ncn->setConnectionType("Sqlite");
          QString fileName;
          fileName = settings.value("sqliteFileName").toString();
          if(fileName.isEmpty())
             fileName = settings.value("database").toString();
          QFileInfo info(baseAddr + fileName);
          if(!info.exists())
             qDebug() << fileName << " not found";
          else
          {
           //QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE", "city");
           // Reuse connection if it exists, otherwise create it fresh
           QSqlDatabase db;
           QString cName = "city";
           QString driver = "QSQLITE";
           if (QSqlDatabase::contains(cName)) {
               db = QSqlDatabase::database(cName);

               // Safety check: If the driver changed, we MUST recreate the connection handle
               if (db.driverName() != driver) {
                   db = QSqlDatabase::addDatabase(driver, cName);
               }
           } else {
               db = QSqlDatabase::addDatabase(driver, cName);
           }
              db.setDatabaseName(info.absoluteFilePath());
           if(db.open())
           {
                Parameters p;
                if(SQL::instance()->getParameters(&p, db))
                {
                    if(!p.city.isEmpty())
                    {
                     ncn->setCityName(p.city);
                     nc->setNameOverride(p.city);
                    }
                }
           }
           db.close();
          }
          ncn->setSqliteFileName(info.fileName());
        }
        else if(ncn->connectionType() == "Direct") {
           //ncn->setDSN(settings.value("DSN").toString());  // not needed
           ncn->setPWD(settings.value("PWD").toString());
           ncn->setUserId(settings.value("UID").toString());
           ncn->setHost(settings.value("hostname").toString());
           ncn->setPort(settings.value("port").toInt());
           ncn->setDefaultSqlDatabase(settings.value("defaultSqlDatabase").toString());
           ncn->setDatabase(settings.value("database").toString());
           //ncn->setMySqlDatabase(settings.value("mySqlDatabase").toString());
        }
        else if(ncn->connectionType() == "ODBC") {
           ncn->setDSN(settings.value("DSN").toString());
           if(!settings.value("odbcConnector").toString().isEmpty())
            ncn->setDSN(settings.value("odbcConnector").toString());
           ncn->setDefaultSqlDatabase(settings.value("defaultSqlDatabase").toString());
           ncn->setDatabase(settings.value("database").toString());
           ncn->setPWD(settings.value("PWD").toString());
           ncn->setUserId(settings.value("UID").toString());
           ncn->setHost(settings.value("hostname").toString());
           ncn->setPort(settings.value("port").toInt());
           ncn->setConnectString(settings.value("connectString").toString());
           ncn->setSslMode(settings.value("sslMode").toString());
           ncn->setPwdMethod(settings.value("pwdMethod").toString());
           ncn->setDSNCanBeUsed(settings.value("dsnCanBeUsed",ncn->connectString().isEmpty()).toBool());
        }

        if(!nc->connections.contains(ncn))
        {
//    nc->connections.append( ncn);
//    nc->connectionNames.append(ncn->description());
//    nc->connectionMap.insert(ncn->uniqueId().toString(), ncn);
           nc->addConnection(ncn);
           //nc->descrByConnection.insert(ncn, ncn->description());
        }
        if(!uuidConnectionMap.contains(ncn->uniqueId()))
            uuidConnectionMap.insert(ncn->uniqueId(),ncn);
        else
        {
            ncn->setUniqueId(QUuid::createUuid());
            //nc->descrByConnection.insert(ncn, ncn->description());
        }
        nc->connectionByUuid.insert(ncn->uniqueId(), ncn);
        nc->connectionByDescr.insert(ncn->description(),ncn);
      }
      settings.endArray();

      if(currentCityId < 0)
      {
         currCity = cityList.at(0);
      }

      //qDebug() << "city bounds:" << cityBounds;
    } // end cities

#if 0 // for testing purposes, create a MySql connection
  City* currCity = cityList.at(3);

  Connection* nc = new Connection();
  nc->setId(1);
  nc->setDatabase("StLouisMySql");
  nc->setDescription ("Test MySql connection");
  nc->setDriver("QMYSQL");
  nc->setDSN("");
  nc->setUID("allen");
  nc->setPWD("iic723");
  nc->setServerType("MySql");
  nc->setHost("192.168.1.101");
  nc->setPort(3306);
  currCity->connections.insert(nc->description(),nc);
  currConnection = nc;
#endif

#if 0 // for testing purposes, create a MsSql connection
  City* currCity = cityList.at(3);

  Connection* nc = new Connection();
  nc->setId(1);
  nc->setDatabase("Mapper");
  nc->setDescription ("Test MsSql connection");
  nc->setDriver("QODBC");
  nc->setDSN("");
  nc->setUID("");
  nc->setPWD("");
  nc->setServerType("MsSql");
  nc->setHost("");
  nc->setPort(0);
  currCity->connections.insert(nc->description(),nc);
  //currConnection = nc;
#endif

   settings.endArray();



   //settings.beginGroup("General");
   currentCityId = settings.value("currCity",0).toInt();
   if(currentCityId < 0 || currentCityId >= cityList.count())
      currentCityId = 0;
   currCity = cityList.at(currentCityId);
   if(currCity->curConnectionId < 0 && currCity->connections.size() == 1)
      currCity->curConnectionId =0;
   currConnection =   currCity->connections.at(currCity->curConnectionId);
   bDisplayWebDebug = settings.value("showDebugMessages", false).toBool();
   bRunInBrowser = settings.value("runInBrowser", false).toBool();
   saveImageDir = settings.value("saveImageDir", "").toString();
   bShowGMFeatures = settings.value("showGMFeatures", true).toBool();
   bForeignKeyCheck = settings.value("foreignKeyCheck", true).toBool();
   bDisplayDebugMsgs = settings.value("displayDebugMsgs", false).toBool();
   bDisplaySegmentArrows = settings.value("displayArrows", false).toBool();
   bDisplayRouteOnReload = settings.value("displayRouteOnReload",false).toBool();
   mapId = settings.value("mapId", "DEMO_MAP_ID").toString();
   // if(mapId.isEmpty())
   //     mapId = "DEMO_MAP_ID";
   mapType = settings.value("mapType", "ROADMAP").toString();
   tileServerUrl = settings.value("tileServerUrl", "https://ubuntu-2/public/map_tiles/").toString();
   mapSource = settings.value("mapSource", MAPSOURCE::GOOGLEMAPS).toInt();
   QFont f;
   f.fromString(settings.value("font").toString());
   font =f;
// #ifdef Q_OS_MACOS
//    macOSPublic = settings.value("macOsPublic", "").toString();
// #endif
   settings.beginGroup("query");
   q.b_stop_query_on_error = settings.value("stop_query_on_error").toBool();
   q.b_sql_execute_after_loading = settings.value("sql_execute_after_loading").toBool();
   q.s_query_path = settings.value("queryPath", QDir::homePath()+"/Resources/sql/").toString();
   q.geometry = settings.value("geometry").toByteArray();
   settings.endGroup();

   settings.beginGroup("routeView");
   rv.hiddenColumns = settings .value("routeView_hidden_cols").toList();
   rv.movedColumns = settings.value("routeView_moved_cols").toList();
   rv.state = settings.value("routeView_state").toByteArray();
   rv.columnCount = settings.value("routeview_columnCount",RouteViewTableModel::ENDDATE+1).toInt();
   settings.endGroup();

   settings.beginGroup("streetView");
   sv.state = settings.value("streetView_state").toByteArray();
   sv.colWidths = stringToList(settings.value("columnWidths").toString());
   settings.endGroup();

   settings.beginGroup("dupSegmentView");
   dsv.state = settings.value("dupSegmentViewState").toByteArray();
   settings.endGroup();

   settings.beginGroup("dlgUpdateStreets");
   dus.state = settings.value("state").toByteArray();
   dus.colWidths = stringToList(settings.value("columnWidths").toString());
   dus.geometry = settings.value("geometry").toByteArray();
   dus.text1 = settings.value("text1").toString();
   dus.text2 = settings.value("text2").toString();
   dus.date = settings.value("date").toDate();
   settings.endGroup();

   settings.beginGroup("routeCommentsDlg");
   rcd.state = settings.value("state").toByteArray();
   rcd.geometry = settings.value("geometry").toByteArray();
   rcd.hiddenColumns = settings .value("hidden_cols").toList();
   rcd.columnCount = settings.value("columnCount").toInt();
   settings.endGroup();

   int sizec = settings.beginReadArray("allowedSources");
   allowedSources.clear();
   for(int j = 0; j < sizec; j++)
   {
       // QVariant var = settings.value("allowedSource");
       // if (var.canConvert<QPair<QString,bool>>())
       QPair<QString,bool> pair;
       // pair.first = settings.value("allowedSource").toString();
       // pair.second = settings.value("allowed").toBool();
       // allowedSources.append( pair);
       allowedSources.insert(settings.value("allowedSource").toString(), settings.value("allowed").toBool());

   }
   settings.endArray();

   buildOverlayLists(); // build lists for cities

   for(Overlay* ov : Overlay::overlayList)
   {
      overlayMap->insert(ov->cityName+"|"+ov->name, ov);
      City* city = cityMap.value(ov->cityName);
      if(city)
      {
         city->addOverlay(ov);
      }
   }
}

void Configuration::getSettings2()
{
    QSettings settings;
    qDebug() << settings.fileName();
    if(!odbcUtil)
        odbcUtil = ODBCUtil::instance();
    odbcUtil->initialize();

    // int size = settings.beginReadArray("cities");
    // if( size == 0)
    QStringList groups = settings.childGroups();
    if(groups.isEmpty())
    {
        createDefaultSettings();
    }
#ifdef Q_OS_MACOS

    //bUseBundleResources = settings.value("useBundleResources",false).toBool();
    startCwd = cwd = QDir::currentPath();
    qDebug() << "starting configure with CWD = '" << cwd;

    if(cwd == "/")
        cwd.append("Applications");
    if(!cwd.contains("mapper.app"))
    {
        QDir dir(cwd + "/mapper.app");
        if(dir.exists())
            cwd.append("/mapper.app/Contents/MacOS");
        else
            QMessageBox::critical(nullptr, tr("error"),tr("mapper.app not found in %1").arg(cwd));

    }

    if( cwd.contains("/mapper.app/Contents/MacOS"))
    {
        //
        // QDir resources(cwd.remove("/mapper.app/Contents/MacOS") + "/Resources");
        //  if(resources.exists())
        //  {
        // running in development environment, set the cwd to that of the development.
        //if(bUseBundleResources)
        // cwd = cwd.remove("/mapper.app/Contents");

        cwd = cwd.remove("/MacOS");
        QDir::setCurrent(cwd);

        // QDir pDir(QDir::homePath() +"/Public/Mapper/Resources");
        // if(!pDir.exists())
        //  copyFiles(cwd + "/Resources", QDir::homePath() +"/Public/Mapper/Resources");
        //}
    }
    else
    {
        //     {
        //         //processCopyList();
        cwd = cwd.remove("/mapper.app/Contents");
        QDir::setCurrent(cwd);
        //     }
    }
#endif

    bool ok = Overlay::importXml("./Resources/overlays.xml");

    // load cities
    settings.beginGroup("Cities");
    QStringList cities = settings.childGroups();
    //for(int i= 0; i < size; i++)
    QMap<int,City*> cityListById;
    foreach (QString city, cities) {
        //settings.setArrayIndex(i);
        settings.beginGroup(city);
        City* nc = new City();
        nc->id = settings.value("id").toInt();
        nc->setName(settings.value("name").toString());
        // if(!cityList.contains(nc))
        // {
        //     cityList.append(nc);
        //     cityMap.insert(nc->name(), nc);
        // }
        if(!cityListById.contains(nc->id))
        {
            cityListById.insert(nc->id, nc);
            cityMap.insert(nc->name(), nc);
        }
        LatLng pt;
        //  qDebug() << "lat: " << settings.value("lat",35).toString();
        //  qDebug() << "lon: " << settings.value("lon",-90).toString();
        pt.setLat(settings.value("lat",35).toDouble());
        pt.setLon(settings.value("lon",-90).toDouble());
        nc->center = pt;
        nc->setBounds(Bounds(settings.value("bounds").toString()));
        if(!nc->bounds().isValid())
        {
            nc->setBounds(Bounds(LatLng(pt.lat()-.1, pt.lon()-.1), LatLng(pt.lat()+.1, pt.lon()+.1)));
        }
        if(nc->bounds().isValid()){
            cityBounds.insert(nc->name(), nc->bounds());
            // if(!nc->bounds().contains(pt))
            //     nc->center = nc->bounds().center();
        }
        qInfo() << nc->name() << tr(" map center lat: %1 lng: %2 ").arg(nc->center.lat(),0,'f',8).arg(nc->center.lon(),0,'f',8);

        nc->mapType = settings.value("maptype","roadmap").toString();
        nc->mapId = settings.value("mapid","??").toString();
        nc->zoom = settings.value("zoom",12).toInt();
        nc->curConnectionId = settings.value("currConnection",0).toInt();
        nc->curUuid = settings.value("curUuid").toUuid();
        nc->curExportConnId = settings.value("currExportConnId",0).toInt();
        nc->bAlphaRoutes = settings.value("AlphaRoutes").toBool();
        nc->bNoPanOpt = settings.value("noPanOpt").toBool();
        nc->bGeocoderRequest = settings.value("GeocoderRequest").toBool();
        nc->lastRoute = settings.value("lastRoute",0).toInt();
        nc->lastRouteName = settings.value("lastRouteName").toString();
        nc->lastRouteEndDate = settings.value("lastRouteEndDate").toString();
        nc->bDisplayStationMarkers = settings.value("displayStationMarkers",false).toBool();
        nc->bDisplayRouteComments = settings.value("displayRouteComments",false).toBool();
        nc->bDisplayTerminalMarkers = settings.value("displayTerminalMarkers",false).toBool();
        nc->bShowOverlay = settings.value("showOverlay").toBool();
        nc->companyKey = settings.value("companyKey").toInt();
        nc->routeSortType = settings.value("routeSortType").toInt();
        nc->savedClipboard = settings.value("savedClipboard").toString();
        nc->curOverlayId = settings.value("currOverlay", -1).toInt();
        nc->bUserMap = settings.value("userMap", false).toBool();
        if(nc->city_overlayMap->isEmpty())
            nc->bShowOverlay = false;
        nc->bDisplayMapInBrowser = settings.value("displayMapInBrowser", bRunInBrowser).toBool();
        nc->mapSource = settings.value("mapSource", mapSource).toInt();
        remove("selectedCompanies");
        nc->bDisplayRoutesForSelectedCompanies = settings.value("displayRoutesForGroup",!nc->selectedCompaniesList.isEmpty()).toBool();
        // QString abbreviationsStr = settings.value("abbreviations").toString();
        // QStringList list =  abbreviationsStr.split(",");
        // nc->abbreviationsList.clear();
        // foreach(QString aPair, list)
        // {
        //     if(aPair.isEmpty())
        //         continue;
        //     QStringList values = aPair.split(":");
        //     nc->abbreviationsList.append(QPair<QString, QString>(values.at(0),values.at(1)));
        // }

        nc->setConnectionUniqueId(QUuid::fromString(settings.value("currConnectionUuid").toString()));
        QString baseAddr;
        baseAddr = QDir::currentPath() +QDir::separator() + "Resources" + QDir::separator()+"databases" + QDir::separator();
        //int sizec = settings.beginReadArray("connections");
        settings.beginGroup("connections");
        // connections
        QStringList connections = settings.childGroups();
        QMap<int, Connection*> connectionsById;
        //for(int j = 0; j < sizec; j++)
        foreach(QString connection, connections)
        {
            //settings.setArrayIndex(j);
            settings.beginGroup(connection);
            QString uuid_string = settings.value("uniqueId").toString();
            QUuid uuid;
            if(uuid_string.isEmpty())
                uuid = QUuid::createUuid();
            else
                uuid = QUuid::fromString(uuid_string);
            Connection* ncn = new Connection(uuid);
            ncn->setId(settings.value("id", -1).toInt());
            ncn->setDescription(settings.value("description").toString());
            ncn->setDriver(settings.value("driver").toString());
            ncn->setServerType(settings.value("serverType").toString());
            ncn->setCityName(settings.value("cityName", nc->name()).toString());
            ncn->setConnectionType(settings.value("connectionType", "Direct").toString());
            ncn->setUniqueId(QUuid::fromString(settings.value("uniqueId", QUuid::createUuid().toString()).toString()));
            if(ncn->id() == nc->curConnectionId)
                nc->setConnectionUniqueId(uuid);
            if(ncn->connectionType() == "Sqlite" || ncn->connectionType() == "Local")
            {
                ncn->setConnectionType("Sqlite");
                QString fileName;
                fileName = settings.value("sqliteFileName").toString();
                if(fileName.isEmpty())
                    fileName = settings.value("database").toString();
                QFileInfo info(baseAddr + fileName);
                if(!info.exists())
                    qDebug() << fileName << " not found";
                else
                {
                    //QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE", "city");
                    // Reuse connection if it exists, otherwise create it fresh
                    QSqlDatabase db;
                    QString cName = "city";
                    QString driver = "QSQLITE";
                    if (QSqlDatabase::contains(cName)) {
                        db = QSqlDatabase::database(cName);

                        // Safety check: If the driver changed, we MUST recreate the connection handle
                        if (db.driverName() != driver) {
                            db = QSqlDatabase::addDatabase(driver, cName);
                        }
                    } else {
                        db = QSqlDatabase::addDatabase(driver, cName);
                    }
                    db.setDatabaseName(baseAddr + fileName);
                    if(db.open())
                    {
                        Parameters p;
                        if(SQL::instance()->getParameters(&p,db))
                        {
                            if(!p.city.isEmpty())
                            {
                                ncn->setCityName(p.city);
                                nc->setNameOverride(p.city);
                            }
                        }
                        db.close();
                    }
                }
                ncn->setSqliteFileName(fileName);
            }
            else if(ncn->connectionType() == "Direct") {
                //ncn->setDSN(settings.value("DSN").toString());  // not needed
                ncn->setPWD(settings.value("PWD").toString());
                ncn->setUserId(settings.value("UID").toString());
                ncn->setHost(settings.value("hostname").toString());
                ncn->setPort(settings.value("port").toInt());
                ncn->setDefaultSqlDatabase(settings.value("defaultSqlDatabase").toString());
                ncn->setDatabase(settings.value("database").toString());
                //ncn->setMySqlDatabase(settings.value("mySqlDatabase").toString());
            }
            else if(ncn->connectionType() == "ODBC") {
                ncn->setDSN(settings.value("DSN").toString());
                if(!settings.value("odbcConnector").toString().isEmpty())
                    ncn->setDSN(settings.value("odbcConnector").toString());
                ncn->setDefaultSqlDatabase(settings.value("defaultSqlDatabase").toString());
                ncn->setDatabase(settings.value("database").toString());
                ncn->setPWD(settings.value("PWD").toString());
                ncn->setUserId(settings.value("UID").toString());
                ncn->setHost(settings.value("hostname").toString());
                ncn->setPort(settings.value("port").toInt());
                ncn->setConnectString(settings.value("connectString").toString());
                ncn->setSslMode(settings.value("sslMode").toString());
                ncn->setPwdMethod(settings.value("pwdMethod").toString());
                ncn->setDSNCanBeUsed(settings.value("dsnCanBeUsed",ncn->connectString().isEmpty()).toBool());
                ncn->setConnectionName(nc->getLabel());
            }

            //if(!nc->connections.contains(ncn))
            if(!connectionsById.contains(ncn->id()))
            {
                //    nc->connections.append( ncn);
                //    nc->connectionNames.append(ncn->description());
                //    nc->connectionMap.insert(ncn->uniqueId().toString(), ncn);
                //nc->addConnection(ncn);
                connectionsById.insert(ncn->id(), ncn);
                //nc->descrByConnection.insert(ncn, ncn->description());
            }
            nc->connectionByUuid.insert(ncn->uniqueId(), ncn);
            if(!uuidConnectionMap.contains(ncn->uniqueId()))
                uuidConnectionMap.insert(ncn->uniqueId(),ncn);
            else
            {
                ncn->setUniqueId(QUuid::createUuid());
                //nc->descrByConnection.insert(ncn, ncn->description());

            }
#ifdef QTKEYCHAIN_VERSION_6
            QString key;
            QString pwd;
            if(!ncn->connectString().isEmpty())
                key = createSecureVaultKey(ncn->connectString(), nc, &pwd);
            else
                key = createSecureVaultKey(ncn, nc);
            qDebug() << "secure vault key: " << key;
            if(!key.isEmpty())
            {
                if(!ncn->pwd().isEmpty())
                {
                    vault->savePassword(key, ncn->pwd());
                }
                else
                {
                    vault->loadPassword(key, [=](const QString &password) {
                        if (password.isEmpty()) {
                            qWarning() << "Could not retrieve password or password is empty."
                                       << " key: "<< key;;
                            return;
                        }

                        // Your asynchronous callback logic continues inside this block
                        qDebug() << "Password successfully retrieved! " << key;
                        ncn->setPWD(password);

                        // Example: Initiate your database connection
                        // this->initializeDatabaseConnection(password);
                    });
                }
            }
#endif
            settings.endGroup();
            qDebug() << settings.group();
        } // end connection
        //settings.endArray();
        settings.endGroup();
        nc->connections = connectionsById.values();
        qDebug() << settings.group();
        if(currentCityId < 0)
        {
            //currCity = cityList.at(0);
            currCity = cityListById.values().at(0);
        }

        //qDebug() << "city bounds:" << cityBounds;
        settings.endGroup(); // end a city
        qDebug() << settings.group();
    } // end cities
    settings.endGroup(); // end cities
    cityList = cityListById.values();
qDebug() << settings.group();
#if 0 // for testing purposes, create a MySql connection
  City* currCity = cityList.at(3);

  Connection* nc = new Connection();
  nc->setId(1);
  nc->setDatabase("StLouisMySql");
  nc->setDescription ("Test MySql connection");
  nc->setDriver("QMYSQL");
  nc->setDSN("");
  nc->setUID("allen");
  nc->setPWD("iic723");
  nc->setServerType("MySql");
  nc->setHost("192.168.1.101");
  nc->setPort(3306);
  currCity->connections.insert(nc->description(),nc);
  currConnection = nc;
#endif

#if 0 // for testing purposes, create a MsSql connection
  City* currCity = cityList.at(3);

  Connection* nc = new Connection();
  nc->setId(1);
  nc->setDatabase("Mapper");
  nc->setDescription ("Test MsSql connection");
  nc->setDriver("QODBC");
  nc->setDSN("");
  nc->setUID("");
  nc->setPWD("");
  nc->setServerType("MsSql");
  nc->setHost("");
  nc->setPort(0);
  currCity->connections.insert(nc->description(),nc);
  //currConnection = nc;
#endif

    //settings.endArray();
    //settings.endGroup();



    //settings.beginGroup("General");
    qDebug() << settings.group();

    currentCityId = settings.value("currCity",0).toInt();
    if(currentCityId < 0 || currentCityId >= cityList.count())
        currentCityId = 0;
    currCity = cityList.at(currentCityId);
    if(currCity->curConnectionId < 0 && currCity->connections.size() == 1)
        currCity->curConnectionId =0;
    currConnection =   currCity->connections.at(currCity->curConnectionId);
    qDebug() << "curr connection " << currConnection->connectionName() << " " << currConnection->driver();
    bDisplayWebDebug = settings.value("showDebugMessages", false).toBool();
    bRunInBrowser = settings.value("runInBrowser", false).toBool();
    saveImageDir = settings.value("saveImageDir", "").toString();
    bShowGMFeatures = settings.value("showGMFeatures", true).toBool();
    bForeignKeyCheck = settings.value("foreignKeyCheck", true).toBool();
    bDisplayDebugMsgs = settings.value("displayDebugMsgs", false).toBool();
    bDisplaySegmentArrows = settings.value("displayArrows", false).toBool();
    bDisplayRouteOnReload = settings.value("displayRouteOnReload",false).toBool();
    bDisplayMimerDistance = settings.value("displayMimerDistance", false).toBool();
    mapId = settings.value("mapId", "DEMO_MAP_ID").toString();
    // if(mapId.isEmpty())
    //     mapId = "DEMO_MAP_ID";
    mapType = settings.value("mapType", "ROADMAP").toString();
    tileServerUrl = settings.value("tileServerUrl", "https://ubuntu-2/public/map_tiles/").toString();
    mapSource = settings.value("mapSource", MAPSOURCE::GOOGLEMAPS).toInt();
    settingsVersion = settings.value("settingsVersion").toInt();

    qDebug() << "group: "  <<settings.group();
    currentOverlays.clear();
    int sizeo = settings.beginReadArray("currentOverlays");
    for(int j = 0; j < sizeo; j++)
    {
        settings.setArrayIndex(j);
        currOpacity = settings.value("opacity", 65).toInt();
        QString name = settings.value("name").toString();
        QUuid ovUuid = QUuid(settings.value("uuid").toString());
        foreach (Overlay* ov, Overlay::overlayList) {

            if(ov->uuid() == ovUuid || ov->name == name)
            {
                ov->opacity = currOpacity;
                currentOverlays.append(ov);
            }
        }
    }
    settings.endArray();
    QFont f;
    f.fromString(settings.value("font").toString());
    font =f;
    //settings.endGroup(); // general

    // #ifdef Q_OS_MACOS
    //    macOSPublic = settings.value("macOsPublic", "").toString();
    // #endif
    settings.beginGroup("query");
    q.b_stop_query_on_error = settings.value("stop_query_on_error").toBool();
    q.b_sql_execute_after_loading = settings.value("sql_execute_after_loading").toBool();
    q.s_query_path = settings.value("queryPath", QDir::homePath()+"/Resources/sql/").toString();
    q.geometry = settings.value("geometry").toByteArray();
    settings.endGroup();

    settings.beginGroup("routeView");
    rv.hiddenColumns = settings .value("routeView_hidden_cols").toList();
    rv.movedColumns = settings.value("routeView_moved_cols").toList();
    rv.state = settings.value("routeView_state").toByteArray();
    rv.columnCount = settings.value("routeview_columnCount",RouteViewTableModel::ENDDATE+1).toInt();
    settings.endGroup();

    settings.beginGroup("streetView");
    sv.state = settings.value("streetView_state").toByteArray();
    sv.colWidths = stringToList(settings.value("columnWidths").toString());
    settings.endGroup();

    settings.beginGroup("dupSegmentView");
    dsv.state = settings.value("dupSegmentViewState").toByteArray();
    settings.endGroup();

    settings.beginGroup("dlgUpdateStreets");
    dus.state = settings.value("state").toByteArray();
    dus.colWidths = stringToList(settings.value("columnWidths").toString());
    dus.geometry = settings.value("geometry").toByteArray();
    dus.text1 = settings.value("text1").toString();
    dus.text2 = settings.value("text2").toString();
    dus.date = settings.value("date").toDate();
    settings.endGroup();

    settings.beginGroup("editCityDialog");
    ecd.state = settings.value("state").toByteArray();
    ecd.colWidths = stringToList(settings.value("columnWidths").toString());
    ecd.geometry = settings.value("geometry").toByteArray();
    settings.endGroup();

    settings.beginGroup("routeCommentsDlg");
    rcd.state = settings.value("state").toByteArray();
    rcd.geometry = settings.value("geometry").toByteArray();
    rcd.hiddenColumns = settings .value("hidden_cols").toList();
    rcd.columnCount = settings.value("columnCount").toInt();
    settings.endGroup();

    int sizec = settings.beginReadArray("allowedSources");
    allowedSources.clear();
    for(int j = 0; j < sizec; j++)
    {
        settings.setArrayIndex(j);
        // QVariant var = settings.value("allowedSource");
        // if (var.canConvert<QPair<QString,bool>>())
        // QPair<QString,bool> pair;
        // pair.first = settings.value("allowedSource").toString();
        // pair.second = settings.value("allowed").toBool();
        // allowedSources.append( pair);
        allowedSources.insert(settings.value("allowedSource").toString(),settings.value("allowed").toBool());
    }
    settings.endArray();

    buildOverlayLists(); // build lists for cities

    for(Overlay* ov : Overlay::overlayList)
    {
        overlayMap->insert(ov->cityName+"|"+ov->name, ov);
        City* city = cityMap.value(ov->cityName);
        if(city)
        {
            city->addOverlay(ov);
        }
    }
} // end getSettings2

bool Configuration::buildOverlayLists()
{
    // for each city, build the list of overlays
    bool rslt = Overlay::importXml("./Resources/overlays.xml");
    QList<Overlay*> overlayList;
    if(rslt)
    {
        overlayList = Overlay::overlayList;
        for(Overlay* ov : overlayList)
        {
            QString cityName = ov->cityName;
            City* city = cityMap.value(ov->cityName);
            if(city && !ov->bounds().isValid())
            {
                ov->setBounds(Bounds(LatLng(city->center.lat()-.3, city->center.lon()-.3), LatLng(city->center.lat()+.3, city->center.lon()+.3)));
            }
            if(!allowedSources.contains(ov->_layerName))
            {
                QUrl url = QUrl(ov->url());
                QString host = url.toString(QUrl::RemovePath | QUrl::RemoveQuery);

                allowedSources.insert(host,ov->isSelected);
            }
            overlayMap->insert(ov->cityName+"|"+ov->name, ov);
            if(city && city->name() == ov->cityName)
            {
                if(ov->isSelected)
                {
                    if(ov->url().isEmpty())
                        ov->isSelected=false;
                    QUrl url = QUrl(ov->url());
                    QString host = url.toString(QUrl::RemovePath | QUrl::RemoveQuery);
                    QPair<QString,bool> pair =QPair<QString,bool>(host,true);
                    ov->isSelected = allowedSources.contains(host);
                    city->city_overlayMap->insert(ov->name, ov);
                    qInfo() << "add overlay " << ov->name << " for city:" << city->name();
                }
            }
        }
    }
    else {
        throw Exception();
    }
    return true;
}

void Configuration::setOverlay(Overlay* ov)
{
 for(int i=0; i < currCity->city_overlayMap->count(); i++)
 {
  Overlay* o  =  currCity->city_overlayMap->values().at(i);
  if(ov->name == o->name)
  {
   o->opacity = ov->opacity;
   //currCity->overlayMap->replace(i, o);
   if(ov->isSelected)
   currCity->addOverlay(ov);
  }
 }
}

Configuration* Configuration::_instance = NULL;

Configuration* Configuration::instance()
{
 if(_instance == NULL)
  _instance = new Configuration();
 return _instance;
}

QStringList Configuration::cityNames()
{
 QStringList result;
 for(City* city : cityList)
  result.append(city->name());
 return result;
}

void Configuration::addCity(City* city)
{
    if(!cityMap.contains(city->name()))
    {
        cityList.append(city);
        cityMap.insert(city->name(), city);
        if(city->bounds().isValid())
         cityBounds.insert(city->name(), city->bounds());
        currCity = city;
        city->setId(cityList.count()-1);
        currentCityId = city->id;
        emit newCityCreated(city);
    }
}

QString Configuration::lookupCityName(Bounds b)
{
 QMapIterator<QString, Bounds> iter(cityBounds);
 while(iter.hasNext())
 {
  iter.next();
  if(iter.value().contains(b))
     return iter.key();
 }
 return "";
}

void Configuration::createDefaultSettings()
{
    //  create a default configuration
    City* newCity = new City();
    newCity->id = 0;
    newCity->setName("St Louis, MO");
    double latitude = 38.65858545118455;
    double longitude = -90.34764714500002;
    newCity->center = LatLng(latitude, longitude);
    qint32 zoom = 10;
    QString maptype = "roadmap";
    newCity->center = LatLng(latitude, longitude);
    newCity->setBounds(Bounds(LatLng(38.558585451, -90.447647145), LatLng(38.758585451, -90.247647145)));
    newCity->zoom = zoom;
    newCity->mapType = maptype;
    newCity->curConnectionId = 0;
    newCity->companyKey=0;
    if(!cityList.contains(newCity))
    {
     cityList.append( newCity);
     cityMap.insert(newCity->name(), newCity);
    }
    //newCity->connectionNames.append(newCity->name());
    Connection* nc = new Connection();
    nc->setId(0);
    nc->setSqliteFileName("StLouis.sqlite3");
    nc->setDescription ("StLouis SQLITE3 connection");
    nc->setDriver("QSQLITE");
    nc->setServerType("Sqlite");
    nc->setConnectionType("Sqlite");

    nc->setCityName(newCity->name());
    if(!newCity->connections.contains(nc))
    {
//     newCity->connections.append( nc);
//     newCity->connectionNames.append(nc->description());
        newCity->addConnection(nc);
    }
    currConnection = nc;

    newCity = new City();
    newCity->id = 1;
    newCity->setName("Cincinnati, OH");
    latitude = 39.10457;
    longitude = -84.51382;
    //qint32 zoom = settings.value("zoom").toInt();
    newCity->center = LatLng(latitude, longitude);
    newCity->setBounds(Bounds(LatLng(38.995919924, -84.788475037), LatLng(39.213049836, -84.23915863)));
    newCity->zoom = zoom;
    newCity->mapType = maptype;
    newCity->curConnectionId =0 ;
    newCity->companyKey=0;
    if(!cityList.contains(newCity))
    {
     cityList.append(newCity);
     cityMap.insert(newCity->name(),newCity);
    }
    nc = new Connection();
    nc->setId(0);
    nc->setSqliteFileName("cincinnati.sqlite3");
    nc->setDescription ("Cincinnati SQLITE3 connection");
    nc->setDriver("QSQLITE");
    nc->setServerType("Sqlite");
    nc->setConnectionType("Sqlite");
    if(!newCity->connections.contains(nc))
    {
//     newCity->connections.append( nc);
//     newCity->connectionNames.append(nc->description());
        newCity->addConnection(nc);
    }

    currConnection = nc;

    newCity = new City();
    newCity->id = 2;
    newCity->setName("Louisville, KY");
    latitude = 38.25228;
    longitude = -85.76115;
    //qint32 zoom = settings.value("zoom").toInt();
    newCity->center = LatLng(latitude, longitude);
    newCity->setBounds(Bounds(LatLng(38.15228, -85.86115), LatLng(38.35228, -85.66115)));
    newCity->zoom = zoom;
    newCity->mapType = maptype;
    newCity->curConnectionId = 0 ;
    newCity->companyKey=0;
    if(!cityList.contains(newCity))
    {
     cityList.append(newCity);
     cityMap.insert(newCity->name(), newCity);
    }
    nc = new Connection();
    nc->setId(0);
    nc->setSqliteFileName("louisville.sqlite3");
    nc->setDescription ("Louisville SQLITE3 connection");
    nc->setServerType("Sqlite");
    nc->setCityName(newCity->name());
    nc->setConnectionType("Sqlite");
    if(!newCity->connections.contains(nc))
    {
//     newCity->connections.append( nc);
//     newCity->connectionNames.append(nc->description());
        newCity->addConnection(nc);
    }
    currConnection = nc;

    newCity = new City();
    newCity->id = 3;
    newCity->setName("Berlin, Deutschland");
    latitude = 52.5315;
    longitude = 13.00165;
    newCity->center = LatLng(latitude, longitude);
    newCity->setBounds(Bounds(LatLng(52.4315, 12.90165), LatLng(52.6315, 13.10165)));
    newCity->zoom = zoom;
    newCity->mapType = maptype;
    newCity->curConnectionId = 0 ;
    newCity->companyKey=0;
    if(!cityList.contains(newCity))
    {
     cityList.append(newCity);
     cityMap.insert(newCity->name(), newCity);
    }
    nc = new Connection();
    nc->setId(0);
    nc->setSqliteFileName("berlinerstrassenbahn.sqlite3");
    nc->setDescription ("Berlin SQLITE3 connection");
    nc->setDriver("QSQLITE");
    nc->setServerType("Sqlite");
    nc->setCityName(newCity->name());
    nc->setConnectionType("Sqlite");
    if(!newCity->connections.contains(nc))
    {
     newCity->connections.append( nc);
     newCity->connectionNames.append(nc->description());
    }

    //"str:straße,Str:Straße,pl:platz,Pl:Platz,ch:chaussee,Ch:Chaussee"

    currConnection = nc;

    newCity = new City();
    newCity->id = 4;
    newCity->setName("Indianapolis, IN");
    latitude = 39.768495;
    longitude = -86.158042;
    newCity->center = LatLng(latitude, longitude);
    //newCity->setBounds(Bounds(LatLng(52.4315, 12.90165), LatLng(52.6315, 13.10165)));
    newCity->zoom = zoom;
    newCity->mapType = maptype;
    newCity->curConnectionId = 0 ;
    newCity->companyKey=0;
    if(!cityList.contains(newCity))
    {
     cityList.append(newCity);
     cityMap.insert(newCity->name(), newCity);
    }
    nc = new Connection();
    nc->setId(0);
    nc->setSqliteFileName("indianapolis.sqlite3");
    nc->setDescription ("Indianapolis SQLITE3 connection");
    nc->setDriver("QSQLITE");
    nc->setServerType("Sqlite");
    nc->setCityName(newCity->name());
    nc->setConnectionType("Sqlite");
    if(!newCity->connections.contains(nc))
    {
     newCity->connections.append( nc);
     newCity->connectionNames.append(nc->description());
    }
    currConnection = nc;

    Overlay* ov = new Overlay("St Louis, MO", "St_Louis_historical_topo");
    //Q_ASSERT(!ov->url().isEmpty());
    newCity->addOverlay(ov);

    newCity->curOverlayId = 0;
    newCity->bShowOverlay =true;

    currentCityId = 0;
    currConnection = newCity->connections.at(0);
    currConnection->setId(newCity->curConnectionId);
    if(Overlay::importXml("./Resources/overlays.xml"))
    {
     for(Overlay* ov : Overlay::overlayList)
     {
      overlayMap->insert(ov->cityName+"|"+ov->name, ov);
      currCity = cityList.at(0);
      City* city = cityMap.value(ov->cityName);
      if(city)
      {
          Q_ASSERT(!ov->url().isEmpty());
       city->addOverlay(ov);
      }
     }
    }
    if(QGuiApplication::screens().count() > 1)
     bRunInBrowser = true;
    saveSettings2();

    return;

} // end default configuration

void Configuration::changeFonts(QWidget* obj,QFont f)
{
    QList<QWidget*> objlistChildren = obj->findChildren<QWidget*>();
    int iCount = objlistChildren.count();

    for(int iIndex = 0; iIndex < iCount; iIndex++)
    {
        QWidget *temp = objlistChildren[iIndex];
        temp->setFont(f);
    }
}
QString Configuration::listToString(QList<int> list)
{
    QString rslt;
    if(list.isEmpty())
        return rslt;
    foreach (int i, list) {
        rslt = rslt + QString::number(i)+ ",";
    }
    rslt.chop(1);
    return rslt;
}

QList<int> Configuration::stringToList(QString str)
{
    QList<int> rslt;
    QStringList sl = str.split(",");
    bool ok;
    foreach (QString s, sl) {
        int i = s.toInt(&ok);
        if(ok)
            rslt.append(i);
        else
            return rslt;
    }
    return rslt;
}

QString Configuration::createSecureVaultKey(Connection* connection, City* city)
{
    QString key;
    if(connection->userId().isEmpty())
        return key;
    if(connection->servertype() == "Sqlite")
        return key;
    key = connection->userId() + "|";
    key.append(city->getLabel() +"|");
    key.append(connection->servertype() + "|");
    if(!connection->host().isEmpty())
        key.append(connection->host());
    else
    {
        if(!connection->dsn().isEmpty())
        {
            DSN* dsn = odbcUtil->getDsn(connection->dsn());
            if(dsn && !dsn->server.isEmpty())
            {
                key.append(dsn->server);
                return key;
            }
        }
        // TODO: get values from a connection string
    }
    return key;
}

QString Configuration::createSecureVaultKey(QString connectString, City* city, QString *password)
{
    QString key;
    QMap<QString,QString> map = Connection::decodeConnectionString(connectString);
    // Driver={PostgreSQL ODBC Driver(UNICODE)};Server=ubuntu-2;Port=5432;User Id=allen;Password=iic723@knobacres;Database=stlouis;sslmode=prefer;
    // Driver={MIMER};Protocol=tcp;Node=ubuntu-2;Service=1360;Database=stlouis_db;Uid=mapperuser;Pwd=iic723@knobacres;
    QString driver = map.value("Driver");
    if(driver == "{MIMER}")
    {
        key.append(map.value("Uid") + "|");
        key.append(city->getLabel() + "|");
        key.append("MimerSql") + "|";
        key.append(map.value("Node"));
        *password = map.value("Pwd");
    }
    else if(driver.contains("PostgreSQL") )
    {
        key.append(map.value("User Id") + "|");
        key.append(city->getLabel() + "|");
        key.append("PostgreSQL") + "|";
        key.append(map.value("Server"));
        *password = map.value("Password");
    }
    else
    {
        qCritical() << "unknown connection string driver: " << driver;
        return key;
    }
    return key;
}