//-----------------------------------------------------------------------------
// $Id: Sim/OrnamentMgr.cpp 2013/10/26 23:10:54 philw $
// Workspace Text/Image Ornament Manager -- created for RiverWare 6.5 [10-2013]
//
//  class OrnamentMgr : Root
//----------------------------------------------------------------------------

#include "OrnamentMgr.hpp"  // this module
#include <iostream>

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

// *********************
// ***  Static Data  ***
// *********************

OrnamentMgr* OrnamentMgr::_instance (NULL);

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

// static 
void OrnamentMgr::chkInstance()
{
   if (_instance == NULL)
   {
      _instance = new OrnamentMgr;
   }
}

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

// constructor 1 of 1
OrnamentMgr::OrnamentMgr()
  : Root(),
    _ornamentList(),
    _userImageMap()
{
}
   
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

OrnamentMgr::~OrnamentMgr()
{
   clearOrnaments();
   clearUserImages();
}

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

void OrnamentMgr::addOrnament (Ornament* orn)
{
   _ornamentList.append (orn);
}

void OrnamentMgr::removeOrnament (Ornament* remOrn, bool deleteToo /*=false*/)
{
   if (_ornamentList.contains (remOrn))
   {
      _ornamentList.removeAll (remOrn);

      if (deleteToo)
      {
         // Note: The Ornament destructor issues an ORNAMENT_DELETED callback.
         delete remOrn;
      }
   }
}

bool OrnamentMgr::containsOrnament (const Ornament* orn) const
{
   const bool yesContains = 
     _ornamentList.contains (const_cast<Ornament*> (orn));

   return (yesContains);
}

void OrnamentMgr::clearOrnaments()
{
   const int ornCnt = _ornamentList.count();
   for (int inx = 0; inx < ornCnt; ++inx)
   {
      Ornament* delOrn = _ornamentList [inx];
      
      // Note: The Ornament destructor issues an ORNAMENT_DELETED callback.
      delete delOrn;
   }

   _ornamentList.clear();
}

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

// returns new imageId
int OrnamentMgr::addUserImage (UserImageData imageData)
{
   // Find an unused image Id 
   int imageId (1000);  // lowest user image Id
   while (_userImageMap.contains (imageId))
   {
      ++imageId;
   }

   // Store given QPixmap
   _userImageMap [imageId] = imageData;
   return (imageId);
}

UserImageData OrnamentMgr::userImageData (int imageId) const
{
   if (_userImageMap.contains (imageId))
   {
      return (_userImageMap [imageId]);
   }

   static const UserImageData NullData;
   return (NullData); // imageId not found. 
}

UserImageData OrnamentMgr::userImageData (const Ornament* orn) const
{
   if (orn && orn->hasUserImage())
   { 
      const int imageId = orn->imageId();
      if (_userImageMap.contains (imageId))
      {
         return (_userImageMap [imageId]);
      }
   }

   static const UserImageData NullData;
   return (NullData); // Ornament doesn't have user image OR imageId not found. 
}

QList<int> OrnamentMgr::userImageIds() const
{
   // Compute used User Image imageIds.
   QList<int> idList;

   const int ornCnt = _ornamentList.count();
   for (int ornInx = 0; ornInx < ornCnt; ++ornInx)
   {
      const Ornament* orn = _ornamentList [ornInx];
      if (orn && orn->hasUserImage())
      {
         const int imageId = orn->imageId();
         if (!idList.contains (imageId))
         {
            idList.append (imageId);
         }
      }
   }

   return (idList);
}

void OrnamentMgr::clearUserImages()
{
   // Note: contained QByteArrays and QPixmaps are automatically deleted.
   _userImageMap.clear();
}

void OrnamentMgr::clearUnusedUserImages()
{
   static const char* mname ("OrnamentMgr::clearUnusedUserImages");

   const int origUserImageCnt = _userImageMap.count();
   origUserImageCnt; // (avoid compilation warning)

   QMap<int,UserImageData> cleanUserImageMap;

   const QList<int> userIds = userImageIds();
   const int userIdCnt = userIds.count();

   for (int inx = 0; inx < userIdCnt; ++inx)
   {
      const int imageId = userIds [inx];
      cleanUserImageMap [imageId] = _userImageMap.value (imageId);
   }

   // Replace User Image Map with "Clean" User Image Map.
   _userImageMap.clear();
   _userImageMap = cleanUserImageMap;

   const int newUserImageCnt = _userImageMap.count();
   newUserImageCnt; // (avoid compilation warning)
   
   // std::cout << mname 
   //           << ": oldCnt " << origUserImageCnt
   //           << ", newCnt " << newUserImageCnt
   //           << std::endl;
}

// private:
void OrnamentMgr::handleAndForwardCallback (CallbackType cbType, Ornament* orn)
{
   callCallbacks (cbType, (CallbackData*) orn);

   if (cbType == ORNAMENT_DELETED)
   {
      removeOrnament (orn, false); // don't deleteToo
   }
}

//--- (end OrnamentMgr.cpp) ---