#include <creaMessageManager.h>
#include <creaImageIODicomNode.h>

#include <creaImageIODicomDatabase.h>
//#include <creaImageIOException.h>

#include <algorithm>

namespace creaImageIO
{
  //=============================================================
  const int DicomNode::Database = 0;
  const int DicomNode::Patient = 1;
  const int DicomNode::Study   = 2;
  const int DicomNode::Series  = 3;
  const int DicomNode::Image   = 4;
  //=============================================================

  const std::string DicomNodeTypeName[5] =
    { "Database",
      "Patient",
      "Study",
      "Series",
      "Image"
    };
  const std::string DicomNodePluralTypeName[5] =
    { "Databases",
      "Patients",
      "Studies",
      "Series",
      "Images"
    };

  //=============================================================
  DicomNode::DicomNode(Type type, DicomDatabase* root, DicomNode* parent)
    : mType(type),
      mDicomDatabase(root),
      mParent(parent),
      mData(0),
      mChildrenLoaded(false),
      mNumberOfChildren(-1)
  {
    if (parent) 
      {
	parent->GetChildrenList().push_back(this);
      }
    if (root) 
      {
	DicomNodeTypeDescription::FieldDescriptionMapType::const_iterator i;
	for (i  = GetTypeDescription().GetFieldDescriptionMap().begin();
	     i != GetTypeDescription().GetFieldDescriptionMap().end();
	     i++)
	  {
	    mFieldValueMap[i->first] = "----";
	  }
      }
  }
  //=============================================================

  //=============================================================
  DicomNode::~DicomNode()
  {
    ChildrenListType::iterator i;
    for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
      {
	delete *i;
      }
    if (mData) 
      {
	delete mData;
	mData = 0;
      }
  }
  //=============================================================

  //=============================================================
  const std::string& DicomNode::GetTypeName(const Type& t)
  {
    return DicomNodeTypeName[t];
  }
  //=============================================================
  //=============================================================
  const std::string& DicomNode::GetPluralTypeName(const Type& t)
  {
    return DicomNodePluralTypeName[t];
  }
  //=============================================================

  //=============================================================
  const std::string& DicomNode::GetTypeName() const
  {
    return DicomNodeTypeName[GetType()];
  }
  //=============================================================

  //=============================================================
  void DicomNode::RemoveChildrenFromList(DicomNode* node)
  {
    ChildrenListType::iterator i = find(GetChildrenList().begin(),
					GetChildrenList().end(),
					node);
    if (i != GetChildrenList().end())
      {
	GetChildrenList().erase(i);
      }
  }
  //=============================================================

  //=============================================================
  const DicomNodeTypeDescription& DicomNode::GetTypeDescription() const
  {
    return mDicomDatabase->GetDicomNodeTypeDescription(mType);
  }
  //=============================================================


  //  Tree* DicomNode::GetTree() const { return mDicomDatabase->GetTree(); }
  

  //=============================================================
  const Field::Value& DicomNode::GetFieldValue(const Field::Key& k) const
  {
    //    std::cout << "this = "<<(void*)this<<std::endl;
    //    std::cout << "mFieldValueMap="<<(void*)(&mFieldValueMap)<<std::endl;
    FieldValueMapType::const_iterator i = mFieldValueMap.find(k);
    if (i==mFieldValueMap.end())
      {
	static Field::Value def("");
	return def;
	//	CREAIMAGEIO_ERROR("DicomNode::GetFieldValue : no field with key '"<<k<<"'");
      }
    return i->second;
  }
  //=============================================================

  //=============================================================
  const Field::Value& DicomNode::GetCleanFieldValue(const Field::Key& k) const
  {
    static std::string Clean("-");
    FieldValueMapType::const_iterator i = mFieldValueMap.find(k);
    if (i==mFieldValueMap.end())
      {
	creaError("DicomNode::GetFieldValue : no field with key '"<<k<<"'");
      }
    if (i->second == "GDCM::Unfound")
      {
	return Clean;
      }
    return i->second;
  }
  //=============================================================


  //=============================================================
  void DicomNode::SetFieldValue(const Field::Key& k, const Field::Value& v)
  {
    FieldValueMapType::iterator i = mFieldValueMap.find(k);
    if (i==mFieldValueMap.end())
      {
	std::cout << "DicomNode::SetFieldValue : no field with key '"<<k
		  <<"'"<<std::endl;
	creaError("DicomNode::SetFieldValue : no field with key '"<<k<<"'");
      }
    i->second = v;
  }
  //=============================================================

  //=============================================================
  void DicomNode::Print() const 
  {
    for (int i=0;i<GetType()+1;++i) std::cout << " ";
    std::cout << "-> "<<GetLabel() << std::endl;
    ChildrenListType::const_iterator i;
    for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
      {
	(*i)->Print();
      }
 
  }
  //=============================================================

  //=============================================================
  std::string DicomNode::GetLabel() const 
  {
    std::string l;
    switch (GetType())
      {
      case Database :
	l += GetFieldValue("Name");
	break;
	//	  + " (" + GetFieldValue("Location") + ")";
     case Patient :
	l += GetCleanFieldValue("A0010_0010")  // Name 
	  + " | " + GetCleanFieldValue("A0010_0040") + " | "  // Sex
	  + GetCleanFieldValue("A0010_0030"); // Birthday
	break;
     case Study :
       l += GetCleanFieldValue("A0008_0020")  // Study Date
	 + " | " +  GetCleanFieldValue("A0008_1030"); // Study Description
       break;
      case Series :
	l += GetCleanFieldValue("A0008_0060")  // Modality
	  + " | " +  GetCleanFieldValue("A0008_103E");  // Description
	break;
      case Image :
	l += GetCleanFieldValue("A0004_1500"); // File Name
	break;
      }
    return l;
  }
  //=============================================================

  //=============================================================
  int DicomNode::GetNumberOfChildren()
  {
    //    std::cout << "$$$ DicomNode::GetNumberOfChildren"<<std::endl;
    if ( GetType() == DicomNode::Image ) return 0;
    if ( GetChildrenList().size() > 0 ) return GetChildrenList().size();
    if ( mNumberOfChildren == -1 ) 
      {
	mNumberOfChildren = 0;
	if (GetDicomDatabase()!=0)
	  {
	    mNumberOfChildren = 
	      GetDicomDatabase()->DBQueryNumberOfChildren(this);
	  }
      }
    return mNumberOfChildren;
  }
  //=============================================================

  /*
  const Field::Description& DicomNode::GetFieldDescription(const Field::Key& k) 
    const
  {
    
    return GetTypeDescription().GetFieldDescription(k);
    
  }
  */



 //=====================================================================
  void DicomNode::SortChildren(const LexicographicalDicomNodeComparator& c)
  {
    // Check 
    /*
    ChildrenListType::const_iterator i;
    for (i=GetChildrenList().begin(); i!=GetChildrenList().end(); i++)
      {
	std::cout << (*i)->GetLabel()<<std::endl;
	if ((*i)==0) 
	  {
	    std::cout << "!!! SortChildren : child = "<<*i<<std::endl;
	    exit(0);
	  }
      }
    std::cout<<"=========================="<<std::endl;
    */
    std::sort(GetChildrenList().begin(),
	      GetChildrenList().end(),
	      c);
  }
 //=====================================================================





} // namespace creaImageIO