FeatureNomenclature.cpp

#include "IsisDebug.h"
#include "FeatureNomenclature.h"

#include <QDebug>
#include <QDomElement>
#include <QGridLayout>
#include <QLabel>
#include <QList>
#include <QMessageBox>
#include <QNetworkAccessManager>
#include <QNetworkRequest>
#include <QNetworkReply>
#include <QPair>
#include <QUrl>

#include "Distance.h"
#include "IException.h"
#include "IString.h"
#include "iTime.h"
#include "Latitude.h"
#include "Longitude.h"

namespace Isis {
  
  FeatureNomenclature::FeatureNomenclature() {
    m_networkMgr = NULL;
    m_request = NULL;
    m_features = NULL;

    m_networkMgr = new QNetworkAccessManager;
    connect(m_networkMgr, SIGNAL(finished(QNetworkReply *)),
            this, SLOT(requestFinished(QNetworkReply *)));

    m_request = new QNetworkRequest;
    m_request->setUrl(
        QUrl("http://planetarynames.wr.usgs.gov/nomenclature/SearchResults"));
    m_request->setRawHeader("User-Agent",
                            "Mozilla/5.0 (X11; Linux i686; rv:6.0) "
                            "Gecko/20100101 Firefox/6.0");
    m_request->setHeader(QNetworkRequest::ContentTypeHeader,
                         "application/x-www-form-urlencoded");
    m_lastQuery = true;
  }


  FeatureNomenclature::FeatureNomenclature(const FeatureNomenclature &other) {
    m_networkMgr = NULL;
    m_request = NULL;
    m_features = NULL;

    m_networkMgr = new QNetworkAccessManager;

    connect(m_networkMgr, SIGNAL(finished(QNetworkReply *)),
            this, SLOT(requestFinished(QNetworkReply *)));

    m_request = new QNetworkRequest;
    m_lastQuery = other.m_lastQuery;

    if (other.m_features)
      m_features = new QList<Feature>(*other.m_features);
  }


  FeatureNomenclature::~FeatureNomenclature() {
    delete m_networkMgr;
    m_networkMgr = NULL;

    delete m_request;
    m_request = NULL;

    delete m_features;
    m_features = NULL;
  }

  
  void FeatureNomenclature::queryFeatures(QString target,
                                          Latitude startLat, Longitude startLon,
                                          Latitude endLat, Longitude endLon) {
    
    QList< QPair<Longitude, Longitude> > range = Longitude::to360Range(startLon, endLon);

    if (!range.isEmpty()) {
      startLon = range[0].first;
      endLon = range[0].second;
    }
      
    if (range.size() > 1) {

      Longitude startLon2 = range[1].first;
      Longitude endLon2 = range[1].second;
      
      runQuery(target, startLat, startLon, endLat, endLon);
      runQuery(target, startLat, startLon2, endLat, endLon2);

      m_lastQuery = false;
    }
    else {
      runQuery(target, startLat, startLon, endLat, endLon);
      
      m_lastQuery = true;
    }
  }


  QList<FeatureNomenclature::Feature> FeatureNomenclature::features() const {
    QList<Feature> featureList;

    if (m_features)
      featureList = *m_features;

    return featureList;
  }


  bool FeatureNomenclature::hasResult() const {
    return (m_features != NULL);
  }


  void FeatureNomenclature::swap(FeatureNomenclature &other) {
    std::swap(m_networkMgr, other.m_networkMgr);
    std::swap(m_request, other.m_request);
    std::swap(m_features, other.m_features);
  }


  FeatureNomenclature &FeatureNomenclature::operator=(
      const FeatureNomenclature &rhs) {
    FeatureNomenclature tmp(rhs);
    swap(tmp);
    return *this;
  }


  bool FeatureNomenclature::featureDiameterGreaterThan(
      const FeatureNomenclature::Feature &lhs,
      const FeatureNomenclature::Feature &rhs) {
    Distance lhsDiameter = lhs.diameter();
    Distance rhsDiameter = rhs.diameter();

    bool greaterThan = false;
    if (lhsDiameter.isValid() && rhsDiameter.isValid()) {
      greaterThan = (lhsDiameter > rhsDiameter);
    }
    else {
      greaterThan = lhsDiameter.isValid();
    }

    return greaterThan;
  }


  FeatureNomenclature::Feature::Feature() {
    m_xmlRepresenation = NULL;
    m_approvalStatus = NoStatus;
  }


  FeatureNomenclature::Feature::Feature(QDomElement searchResultFeature, IAUStatus status) {
    m_xmlRepresenation = NULL;
    m_xmlRepresenation = new QDomElement(searchResultFeature);
    m_approvalStatus = status;
  }


  FeatureNomenclature::Feature::Feature(const Feature &other) {
    m_xmlRepresenation = NULL;
    // QDomElement does a shallow copy.
    m_approvalStatus = other.m_approvalStatus;
    m_xmlRepresenation = new QDomElement(*other.m_xmlRepresenation);
  }


  FeatureNomenclature::Feature::~Feature() {
    delete m_xmlRepresenation;
    m_xmlRepresenation = NULL;
  }


  QWidget *FeatureNomenclature::Feature::toWidget() const {
    QWidget *widget = new QWidget;

    QGridLayout *layout = new QGridLayout;
    widget->setLayout(layout);

    int row = 0;

    QLabel *titleLabel = new QLabel("<h2>Feature Details</h2>");
    layout->addWidget(titleLabel, row, 0, 1, 2);
    row++;

    QList< QPair<QString, QString (FeatureNomenclature::Feature::*)() const> >
        displayValues;

    QPair<QString, QString (FeatureNomenclature::Feature::*)() const>
        displayValue;

    displayValue.first = "Feature Name:";
    displayValue.second = &FeatureNomenclature::Feature::displayName;
    displayValues.append(displayValue);

//     displayValue.first = "Feature Name (clean):";
//     displayValue.second = &FeatureNomenclature::Feature::cleanName;
//     displayValues.append(displayValue);

    displayValue.first = "Feature ID:";
    displayValue.second = &FeatureNomenclature::Feature::id;
    displayValues.append(displayValue);

    displayValue.first = "Target:";
    displayValue.second = &FeatureNomenclature::Feature::target;
    displayValues.append(displayValue);

    displayValue.first = "System:";
    displayValue.second = &FeatureNomenclature::Feature::system;
    displayValues.append(displayValue);

    displayValue.first = "Control Network:";
    displayValue.second = &FeatureNomenclature::Feature::controlNet;
    displayValues.append(displayValue);

    displayValue.first = "Diameter:";
    displayValue.second = &FeatureNomenclature::Feature::diameterString;
    displayValues.append(displayValue);

    displayValue.first = "Originating Continent:";
    displayValue.second =
        &FeatureNomenclature::Feature::originatingContinent;
    displayValues.append(displayValue);

    displayValue.first = "Originating Ethnicity:";
    displayValue.second =
        &FeatureNomenclature::Feature::originatingEthnicity;
    displayValues.append(displayValue);

    displayValue.first = "Feature Type:";
    displayValue.second =
        &FeatureNomenclature::Feature::featureType;
    displayValues.append(displayValue);

    displayValue.first = "Center Latitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::centerLatitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Center Longitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::centerLongitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Northern Latitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::northernLatitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Southern Latitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::southernLatitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Eastern Longitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::easternLongitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Western Longitude:";
    displayValue.second =
        &FeatureNomenclature::Feature::westernLongitudeString;
    displayValues.append(displayValue);

    displayValue.first = "Approval Date:";
    displayValue.second =
        &FeatureNomenclature::Feature::approvalDate;
    displayValues.append(displayValue);

    displayValue.first = "Approval Status:";
    displayValue.second =
        &FeatureNomenclature::Feature::approvalStatus;
    displayValues.append(displayValue);

    displayValue.first = "Last Updated:";
    displayValue.second =
        &FeatureNomenclature::Feature::lastUpdated;
    displayValues.append(displayValue);

    displayValue.first = "Reference:";
    displayValue.second =
        &FeatureNomenclature::Feature::referenceString;
    displayValues.append(displayValue);

    displayValue.first = "Origin:";
    displayValue.second =
        &FeatureNomenclature::Feature::origin;
    displayValues.append(displayValue);

    displayValue.first = "URL:";
    displayValue.second =
        &FeatureNomenclature::Feature::referenceUrlString;
    displayValues.append(displayValue);

    for (int i = 0; i < displayValues.count(); i++) {
      QLabel *titleLabel = new QLabel(displayValues[i].first);
      QLabel *valueLabel = new QLabel( (this->*(displayValues[i].second))() );
      valueLabel->setOpenExternalLinks(true);
      valueLabel->setWordWrap(true);

      if (valueLabel->text() != "") {
        layout->addWidget(titleLabel, row, 0);
        layout->addWidget(valueLabel, row, 1);
      }
      else {
        delete titleLabel;
        delete valueLabel;
      }

      row++;
    }

    return widget;
  }


  QString FeatureNomenclature::Feature::id() const {
    return getTagText("id");
  }


  QString FeatureNomenclature::Feature::name() const {
    return getTagText("name");
  }


  QString FeatureNomenclature::Feature::cleanName() const {
    return getTagText("cleanName");
  }


  QString FeatureNomenclature::Feature::controlNet() const {
    QString targetStr = target();
    QString cnet = "";

    if (targetStr.toUpper() == "MOON")
      cnet = "LOLA";
    else if (targetStr.toUpper() == "MARS")
      cnet = "MDIM 2.1";
    else if (targetStr.toUpper() == "MERCURY")
      cnet = "Preliminary MESSENGER";

    return cnet;
  }


  QString FeatureNomenclature::Feature::displayName() const {
    QString nameString = name();
    QString cleanNameString = cleanName();

    QString displayNameString = nameString;

    if (nameString != cleanNameString)
      displayNameString = nameString + " (" + cleanNameString + ")";
    
    return displayNameString;
  }


  QString FeatureNomenclature::Feature::target() const {
    return getTagText("target");
  }


  QString FeatureNomenclature::Feature::system() const {
    return getTagText("system");
  }


  Distance FeatureNomenclature::Feature::diameter() const {
    Distance result;

    try {
      result = Distance(toDouble(getTagText("diameter")),
                        Distance::Kilometers);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::diameterString() const {
    return diameter().toString();
  }


  Latitude FeatureNomenclature::Feature::centerLatitude() const {
    Latitude result;

    try {
      result = Latitude(toDouble(getTagText("centerlatitude")), Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::centerLatitudeString() const {
    return centerLatitude().toString();
  }


  Longitude FeatureNomenclature::Feature::centerLongitude() const {
    Longitude result;

    try {
      result = Longitude(toDouble(getTagText("centerlongitude")),
                         Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::centerLongitudeString() const {
    return centerLongitude().toString();
  }


  Latitude FeatureNomenclature::Feature::northernLatitude() const {
    Latitude result;

    try {
      result = Latitude(toDouble(getTagText("northernLatitude")), Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::northernLatitudeString() const {
    return northernLatitude().toString();
  }


  Latitude FeatureNomenclature::Feature::southernLatitude() const {
    Latitude result;

    try {
      result = Latitude(toDouble(getTagText("southernLatitude")), Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::southernLatitudeString() const {
    return southernLatitude().toString();
  }


  Longitude FeatureNomenclature::Feature::easternLongitude() const {
    Longitude result;

    try {
      result = Longitude(toDouble(getTagText("easternLongitude")),
                         Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::easternLongitudeString() const {
    return easternLongitude().toString();
  }


  Longitude FeatureNomenclature::Feature::westernLongitude() const {
    Longitude result;

    try {
      result = Longitude(toDouble(getTagText("westernLongitude")),
                         Angle::Degrees);
    }
    catch (IException &) {
    }

    return result;
  }


  QString FeatureNomenclature::Feature::westernLongitudeString() const {
    return westernLongitude().toString();
  }


  QString FeatureNomenclature::Feature::originatingContinent() const {
    return getTagText("continent");
  }


  QString FeatureNomenclature::Feature::originatingEthnicity() const {
    return getTagText("ethnicity");
  }


  QString FeatureNomenclature::Feature::approvalStatus() const {
    return getTagText("approvalstatus");
  }


  QString FeatureNomenclature::Feature::approvalDate() const {
    return getTagText("approvaldate");
  }


  QString FeatureNomenclature::Feature::featureType() const {
    return getTagText("featuretype");
  }


  QString FeatureNomenclature::Feature::referenceString() const {
    return getTagText("reference");
  }


  QString FeatureNomenclature::Feature::origin() const {
    return getTagText("origin");
  }


  QString FeatureNomenclature::Feature::lastUpdated() const {
    return getTagText("lastUpdated");
  }


  QUrl FeatureNomenclature::Feature::referenceUrl() const {
    return QUrl("http://planetarynames.wr.usgs.gov/Feature/" + id());
  }


  QString FeatureNomenclature::Feature::referenceUrlString() const {
    return "<a href='" + referenceUrl().toString() + "'>" +
             referenceUrl().toString() +
           "</a>";
  }


  FeatureNomenclature::IAUStatus FeatureNomenclature::Feature::status() const {
    return m_approvalStatus;
  }

  
  void FeatureNomenclature::Feature::swap(Feature &other) {
    std::swap(m_xmlRepresenation, other.m_xmlRepresenation);
    std::swap(m_approvalStatus, other.m_approvalStatus);
    
  }


  FeatureNomenclature::Feature &FeatureNomenclature::Feature::operator=(
      const Feature &rhs) {
    Feature copy(rhs);
    swap(copy);
    return *this;
  }


  QString FeatureNomenclature::Feature::getTagText(QString tagName) const {
    QString text;

    if (m_xmlRepresenation) {
      QDomNodeList nodes =
          m_xmlRepresenation->elementsByTagName(tagName);

      if (nodes.count())
        text = nodes.at(0).toElement().text().trimmed();
    }
    
    return text;
  }


  void FeatureNomenclature::requestFinished(QNetworkReply *reply) {
    if (reply->error() == QNetworkReply::NoError) {

      QString errorMsg;
      int errorLine;
      int errorCol;

      QDomDocument xmlResultDocument;
      if (xmlResultDocument.setContent(reply->readAll(),
                                       &errorMsg, &errorLine, &errorCol)) {
        for (QDomNode node = xmlResultDocument.firstChild();
             !node.isNull();
             node = node.nextSibling()) {
          QDomElement element = node.toElement();
          if (element.tagName() == "searchresults") {
            readSearchResults(element);
          }
        }
      }
      else {
      QMessageBox::warning(NULL, "Failed to read nomenclature database result",
                           "An error occurred when parsing the data sent back "
                           "from the nomenclature database. "
                           "The XML result was invalid. The parse is [" +
                           errorMsg + "] on line [" +
                           QString(errorLine) +"], column [" +
                           QString(errorCol) + "]");
      }
    }
    else {
      QMessageBox::warning(NULL, "Failed to query nomenclature database",
                           "An error occurred when querying the nomenclature "
                           "database for features that intersect the qeuried "
                           "ground range. Please make sure you have an active "
                           "internet connection. The error returned was [" +
                           reply->errorString() + "]");
    }

    reply->deleteLater();

    if (m_lastQuery) {
      emit featuresIdentified(this);
    }
    m_lastQuery = true;
  }


  void FeatureNomenclature::readSearchResults(QDomElement xmlSearchResults) {
    ASSERT(xmlSearchResults.tagName() == "searchresults");
    
    if (!m_features)
      m_features = new QList<Feature>;

    for (QDomNode node = xmlSearchResults.firstChild();
         !node.isNull();
         node = node.nextSibling()) {
      QDomElement element = node.toElement();
      QString approvalID = element.childNodes().item(15).toElement().attribute("id");

      if (element.tagName() == "feature") {
        
        if(approvalID == "5") {
           m_statusApproval = Approved;
        }
        else if(approvalID == "6") {
          m_statusApproval = Dropped;
        }
        else if(approvalID == "7") {
          m_statusApproval = Unapproved;
        }
        else {
          m_statusApproval = NoStatus;
        }

        m_features->append(Feature(element, m_statusApproval));
      }
    }
  }

  
  void FeatureNomenclature::runQuery(QString target,
                                     Latitude startLat, Longitude startLon,
                                     Latitude endLat, Longitude endLon) {

    QUrl encodedFormData;

    // List of XML fields we want from the server
    encodedFormData.addQueryItem("additionalInfoColumn", "true");
    encodedFormData.addQueryItem("approvalDateColumn", "true");
    encodedFormData.addQueryItem("approvalStatusColumn", "true");
    encodedFormData.addQueryItem("centerLatLonColumn", "true");
    encodedFormData.addQueryItem("cleanFeatureNameColumn", "true");
    encodedFormData.addQueryItem("contEthColumn", "true");
    encodedFormData.addQueryItem("coordSystemColumn", "true");
    encodedFormData.addQueryItem("diameterColumn", "true");
    encodedFormData.addQueryItem("featureIDColumn", "true");
    encodedFormData.addQueryItem("featureNameColumn", "true");
    encodedFormData.addQueryItem("featureTypeCodeColumn", "true");
    encodedFormData.addQueryItem("featureTypeColumn", "true");
    encodedFormData.addQueryItem("lastUpdatedColumn", "true");
    encodedFormData.addQueryItem("latLonColumn", "true");
    encodedFormData.addQueryItem("originColumn", "true");
    encodedFormData.addQueryItem("quadColumn", "true");
    encodedFormData.addQueryItem("referenceColumn", "true");
    encodedFormData.addQueryItem("targetColumn", "true");

    // Data units
    encodedFormData.addQueryItem("is_0_360", "true");
    encodedFormData.addQueryItem("is_planetographic", "false");
    encodedFormData.addQueryItem("is_positive_east", "true");

    // Format parameters
    encodedFormData.addQueryItem("displayType", "XML");
    encodedFormData.addQueryItem("sort_asc", "true");
    encodedFormData.addQueryItem("sort_column", "name");

    // Search critera (required even if blank)
    encodedFormData.addQueryItem("approvalStatus", "");
    encodedFormData.addQueryItem("beginDate", "");
    encodedFormData.addQueryItem("continent", "");
    encodedFormData.addQueryItem("endDate", "");
    encodedFormData.addQueryItem("ethnicity", "");
    encodedFormData.addQueryItem("feature", "");
    encodedFormData.addQueryItem("featureType", "");
    encodedFormData.addQueryItem("minFeatureDiameter", "");
    encodedFormData.addQueryItem("maxFeatureDiameter", "");
    encodedFormData.addQueryItem("reference", "");
    encodedFormData.addQueryItem("system", "");

    encodedFormData.addQueryItem("target", target.toUpper());
    encodedFormData.addQueryItem("easternLongitude",
                                QString::number(endLon.degrees()));
    encodedFormData.addQueryItem("westernLongitude",
                                QString::number(startLon.degrees()));
    encodedFormData.addQueryItem("northernLatitude",
                                 QString::number(endLat.degrees()));
    encodedFormData.addQueryItem("southernLatitude",
                                 QString::number(startLat.degrees()));

    m_networkMgr->post(*m_request, QByteArray(encodedFormData.encodedQuery()));
  }
}