#include <iostream>

using namespace std;

#include <QStringList>

#include "treeitem.h"

#include "branchobj.h"

#include "branchitem.h"

#include "vymmodel.h"

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

{

	init();

    parentItem = parent;

    itemData = data;

}

TreeItem::~TreeItem()

{

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

	TreeItem *ti;

	while (!childItems.isEmpty())

	{

		ti=childItems.takeFirst();

		switch (ti->getType() )

		{

			case TreeItem::MapCenter:

				delete (MapCenterItem*)ti;

				break;

			case TreeItem::Branch:

				delete (BranchItem*)ti;

				break;

			default:

				delete ti;

				break;

		}

	}	

}

void TreeItem::init()

{

	model=NULL;

    parentItem = NULL;

    itemData.clear();

	lmo=NULL;	

	branchOffset=0;

	branchCounter=0;

	lastSelectedBranchNum=-1;

	note.setNote(""); 

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

	// isNoteInEditor=false;

	hidden=false;

	// Reset ID

	objID="";

}

QString TreeItem::saveToDir (const QString &tmpdir,const QString &prefix, const QPointF& offset)

{

	cout << "TreeItem::saveToDir called directly for ("<<getHeadingStd()<<"), instead of inherited type...\n";	//FIXME-1 triggered on save

	return QString();

}

/*

void TreeItem::copy (OrnamentedObj* other)	//FIXME-2	probably need deep copy of branches and data!

{

	note.copy (other->note);

	model=other->model;

	hideExport=officially 

	other->hideExport;

}

*/

void TreeItem::setModel (VymModel *m)

{

	model=m;

}

VymModel* TreeItem::getModel ()

{

	return model;

}

void TreeItem::appendChild(TreeItem *item)

{

    childItems.append(item);

	item->parentItem=this;

	item->setModel (model);

	if (item->type == Branch || item->type ==MapCenter)

	{

		if (branchCounter==0)

			branchOffset=childItems.count()-1;

		branchCounter++;

	}

}

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)->isBranchLikeType())

			branchCounter--;

		childItems.removeAt (row);

	}

}

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 itemData.count();

}

int TreeItem::branchCount() const

{

    return branchCounter;

}

int TreeItem::imageCount() const

{

	int imageCounter=0;

    return imageCounter; // FIXME-1 imageCounter needs to be calculated...

}

int TreeItem::xlinkCount() const // FIXME-2 check if xlinks are stored in a different way (global to model?)

{

	int xlinkCounter=0;

    return xlinkCounter; // FIXME-1 xlinkCounter needs to be calculated...

}

int TreeItem::row() const

{

    if (parentItem)

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

    return 0;

}

int TreeItem::column() const

{

    return 0;

}

int TreeItem::depth() 

{

	int d=-2;

	TreeItem *ti=this;

	while (ti!=NULL)

	{

		ti=ti->parent();

		d++;

	}

	return d;

}

TreeItem *TreeItem::parent()

{

    return parentItem;

}

int TreeItem::childNum()

{

	return parentItem->childItems.indexOf (this);

}

int TreeItem::num()

{

	switch (type)

	{

		case Undefined: return -1;

		case MapCenter: return parentItem->childItems.indexOf (this) - branchOffset;

		case Branch: return parentItem->childItems.indexOf (this) - branchOffset;

		case Image: return -1; // FIXME-2

		default: return -1;

	}

}

int TreeItem::num (TreeItem *item)

{

	if (!item) return -1;

	switch (item->getType())

	{

		case Undefined: return -1;

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

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

		case Image: return -1; // FIXME-2

		default: return -1;

	}

}

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::setNote(const QString s)

{

	note.setNote(s);

	// updateNoteFlag();  FIXME-2 needed?

	if (model) 

		model->emitNoteHasChanged (this);

}

void TreeItem::setNoteObj(const NoteObj &n, bool updateNoteEditor)

{

	note=n;

	// updateNoteFlag();  FIXME-2 needed?

	if (model && updateNoteEditor)	

		model->emitNoteHasChanged (this);

}

QString TreeItem::getNote()

{

	return note.getNote();

}

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::setType(const Type t)

{

	type=t;

	itemData[1]=getTypeName();

}

TreeItem::Type TreeItem::getType()

{

	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");

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

	}

}

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::getBranchNum(const int &n)

{

	if (branchCounter>0)

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

	else

		return NULL;

}

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

{

	if (branchCounter>0)

	{

		return (BranchObj*)(getChildNum (branchOffset+n)->lmo);

	} else

		return NULL;

}

void TreeItem::setLastSelectedBranch()

{

	if (parentItem)

		parentItem->lastSelectedBranchNum=parentItem->childItems.indexOf(this);

}

TreeItem* TreeItem::findBySelectString (const QString &s)  //FIXME-1

{

/*

	LinkableMapObj *lmo=this;

	QString part;

	QString typ;

	QString num;

	while (!s.isEmpty() )

	{

		part=s.section(",",0,0);

		typ=part.left (3);

		num=part.right(part.length() - 3);

		if (typ=="mc:")

		{

			if (depth>0)

				return false;	// in a subtree there is no center

			else

				break;

		} else

			if (typ=="bo:")

				lmo=lmo->getTreeItem()->getBranchObjNum (num.toInt());

			else

				if (typ=="fi:")

					lmo=((BranchObj*)lmo)->getFloatImageNum (num.toUInt());

		if (!lmo) break;

		if (s.contains(","))

			s=s.right(s.length() - part.length() -1 );

		else	

			break;

	}

	*/

	return NULL;

}

void TreeItem::setLastSelectedBranch(int i)

{

		lastSelectedBranchNum=i;

}

TreeItem* TreeItem::getLastSelectedBranch()

{

	return getBranchNum (lastSelectedBranchNum);

}

void TreeItem::setHideTmp (HideTmpMode mode)

{

	if (isBranchLikeType() )

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

		/*

	if (type==Image)

		//updateVisibility();

	*/

/*

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

		{

			// Hide stuff according to hideExport flag and parents

			//setVisibility (false);

			updateVisibility();

			//FIXME-2 hidden=true;

		}else

		{

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

			XXXXXXXX treeItem should be THIS

			move visible to TreeItem???

			BranchObj now has updateContents

			maybe also start "bool TreeItem::branchlikeType"

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

				setVisibility (false);

			else

				setVisibility (true);

			//FIXME-2 hidden=false;

		}	

*/

		// And take care of my children

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

			getBranchNum(i)->setHideTmp (mode);

}

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 (isBranchLikeType() )

	{

		hideExport=b;

		/* FIXME-1 call setVis and updateContentsSize...

		if (b)

			systemFlags->activate("hideInExport");

		else	

			systemFlags->deactivate("hideInExport");

		calcBBoxSize();

		positionBBox();

		requestReposition();	

		*/

	}

}	

bool TreeItem::hideInExport()

{

	return hideExport;

}	

bool TreeItem::isHidden()

{

	return hidden;

}	

LinkableMapObj* TreeItem::getLMO()	// FIXME-3  VM should be unnecessary in the end

{

	return lmo;

}

void TreeItem::setLMO(LinkableMapObj *l)

{

	lmo=l;

}