//-----------------------------------------------------------------------------
// $Id: Sim/UserImageData.cpp 2013/10/26 23:10:54 philw $
// Raw image binary data QByteArray with constructed QPixmap
// ... used by Workspace Text/Image Ornaments (RiverWare 6.5, 10-2013).
//
//  class UserImageData
//----------------------------------------------------------------------------

#include "UserImageData.hpp"  // this module

#include "RwFileDialog.hpp"
#include "cwFormat.hpp"
#include "libSimMsgs.hpp"

#include <QDomNode>
#include <QDomNodeList>
#include <QDomElement>
#include <QFile>
#include <QFileInfo>
#include <iostream>

UserImageData::UserImageData (const QByteArray& bytes,
                              const QString& origPath) // just FYI
{
   _bytes = bytes;
   _origPath = origPath;

   const bool loadOk = _pmap.loadFromData (_bytes);   
   if (loadOk && !_pmap.isNull())
   {
      _okStat = okstat (true);
   }
   else
   {
      _okStat = okstat (loadOk ? "Null Pixmap" : "Data Error");
   }
}

QString UserImageData::origFile() const
{
   QString fileName;

   if (!_origPath.isEmpty())
   {
      const QFileInfo origFileInfo (_origPath);
      fileName =  origFileInfo.fileName();
   }

   return (fileName);
}

// compare status and image data
bool UserImageData::dataEqual (const UserImageData& rhs) const
{
   if (bool (_okStat) != bool (rhs._okStat)) return (false);
   if (_pmap.isNull() != rhs._pmap.isNull()) return (false);
   if (_bytes.count() != rhs._bytes.count()) return (false);

   if (!_pmap.isNull())
   {
      if (_pmap.size() != rhs._pmap.size()) return (false);
   }

   // A little expensive esp. when these things ARE equal. These are large.
   if (_bytes != rhs._bytes) return (false);

   return (true); // status and image data are equal.
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
   
// ***************************************************
// ***  UserImageData / XML Serialization: Output  ***
// ***************************************************

static const QString XML_ELEM_USER_IMAGE_DATA ("UserImageData");
static const QString XML_ELEM_ORIG_PATH       ("OrigPath");
static const QString XML_ELEM_BASE64_DATA     ("Base64Data");

static const QString XML_ATTRIB_WIDTH  ("width");
static const QString XML_ATTRIB_HEIGHT ("height");
static const QString XML_ATTRIB_SIZE   ("byteCount");

QDomElement UserImageData::asXmlDomElement (QDomDocument& doc) const
{
   const int imgWid = _pmap.isNull() ? 0 : _pmap.width();
   const int imgHgt = _pmap.isNull() ? 0 : _pmap.height();
   const int imgSiz = _bytes.count();
   
   QDomElement elem = doc.createElement (XML_ELEM_USER_IMAGE_DATA);
   elem.setAttribute (XML_ATTRIB_WIDTH,  QString::number (imgWid));
   elem.setAttribute (XML_ATTRIB_HEIGHT, QString::number (imgHgt));
   elem.setAttribute (XML_ATTRIB_SIZE,   QString::number (imgSiz));

   QDomElement pathElem = doc.createElement (XML_ELEM_ORIG_PATH);
   QDomCDATASection dispData = doc.createCDATASection (_origPath);
   pathElem.appendChild (dispData);

   QDomElement dataElem = doc.createElement (XML_ELEM_BASE64_DATA);
   QDomCDATASection toolData = doc.createCDATASection (_bytes.toBase64());
   dataElem.appendChild (toolData);

   elem.appendChild (pathElem);
   elem.appendChild (dataElem);

   return elem;
}

QString UserImageData::toXml() const
{
   QDomDocument imageDataDoc;

   const QDomElement docElem = asXmlDomElement (imageDataDoc);
   imageDataDoc.appendChild (docElem);

   const QString docStr = imageDataDoc.toString();
   return (docStr.trimmed());
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// **************************************************
// ***  UserImageData / XML Serialization: Input  ***
// **************************************************

okstat UserImageData::loadFromDomElement (const QDomElement& imageDataElem, 
                                          const QString& srcDesc)
{
   srcDesc; // (avoid compilation warning)

   // ***********************************
   // ***  UserImageData: Attributes  ***
   // ***********************************

   // All attributes are currently for dependent data.

   //-- const QDomNamedNodeMap ornamentAttbs = imageDataElem.attributes();
   //-- const int attbCnt = ornamentAttbs.count();
   //-- for (int attbInx = 0;  attbInx < attbCnt;  ++attbInx)
   //-- {
   //--    const QDomAttr attb = ornamentAttbs .item (attbInx) .toAttr();
   //--    if (!attb.isNull())
   //--    {
   //--       const QString attbName = attb.name();
   //--       const QString attbStrVal = attb.value();
   //--    }
   //-- }

   // ***************************************
   // ***  UserImageData: Child Elements  ***
   // ***************************************

   QString origPath;
   QByteArray byteData;

   const QDomNodeList ornamentChildNodes = imageDataElem.childNodes();
   const int chCnt = ornamentChildNodes.count();
   for (int chInx = 0; chInx < chCnt; ++chInx)
   {
      const QDomElement chElem = ornamentChildNodes.at (chInx).toElement();
      const QString chTag = chElem.tagName();

      if (chTag == XML_ELEM_ORIG_PATH)
      {
         origPath = chElem.text();
      }

      else if (chTag == XML_ELEM_BASE64_DATA)
      {
         const QByteArray chElemBytes = chElem.text().toLatin1();
         byteData = QByteArray::fromBase64 (chElemBytes);
      }
   }

   if (byteData.isEmpty())
   {
      *this = UserImageData(); // empty
      return okstat ("No image data found");
   }

   *this = UserImageData (byteData, origPath);
   return okstat (_okStat);
}

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

okstat UserImageData::loadFromXml (const QString& xmlStr,
                                   const QString& srcDesc)
{
   okstat loadOk (true);

   // ************************************************
   // ***  Read XML Document from Provided String  ***
   // ************************************************

   QDomDocument imageDataDoc;
   QString errMsg ("");
   int errLine (-1);
   int errCol (-1);

   const bool setContentOk =
      imageDataDoc.setContent (xmlStr, &errMsg, &errLine, &errCol);

   if (!setContentOk)
   {
      QString msg ("");

      cwFormatMsg (msg, MSG_XML_LN_PARSE_ERR, "UserImageData Data",
         qPrintable (srcDesc), errLine, errCol, qPrintable (errMsg));

      loadOk = okstat (msg);
   }

   else // (setContentOk)
   {
      // ***********************************************************
      // ***  Load this UserImageData from the XML DOM Document  ***
      // ***********************************************************

      loadOk = loadFromDomElement (imageDataDoc.documentElement(), srcDesc);
   }

   return (loadOk);
}
    
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

void UserImageData::exportToFile()
{
   static const char* mname ("UserImageData::exportToFile");

   const QString filePath = 
      RwFileDialog::getSaveFileName (RwFile::For_Output, NULL,
                                     "Export User Image Data (XML)");

   if (filePath.isEmpty()) return;
   //--------------------------->>

   QFile outFile (filePath);
   outFile.open (QIODevice::WriteOnly | QIODevice::Text);
   const QString xmlStr = toXml();
   outFile.write (xmlStr.toLatin1());
   outFile.close();
}

okstat UserImageData::importFromFile()
{
   static const char* mname ("UserImageData::importFromFile");

   const QString filePath =
      RwFileDialog::getOpenFileName (RwFile::For_Output, NULL,
                                     "Import User Image Data (XML)");

   if (filePath.isEmpty()) return okstat (true);
   //----------------------------------------->>

   QFile inFile (filePath);
   inFile.open (QIODevice::ReadOnly | QIODevice::Text);
   const QByteArray inBytes = inFile.readAll();
   inFile.close();
   
   const QString inStr (inBytes);
   UserImageData inImgDat;
   okstat loadOk = inImgDat.loadFromXml (inStr, mname);
   return (loadOk);
}

//--- (end UserImageData.cpp) ---