#include <QStringList>

#include "branchobj.h"

#include "treeitem.h"

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

{

    parentItem = parent;

    itemData = data;

	lmo=NULL;

	branchOffset=0;

	branchCounter=0;

	lastSelectedBranchNum=-1;

}

TreeItem::~TreeItem()

{

    qDeleteAll(childItems);

}

void TreeItem::appendChild(TreeItem *item)

{

    childItems.append(item);

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

	{

		if (branchCounter==0)

			branchOffset=childItems.count()-1;

		branchCounter++;

	}

}

#include <iostream>

using namespace std;

void TreeItem::removeChild(int row)

{

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

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

	else

	{

		cout << "TI::removeChild this="<<this<<"  row="<<row<<endl;

		delete childItems.takeAt (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::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=-1;

	TreeItem *ti=this;

	while (ti!=NULL)

	{

		ti=ti->parent();

		d++;

	}

	return d;

}

TreeItem *TreeItem::parent()

{

    return parentItem;

}

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

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

{

	return itemData[0].toString();

}

void TreeItem::setNote(const QString s)

{

	switch (type)

	{

		case MapCenter: 

			((BranchObj*)lmo)->setNote(s);

			break;

		case Branch: 

			((BranchObj*)lmo)->setNote(s);

			break;

		default: ;

	}

}

QString TreeItem::getNote()

{

	switch (type)

	{

		case MapCenter: return ((BranchObj*)lmo)->getNote();

		case Branch: return ((BranchObj*)lmo)->getNote();

		default: return QString ();

	}

}

void TreeItem::setType(const Type t)

{

	type=t;

	itemData[1]=getTypeName();

}

TreeItem::Type TreeItem::getType()

{

	return type;

}

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

	}

}

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

{

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

		return childItems.at(n);

	else

		return NULL;

}

TreeItem* TreeItem::getFirstBranch()

{

	if (branchCounter>0)

		return getBranchNum (branchOffset);

	else

		return NULL;

}

TreeItem* TreeItem::getLastBranch()

{

	if (branchCounter>0)

		return getBranchNum (branchOffset + branchCounter-1);

	else

		return NULL;

}

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

{

	if (branchCounter>0)

		return getChildNum (branchOffset + n);

	else

		return NULL;

}

void TreeItem::setLastSelectedBranch()

{

	if (parentItem)

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

}

TreeItem* TreeItem::getLastSelectedBranch()

{

	return getBranchNum (lastSelectedBranchNum);

}

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

{

	return lmo;

}

void TreeItem::setLMO(LinkableMapObj *l)

{

	lmo=l;

}