#include <iostream>

 #include <QStringList>

 #include "attributeitem.h"

 #include "branchobj.h"

 #include "branchitem.h"

 #include "treeitem.h"

 #include "vymmodel.h"

 #include "xlinkitem.h"

 #include "xlinkobj.h"

 using namespace std;

 extern FlagRow* standardFlagsMaster;

 TreeItem::TreeItem()

 {

 	cout << "Constr. TI  this="<<this<<endl;

 	init();

 	itemData.clear();

 	rootItem=this;

 	parentItem=NULL;

 }

 TreeItem::TreeItem(const QList<QVariant> &data, TreeItem *parent)

 {

 	//cout << "Constructor TreeItem this="<<this<<"  parent="<<parent<<endl;

 	init();

     parentItem = parent;

     itemData = data;

 	rootItem=this;

 	if (parentItem )

 		rootItem=parentItem->rootItem;

 }

 TreeItem::~TreeItem()

 {

 	//cout << "Destructor TreeItem "<<getHeadingStd()<<endl;

 	TreeItem *ti;

 	while (!childItems.isEmpty())

 	{

 		ti=childItems.takeFirst();

 		delete ti;

 	}	

 }

 void TreeItem::init()

 {

 	model=NULL;

 	branchOffset=0;

 	branchCounter=0;

 	imageOffset=0;

 	imageCounter=0;

 	attributeCounter=0;

 	attributeOffset=0;

 	xlinkCounter=0;

 	xlinkOffset=0;

 	note.setNote(""); 

 	// note.setFontHint (textEditor->getFontHintDefault() );	//FIXME-3

 	// isNoteInEditor=false;

 	hidden=false;

 	hideExport=false;

 	// Reset ID

 	objID="";

 	standardFlags.setMasterRow (standardFlagsMaster);

 }

 void TreeItem::setModel (VymModel *m)

 {

 	model=m;

 }

 VymModel* TreeItem::getModel ()

 {

 	return model;

 }

 int TreeItem::getRowNumAppend (TreeItem *item)

 {	

 	switch (item->type)

 	{

 		case Attribute: return attributeOffset + attributeCounter;

 		case XLink: return xlinkOffset + xlinkCounter;

 		case Image: return imageOffset + imageCounter;

 		case MapCenter: return branchOffset + branchCounter;

 		case Branch: return branchOffset + branchCounter;

 		default: return -1;

 	}

 }

 void TreeItem::appendChild(TreeItem *item)

 {

 	item->parentItem=this;

 	item->rootItem=rootItem;

 	item->setModel (model);

 	if (item->type == Attribute)

 	{

 		// attribute are on top of list

 		childItems.insert (attributeCounter,item);

 		attributeCounter++;

 		xlinkOffset++;

 		imageOffset++;

 		branchOffset++;

 	}

 	if (item->type == XLink)

 	{

 		childItems.insert (xlinkCounter+xlinkOffset,item);

 		xlinkCounter++;

 		imageOffset++;

 		branchOffset++;

 	}

 	if (item->type == Image)

 	{

 		childItems.insert (imageCounter+imageOffset,item);

 		imageCounter++;

 		branchOffset++;

 	}

 	if (item->isBranchLikeType())

 	{

 		// branches are on bottom of list

 		childItems.append(item);

 		branchCounter++;

 		// Set correct type		//FIXME-3 DUP in constr branchitem

 		if (this==rootItem)

 			item->setType(MapCenter);

 		else

 			item->setType (Branch);

 	}

 }

 void TreeItem::removeChild(int row)

 {

     if (row<0 || row > childItems.size()-1)

 		qWarning ("TreeItem::removeChild tried to remove non existing item?!\n");

 	else

 	{

 		if (childItems.at(row)->type==Attribute)

 		{

 			attributeCounter--;

 			xlinkOffset--;

 			imageOffset--;

 			branchOffset--;

 		}	

 		if (childItems.at(row)->type==XLink)

 		{

 			xlinkCounter--;

 			imageOffset--;

 			branchOffset--;

 		}	

 		if (childItems.at(row)->type==Image)

 		{

 			imageCounter--;

 			branchOffset--;

 		}	

 		if (childItems.at(row)->isBranchLikeType())

 			branchCounter--;

 		childItems.removeAt (row);

 	}

 }

 /*

 void TreeItem::clear()	// FIXME-2 used in vymmodel addMapInsert, but needs to be used via model and emit layout changes...

 {

 	cout << "TI::clear\n";

 	while ( childItems.size()>0)

 	{

 		branchCounter--;

 		childItems.removeAt (0);

 	}

 }

 */

 TreeItem *TreeItem::child(int row)

 {

     return childItems.value(row);

 }

 int TreeItem::childCount() const

 {

     return childItems.count();

 }

 int TreeItem::childNumber() const

 {

     if (parentItem)

         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

     return 0;

 }

 int TreeItem::columnCount() const

 {

 	return 1;

 }

 int TreeItem::branchCount() const

 {

     return branchCounter;

 }

 int TreeItem::imageCount() const

 {

     return imageCounter; 

 }

 int TreeItem::xlinkCount() const

 {

     return xlinkCounter; 

 }

 int TreeItem::attributeCount() const 

 {

     return attributeCounter; 

 }

 int TreeItem::row() const

 {

     if (parentItem)

         return parentItem->childItems.indexOf(const_cast<TreeItem*>(this));

 	cout << "TI::row() pI=NULL this="<<this<<"  ***************\n";

     return 0;

 }

 int TreeItem::depth() 

 {

 	// Rootitem d=-1

 	// MapCenter d=0

 	int d=-2;

 	TreeItem *ti=this;

 	while (ti!=NULL)

 	{

 		ti=ti->parent();

 		d++;

 	}

 	return d;

 }

 TreeItem *TreeItem::parent()

 {

 	//cout << "TI::parent of "<<getHeadingStd()<<"  is "<<parentItem<<endl;

     return parentItem;

 }

 int TreeItem::childNum()

 {

 	return parentItem->childItems.indexOf (this);

 }

 int TreeItem::num()

 {

 	if (!parentItem) return -1;

 	return parentItem->num (this);

 }

 int TreeItem::num (TreeItem *item)

 {

 	if (!item) return -1;

 	if (!childItems.contains(item)) return -1;

 	switch (item->getType())

 	{

 		case MapCenter: return childItems.indexOf (item) - branchOffset;

 		case Branch: return childItems.indexOf (item) - branchOffset;

 		case Image: return parentItem->childItems.indexOf (item) - imageOffset;

 		case Attribute: return parentItem->childItems.indexOf (item) - attributeOffset;

 		case XLink: return parentItem->childItems.indexOf (item) - xlinkOffset;

 		default: return -1;

 	}

 }

 void TreeItem::setType(const Type t)

 {

 	type=t;

 	itemData[1]=getTypeName();

 }

 TreeItem::Type TreeItem::getType()

 {

 	if (type==Branch && depth()==0) return MapCenter;	//FIXME-3 should not be necesssary

 	return type;

 }

 bool TreeItem::isBranchLikeType() const

 {

 	if (type==Branch ||type==MapCenter) return true;

 	return false;

 }

 QString TreeItem::getTypeName()

 {

 	switch (type)

 	{

 		case Undefined: return QString ("Undefined");

 		case MapCenter: return QString ("MapCenter");

 		case Branch: return QString ("Branch");

 		case Image: return QString ("Image");

 		case Attribute: return QString ("Attribute");

 		case XLink: return QString ("XLink");

 		default: return QString ("TreeItem::getTypeName no typename defined?!");

 	}

 }

 QVariant TreeItem::data(int column) const

 {

     return itemData.value(column);

 }

 void TreeItem::setHeading (const QString s)

 {

 	itemData[0]=s;

 }

 QString TreeItem::getHeading () const

 {

 	return itemData[0].toString();

 }

 std::string TreeItem::getHeadingStd () const

 {

 	return itemData[0].toString().toStdString();

 }

 void TreeItem::setHeadingColor (QColor color)

 {

 	headingColor=color;

 }

 QColor TreeItem::getHeadingColor ()

 {

 	return headingColor;

 }

 void TreeItem::setURL (const QString &u)

 {

 	url=u;

 	if (!url.isEmpty())

 		systemFlags.activate ("system-url");

 	else

 		systemFlags.deactivate ("system-url");

 }

 QString TreeItem::getURL ()

 {

 	return url;

 }

 void TreeItem::setVymLink (const QString &vl)

 {

 	if (!vl.isEmpty())

 	{

 		// We need the relative (from loading) 

 		// or absolute path (from User event)

 		// and build the absolute path.

 		// Note: If we have relative, use path of

 		// current map to build absolute path

 		QDir d(vl);

 		if (!d.path().startsWith ("/"))

 		{

 			QString p=model->getDestPath();

 			int i=p.findRev("/",-1);

 			d.setPath(p.left(i)+"/"+vl);

 			d.convertToAbs();

 		}

 		vymLink=d.path();

 		systemFlags.activate("system-vymLink");

 	}	

 	else	

 	{

 		systemFlags.deactivate("system-vymLink");

 		vymLink.clear();

 	}	

 }

 QString TreeItem::getVymLink ()

 {

 	return vymLink;

 }

 void TreeItem::setNote(const QString &s)

 {

 	NoteObj n;

 	n.setNote(s);

 	setNoteObj (n);

 }

 void TreeItem::clearNote()

 {

 	note.clear();

 	systemFlags.deactivate ("system-note");

 }

 void TreeItem::setNoteObj(const NoteObj &n){

 	note=n;

 	if (!note.isEmpty() && !systemFlags.isActive ("system-note"))

 		systemFlags.activate ("system-note");

 	if (note.isEmpty() && systemFlags.isActive ("system-note"))

 		systemFlags.deactivate ("system-note");

 }

 QString TreeItem::getNote()

 {

 	return note.getNote();

 }

 bool TreeItem::hasEmptyNote()

 {

 	return note.isEmpty();

 }

 NoteObj TreeItem::getNoteObj()

 {

 	return note;

 }

 QString TreeItem::getNoteASCII(const QString &indent, const int &width)

 {

     return note.getNoteASCII(indent,width);

 }

 QString TreeItem::getNoteASCII()

 {

     return note.getNoteASCII();

 }

 QString TreeItem::getNoteOpenDoc()

 {

     return note.getNoteOpenDoc();

 }

 void TreeItem::activateStandardFlag (const QString &name)

 {

 	standardFlags.activate (name);

 	model->emitDataHasChanged(this);

 }

 void TreeItem::deactivateStandardFlag (const QString &name)

 {

 	standardFlags.deactivate (name);

 	model->emitDataHasChanged(this);

 }

 void TreeItem::deactivateAllStandardFlags ()

 {

 	standardFlags.deactivateAll ();

 	model->emitDataHasChanged(this);

 }

 void TreeItem::toggleStandardFlag(const QString &name, FlagRow *master)

 {

 	standardFlags.toggle (name,master);

 	model->emitDataHasChanged(this);

 }

 bool TreeItem::isActiveStandardFlag (const QString &name)

 {

 	return standardFlags.isActive (name);

 }

 QStringList TreeItem::activeStandardFlagNames ()

 {

 	return standardFlags.activeFlagNames();

 }

 FlagRow* TreeItem::getStandardFlagRow()

 {

 	return &standardFlags;

 }

 QStringList TreeItem::activeSystemFlagNames ()

 {

 	return systemFlags.activeFlagNames();

 }

 bool TreeItem::canMoveDown()

 {

 	switch (type)

 	{

 		case Undefined: return false;

 		case MapCenter: 

 		case Branch: 

 			if (!parentItem) return false;

 			if (parentItem->num (this) < parentItem->branchCount()-1)

 				return true;

 			else

 				return false;

 			break;	

 		case Image: return false;

 		default: return false;

 	}

 }

 bool TreeItem::canMoveUp()

 {

 	switch (type)

 	{

 		case MapCenter: 

 		case Branch: 

 			if (!parentItem) return false;

 			if (parentItem->num (this) > 0)

 				return true;

 			else

 				return false;

 			break;	

 		default: return false;

 	}

 }

 void TreeItem::setID (const QString &s)

 {

 	objID=s;

 }

 QString TreeItem::getID()

 {

 	return objID;

 }

 TreeItem* TreeItem::getChildNum(const int &n)

 {

 	if (n>=0 && n<childItems.count() )

 		return childItems.at(n);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getFirstBranch()

 {

 	if (branchCounter>0)

 		return getBranchNum (branchOffset);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getLastBranch()

 {

 	if (branchCounter>0)

 		return getBranchNum (branchOffset + branchCounter-1);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getNextBranch(BranchItem *currentBranch)

 {

 	if (!currentBranch) return NULL;

 	int n=num (currentBranch)+1;

 	if (n<branchCounter)

 		return getBranchNum (branchOffset + n);

 	else

 		return NULL;

 }

 BranchItem* TreeItem::getBranchNum(const int &n)

 {

 	if (n>=0 && n<branchCounter)

 		return (BranchItem*)getChildNum (branchOffset + n);

 	else

 		return NULL;

 }

 BranchObj* TreeItem::getBranchObjNum(const int &n)

 {

 	if (n>=0 && n<branchCounter)

 	{

 		return (BranchObj*)(getBranchNum(n)->getLMO());

 	} else

 		return NULL;

 }

 ImageItem* TreeItem::getImageNum (const int &n)

 {

 	if (n>=0 && n<imageCounter)

 		return (ImageItem*)getChildNum (imageOffset + n);

 	else

 		return NULL;

 }

 FloatImageObj* TreeItem::getImageObjNum (const int &n)	// FIXME-5 what about SVGs later?

 {

 	if (imageCounter>0 )

 		return (FloatImageObj*)(getImageNum(n)->getLMO());

 	else

 		return NULL;

 }

 XLinkItem* TreeItem::getXLinkNum (const int &n)	

 {

 	if (n>=0 && n<xlinkCounter )

 		return (XLinkItem*)getChildNum (xlinkOffset +n);

 	else

 		return NULL;

 }

 XLinkObj* TreeItem::getXLinkObjNum (const int &n)	

 {

 	if (xlinkCounter>0 )

 	{

 		XLinkItem *xli=getXLinkNum (n);

 		if (!xli) return NULL;

 		if (xli->isBegin() )

 			return (XLinkObj*)(xli->getLMO());

 		else

 		{

 			xli=xli->getPartnerXLink();

 			if (!xli) return NULL;

 			return (XLinkObj*)(xli->getLMO());

 		}

 	}

 	return NULL;

 }

 void TreeItem::setHideTmp (HideTmpMode mode)  //FIXME-2	update visibility in derived objects...

 {

 		/*

 	if (type==Image)

 		((ImageItem*)this)->updateVisibility();

 		*/

 		if (mode==HideExport && (hideExport || hasHiddenExportParent() ) )

 		{

 			// Hide stuff according to hideExport flag and parents

 	//		if (lmo) lmo->setVisibility (false);

 			hidden=true;

 		}else

 		{

 			// Do not hide, but still take care of scrolled status

 			hidden=false;

 /*

 			XXXXXXXX treeItem should be THIS

 			move visible to TreeItem???

 			BranchObj now has updateContents

 */

 /*

 		if (isBranchLikeType() )

 			((BranchItem*)this)->updateVisibility();

 			if ( ((BranchItem*)treeItem)->hasScrolledParent((BranchItem*)treeItem))

 				setVisibility (false);

 			else

 				setVisibility (true);

 */			

 		}	

 /*

 		// And take care of my children

 		for (int i=0; i<branchCount(); ++i)

 			getBranchNum(i)->setHideTmp (mode);	// FIXME-4 maybe also consider images and other types

 */

 }

 bool TreeItem::hasHiddenExportParent()

 {

 	// Calls parents recursivly to

 	// find out, if we or parents are temp. hidden

 	if (hidden || hideExport) return true;

 	if (parentItem) 

 		return parentItem->hasHiddenExportParent();

 	else

 		return false;

 }

 void TreeItem::setHideInExport(bool b) 

 {

 	if (type==Branch || type==Image)

 	{

 		hideExport=b;

 		if (b)

 			systemFlags.activate("system-hideInExport");

 		else	

 			systemFlags.deactivate("system-hideInExport");

 	}

 }	

 bool TreeItem::hideInExport()

 {

 	return hideExport;

 }	

 void TreeItem::updateVisibility()

 {

 	// overloaded in derived objects

 }	

 bool TreeItem::isHidden()

 {

 	return hidden;

 }	

 QString TreeItem::getGeneralAttr()

 {

 	QString s;

 	if (hideExport)

 		 s+=attribut("hideInExport","true");

 	if (!url.isEmpty())

 		s+=attribut ("url",url);

 	if (!vymLink.isEmpty())

 		s+=attribut ("vymLink",vymLink);

 	return s;	

 }