#include "branchobj.h"

#include "branchitem.h"

#include "geometry.h"

#include "mapeditor.h"

#include "mainwindow.h"

#include "misc.h"

extern FlagRow *standardFlagsMaster;

extern FlagRow *systemFlagsMaster;

/////////////////////////////////////////////////////////////////

// BranchObj

/////////////////////////////////////////////////////////////////

BranchObj::BranchObj (QGraphicsScene* s,TreeItem *ti):OrnamentedObj (s)

{

//    cout << "Const BranchObj (s)  \n";

	parObj=NULL;

    scene=s;

	treeItem=ti;

	init();

}

/*

BranchObj::BranchObj (QGraphicsScene* s, LinkableMapObj* p):OrnamentedObj (s)// FIXME-3 needed at all?

{

//    cout << "Const BranchObj (s,p)\n";

    scene=s;

    setParObj (p);	

	if (treeItem->depth()==1)	// FIXME-3 needed to recursively calc depth?

		// Calc angle to mapCenter if I am a mainbranch

		// needed for reordering the mainbranches clockwise 

		// around mapcenter 

		angle=getAngle (QPointF (x() - parObj->getChildPos().x() , 

								(y() - parObj->getChildPos().y() ) ) );

    init();

}

*/

BranchObj::~BranchObj ()

{

//	cout << "Destr BranchObj of "<<this<<" ("<<treeItem->getHeading().toStdString()<<")"<<endl;

	// If I'm animated, I need to un-animate myself first

	if (anim.isAnimated() )

	{

		anim.setAnimated (false);

		VymModel *model=treeItem->getModel();

		model->stopAnimation (this);

	}

	// Check, if this branch was the last child to be deleted

	// If so, unset the scrolled flags in parent // FIXME-2 better do this in model?

	/*

	BranchObj *po=(BranchObj*)parObj;

	BranchObj *bo;

	if (po)

	{

		bo=((BranchObj*)parObj)->getLastBranch();

		if (bo) po->unScroll();

	}

	*/

	clear();

}

bool BranchObj::operator< ( const BranchObj & other )

{

    return  angle < other.angle;

}

bool BranchObj::operator== ( const BranchObj & other )

{

    return angle == other.angle;

}

void BranchObj::init () 

{

	if (parObj)

	{

		absPos=getRandPos();

		absPos+=parObj->getChildPos();

	}

}

void BranchObj::copy (BranchObj* other)

{

    OrnamentedObj::copy(other);

	setVisibility (other->visible);

	angle=other->angle;

    positionBBox();

}

void BranchObj::clear() 

{

	//setVisibility (true); //FIXME-4 needed?

	while (!xlink.isEmpty())

		delete xlink.takeFirst();

}

bool isAbove (BranchObj* a, BranchObj *b)

{

	if (a->angle < b->angle)

		return true;

	else	

		return false;

}

void BranchObj::setParObjTmp(LinkableMapObj* lmo, QPointF m, int off)

{

	// Temporary link to lmo

	// m is position of mouse pointer 

	// offset 0: default 1: below lmo   -1 above lmo  (if possible)

	BranchItem *pi=(BranchItem*)(lmo->getTreeItem()->parent());

	int pi_depth=pi->depth();

	BranchObj* o=(BranchObj*)(lmo);

	if (!parObjTmpBuf) 

		parObjTmpBuf=parObj;

	// ignore mapcenter and mainbranch	//FIXME-3 MCO meanwhile also could be relinked

	if (pi_depth<2) off=0;

	if (off==0)

		link2ParPos=false;

	else

		link2ParPos=true;

	parObj=o;

	// setLinkStyle calls updateLinkGeometry, only set it once

	//LinkableMapObj::Style ls=getDefLinkStyle (lmo->getTreeItem() );

	//if (style!=ls ) setLinkStyle (ls);

	setLinkStyle (lmo->getDefLinkStyle (lmo->getTreeItem()));

	// Move temporary to new position at destination

	// Usually the positioning would be done by reposition(),

	// but then also the destination branch would "Jump" around...

	// Better just do it approximately

	if (parObj->getTreeItem()->depth()==0)	

	{	// new parent is a mapcenter

		QPointF p= normalize ( QPointF (m.x() - o->getChildPos().x(),

									  m.y() - o->getChildPos().y() ));

		if (p.x()<0) p.setX( p.x()-bbox.width() );

		move2RelPos (p);

	} else

	{	

		qreal y;

		if (off==0)

		{

			// new parent is just a branch, link to it

			QRectF t=o->getBBoxSizeWithChildren();

			if (o->getTreeItem()->getLastBranch())

				y=t.y() + t.height() ;

			else

				y=t.y();

		} else

		{

			if (off<0)

				// we want to link above lmo

				y=o->y() - height() + 5;

			else	

				// we want to link below lmo

				// Bottom of sel should be 5 pixels above

				// the bottom of the branch _below_ the target:

				// Don't try to find that branch, guess 12 pixels

				y=o->getChildPos().y()  -height() + 12; 

		}	

		if (o->getOrientation()==LinkableMapObj::LeftOfCenter)

			move ( o->getChildPos().x() - linkwidth, y );

		else	

			move (o->getChildPos().x() + linkwidth, y );

	}	

	// updateLinkGeometry is called implicitly in move

	requestReposition();	

}

void BranchObj::unsetParObjTmp()

{

	if (parObjTmpBuf) 

	{

		link2ParPos=false;

		parObj=parObjTmpBuf;

		parObjTmpBuf=NULL;

		setLinkStyle (getDefLinkStyle(treeItem->parent() ) );

		updateLinkGeometry();

	}		

}

void BranchObj::setVisibility(bool v, int toDepth)

{

	BranchItem *bi=(BranchItem*)treeItem;

    if (bi->depth() <= toDepth)

    {

		frame->setVisibility(v);

		heading->setVisibility(v);

		systemFlags->setVisibility(v);

		standardFlags->setVisibility(v);

		LinkableMapObj::setVisibility (v);

		int i;

		for (i=0; i<treeItem->imageCount(); ++i)

			treeItem->getImageObjNum(i)->setVisibility (v);

		for (i=0; i<treeItem->xlinkCount(); ++i)	

			treeItem->getXLinkObjNum(i)->setVisibility ();	

		// Only change children, if I am not scrolled

		if (! bi->isScrolled() && (bi->depth() < toDepth))

		{

			// Now go recursivly through all children //FIXME-3 are there multiple calls for lower level items???

			for (i=0; i<treeItem->branchCount(); ++i)

				treeItem->getBranchObjNum(i)->setVisibility (v,toDepth);	

		}

    } // depth <= toDepth	

	requestReposition();

}	

void BranchObj::setVisibility(bool v)

{

    setVisibility (v,MAX_DEPTH);

}

void BranchObj::setLinkColor ()

{

	// Overloaded from LinkableMapObj

	// BranchObj can use color of heading

	VymModel *model=treeItem->getModel();

	if (model)

	{

		if (model->getMapLinkColorHint()==HeadingColor)

			LinkableMapObj::setLinkColor (heading->getColor() );

		else	

			LinkableMapObj::setLinkColor ();

	}		

}

void BranchObj::updateContentSize()

{

	calcBBoxSize();

	positionBBox();

	requestReposition();

}

void BranchObj::positionContents()

{

	for (int i=0; i<treeItem->imageCount(); ++i)

		treeItem->getImageObjNum(i)->reposition();

	OrnamentedObj::positionContents();

}

void BranchObj::move (double x, double y)

{

	OrnamentedObj::move (x,y);

	FloatImageObj *fio;

    for (int i=0; i<treeItem->imageCount(); ++i )

	{

		fio=treeItem->getImageObjNum(i);

		if (fio) fio->reposition();

	}

    positionBBox();

}

void BranchObj::move (QPointF p)

{

	move (p.x(), p.y());

}

void BranchObj::moveBy (double x, double y)

{

	OrnamentedObj::moveBy (x,y);

	for (int i=0; i<treeItem->branchCount(); ++i)

		treeItem->getBranchObjNum(i)->moveBy (x,y);

    positionBBox();

}

void BranchObj::moveBy (QPointF p)

{

	moveBy (p.x(), p.y());

}

void BranchObj::positionBBox()

{

	QPointF ap=getAbsPos();

	bbox.moveTopLeft (ap);

	positionContents();

	// set the frame

	frame->setRect(QRectF(bbox.x(),bbox.y(),bbox.width(),bbox.height() ) );

	//Update links to other branches

	XLinkObj *xlo;

	for (int i=0; i<treeItem->xlinkCount(); ++i)	

	{

		xlo=treeItem->getXLinkObjNum(i);

		if (xlo) xlo->updateXLink();

	}	

}

void BranchObj::calcBBoxSize()

{

    QSizeF heading_r=heading->getSize();

    qreal heading_w=(qreal) heading_r.width() ;

    qreal heading_h=(qreal) heading_r.height() ;

    QSizeF sysflags_r=systemFlags->getSize();

	qreal sysflags_h=sysflags_r.height();

	qreal sysflags_w=sysflags_r.width();

    QSizeF stanflags_r=standardFlags->getSize();

	qreal stanflags_h=stanflags_r.height();

	qreal stanflags_w=stanflags_r.width();

    qreal w;

    qreal h;

	// set width to sum of all widths

	w=heading_w + sysflags_w + stanflags_w;

	// set height to maximum needed height

	h=max (sysflags_h,stanflags_h);

	h=max (h,heading_h);

	// Save the dimension of flags and heading

	ornamentsBBox.setSize ( QSizeF(w,h));

	// clickBox includes Flags and Heading

    clickBox.setSize (ornamentsBBox.size() );

	// Floatimages 

	QPointF rp;

	topPad=botPad=leftPad=rightPad=0;

	bool incV=((BranchItem*)treeItem)->getIncludeImagesVer();

	bool incH=((BranchItem*)treeItem)->getIncludeImagesHor();

	if (incH || incV)

	{

		FloatImageObj *fio;

		for (int i=0; i<treeItem->imageCount(); ++i )	

		{

			fio=treeItem->getImageObjNum(i);

			rp=fio->getRelPos();

			if (incV)

			{

				if (rp.y() < 0) 

					topPad=max (topPad,-rp.y()-h);

				if (rp.y()+fio->height() > 0)

					botPad=max (botPad,rp.y()+fio->height());

			}		

			if (incH)

			{

				if (orientation==LinkableMapObj::RightOfCenter)

				{

					if (-rp.x()-w > 0) 

						leftPad=max (leftPad,-rp.x()-w);

					if (rp.x()+fio->width() > 0)

						rightPad=max (rightPad,rp.x()+fio->width());

				} else

				{

					if (rp.x()< 0) 

						leftPad=max (leftPad,-rp.x());

					if (rp.x()+fio->width() > w)

						rightPad=max (rightPad,rp.x()+fio->width()-w);

				}

			}		

		}	

		h+=topPad+botPad;

		w+=leftPad+rightPad;

	}

	// Frame thickness

    w+=frame->getPadding();

    h+=frame->getPadding();

	// Finally set size

    bbox.setSize (QSizeF (w,h));

}

void BranchObj::setDockPos()

{

	if (treeItem->getType()==TreeItem::MapCenter)

	{

		// set childPos to middle of MapCenterObj

		childPos.setX( clickBox.topLeft().x() + clickBox.width()/2 );

		childPos.setY( clickBox.topLeft().y() + clickBox.height()/2 );

		parPos=childPos;		

		for (int i=0; i<treeItem->branchCount(); ++i)

			treeItem->getBranchObjNum(i)->updateLinkGeometry();

	} else

	{

		// Sets childpos and parpos depending on orientation

		if (getOrientation()==LinkableMapObj::LeftOfCenter )

		{

			childPos=QPointF (

				ornamentsBBox.bottomLeft().x(), 

				bottomlineY);

			parPos=QPointF (

				ornamentsBBox.bottomRight().x(),

				bottomlineY);

		} else

		{

			childPos=QPointF (

				ornamentsBBox.bottomRight().x(), 

				bottomlineY);

			parPos=QPointF (

				ornamentsBBox.bottomLeft().x(),

				bottomlineY);

		}

	}

}

void BranchObj::updateData()

{

	bool changed=false;

	if (!treeItem)

	{

		qWarning ("BranchObj::udpateHeading treeItem==NULL");

		return;

	}

	QString s=treeItem->getHeading();

	if (s!=heading->text())

	{

		heading->setText (s);

		changed=true;

	}

	QStringList TIactiveFlags=treeItem->activeStandardFlagNames();

	// Add missing standard flags active in TreeItem

	for (int i=0;i<=TIactiveFlags.size()-1;i++)

	{	

		if (!standardFlags->isActive (TIactiveFlags.at(i) ))

		{

			Flag *f=standardFlagsMaster->getFlag(TIactiveFlags.at(i));

			if (f) standardFlags->activate (f);

			changed=true;

		}

	}

	// Remove standard flags no longer active in TreeItem

	QStringList BOactiveFlags=standardFlags->activeFlagNames();

	for (int i=0;i<BOactiveFlags.size();++i)

		if (!TIactiveFlags.contains (BOactiveFlags.at(i)))

		{

			standardFlags->deactivate (BOactiveFlags.at(i));

			changed=true;

		}	

	// Add missing system flags active in TreeItem

	TIactiveFlags=treeItem->activeSystemFlagNames();

	for (int i=0;i<TIactiveFlags.size();++i)

	{	

		if (!systemFlags->isActive (TIactiveFlags.at(i) ))

		{

			Flag *f=systemFlagsMaster->getFlag(TIactiveFlags.at(i));

			if (f) systemFlags->activate (f);

			changed=true;

		}

	}

	// Remove system flags no longer active in TreeItem

	BOactiveFlags=systemFlags->activeFlagNames();

	for (int i=0;i<BOactiveFlags.size();++i)

	{

		if (!TIactiveFlags.contains (BOactiveFlags.at(i)))

		{

			systemFlags->deactivate (BOactiveFlags.at(i));

			changed=true;

		}	

	}

	updateContentSize();

}

void BranchObj::savePosInAngle ()

{

	// Save position in angle

	for (int i=0; i<treeItem->branchCount(); ++i)

		treeItem->getBranchObjNum(i)->angle=i;

}

void BranchObj::setDefAttr (BranchModification mod)

{

	int fontsize;

	switch (treeItem->depth())

	{

		case 0: fontsize=16; break;

		case 1: fontsize=12; break;

		default: fontsize=10; break;

	}	

	setLinkStyle(getDefLinkStyle(treeItem->parent() ));

	setLinkColor ();

	QFont font("Sans Serif,8,-1,5,50,0,0,0,0,0");

	font.setPointSize(fontsize);

	heading->setFont(font );

	if (mod==NewBranch)

		setColor (treeItem->getHeadingColor() );

	calcBBoxSize();

}

void BranchObj::sortChildren() //FIXME-3 not moved to model yet 

{

/*

	int childCount=branch.count(); 

	int curChildIndex;

	bool madeChanges=false;

	do

	{

		madeChanges=false;

		for(curChildIndex=1;curChildIndex<childCount;curChildIndex++){

			BranchObj* curChild=(BranchObj*)treeItem->getBranchObjNum(curChildIndex);

			BranchObj* prevChild=(BranchObj*)treeItem->getBranchObjNum(curChildIndex-1);

			if(prevChild->heading->text().compare(curChild->heading->text())>0)

			{

				this->moveBranchUp(curChild);

				madeChanges=true;

			}

		}

	}while(madeChanges);

*/

}

void BranchObj::alignRelativeTo (QPointF ref,bool alignSelf)

{

	qreal th = bboxTotal.height();	

	int depth=treeItem->depth();	// FIXME-3 needed to recursively calc depth?

// TODO testing

/*

	QString h=QString (depth,' ');

	h+=treeItem->getHeading();

	h+=QString (15,' ');

	h.truncate (15);

	QPointF pp; if (parObj) pp=parObj->getChildPos();

	cout << "BO::alignRelTo ";

	cout<<h.toStdString();

	cout << "    d="<<depth<<

//cout<<  "  ref="<<ref<<

      	"  bbox.tL="<<bboxTotal.topLeft()<<

		"  absPos="<<absPos<<

//		"  relPos="<<relPos<<

//		"  parPos="<<pp<<

		"  w="<<bbox.width()<<

		"  h="<<bbox.height()<<

//		"  orient="<<orientation<<

//		"  alignSelf="<<alignSelf<<

//		"  scrolled="<<((BranchItem*)treeItem)->isScrolled()<<

//		"  pad="<<topPad<<","<<botPad<<","<<leftPad<<","<<rightPad<<

//		"  hidden="<<hidden<<

		"  th="<<th<<

		endl;

*/

	setOrientation();

	//updateLinkGeometry();

	if (depth==1 && parObj)

	{

		// Position relatively, if needed

		//if (useRelPos) move2RelPos (relPos.x(), relPos.y());

		// Calc angle to mapCenter if I am a mainbranch

		// needed for reordering the mainbranches clockwise 

		// around mapcenter 

		angle=getAngle (QPointF ((int)(x() - parObj->getChildPos().x() ), 

								(int)(y() - parObj->getChildPos().y() ) ) );

	}							

	if (depth>1)

    {

		// Align myself depending on orientation and parent, but

		// only if I am not a mainbranch or mapcenter itself

		if (anim.isAnimated())

		{

			move2RelPos(anim);

		} else

		{

			LinkableMapObj::Orientation o;

			o=parObj->getOrientation();

			if (alignSelf)

				switch (orientation) 

				{

					case LinkableMapObj::LeftOfCenter:

						move (ref.x() - bbox.width(), ref.y() + (th-bbox.height())/2 );

						//move (ref.x() , ref.y() + (th-bbox.height())/2 );

					break;

					case LinkableMapObj::RightOfCenter:	

						move (ref.x() , ref.y() + (th-bbox.height())/2  );

					break;

					default:

						qWarning ("LMO::alignRelativeTo: oops, no orientation given...");

					break;

			}

		}

    }		

	if ( ((BranchItem*)treeItem)->isScrolled() ) return;

    // Set reference point for alignment of children

    QPointF ref2;

    if (orientation==LinkableMapObj::LeftOfCenter)

		ref2.setX(bbox.topLeft().x() - linkwidth);

    else	

		ref2.setX(bbox.topRight().x() + linkwidth);

	if (depth==1)

		ref2.setY(absPos.y()-(bboxTotal.height()-bbox.height())/2);

	else	

		ref2.setY(ref.y() );	

    // Align the children depending on reference point 

	for (int i=0; i<treeItem->branchCount(); ++i)

    {	

		if (!treeItem->getBranchNum(i)->isHidden())

		{

			treeItem->getBranchObjNum(i)->alignRelativeTo (ref2,true);

			// append next branch below current one

			ref2.setY(ref2.y() + treeItem->getBranchObjNum(i)->getBBoxSizeWithChildren().height() );

		}

    }

}

void BranchObj::reposition()

{	

/* TODO testing only

	if (!treeItem->getHeading().isEmpty())

		cout << "BO::reposition  "<<qPrintable(treeItem->getHeading())<<endl;

	else	

		cout << "BO::reposition  ???"<<endl;

//	cout << "  orient="<<orientation<<endl;

*/		

	if (treeItem->depth()==0)

	{

		// only calculate the sizes once. If the deepest LMO 

		// changes its height,

		// all upper LMOs have to change, too.

		calcBBoxSizeWithChildren();

		updateLinkGeometry();	// This update is needed if the scene is resized 

						// due to excessive moving of a FIO

	    alignRelativeTo ( QPointF (absPos.x(),

			absPos.y()-(bboxTotal.height()-bbox.height())/2) );

		//FIXME-2 qSort (branch.begin(),branch.end(), isAbove);

		positionBBox();	// Reposition bbox and contents

	} else

	{

		// This is only important for moving branches:

		// For editing a branch it isn't called...

	    alignRelativeTo ( QPointF (absPos.x(),

							absPos.y()-(bboxTotal.height()-bbox.height())/2) );

	}

}

void BranchObj::unsetAllRepositionRequests()

{

	repositionRequest=false;

	for (int i=0; i<treeItem->branchCount(); ++i)

		treeItem->getBranchObjNum(i)->unsetAllRepositionRequests();

}

QPolygonF BranchObj::shape()

{

	QPolygonF p;

	QRectF r=getTotalBBox();

	if (orientation==LinkableMapObj::LeftOfCenter)

		p   <<r.bottomLeft()

			<<r.topLeft()

			<<QPointF (bbox.topLeft().x(), r.topLeft().y() )

			<<bbox.topRight()

			<<bbox.bottomRight()

			<<QPointF (bbox.bottomLeft().x(), r.bottomLeft().y() ) ;

	else		

		p   <<r.bottomRight()

			<<r.topRight()

			<<QPointF (bbox.topRight().x(), r.topRight().y() )

			<<bbox.topLeft()

			<<bbox.bottomLeft()

			<<QPointF (bbox.bottomRight().x(), r.bottomRight().y() ) ;

	return p;

}

QRectF BranchObj::getTotalBBox()

{

	QRectF r=bbox;

	if ( ((BranchItem*)treeItem)->isScrolled() ) return r;

	for (int i=0; i<treeItem->branchCount(); ++i)

		if (!treeItem->getBranchNum(i)->isHidden())

			r=addBBox(treeItem->getBranchObjNum(i)->getTotalBBox(),r);

/* FIXME-3 lots of occurences of treeItem->getBranchObjNum(i) in branchobj.cpp

            better check if they are not NULL and maybe simplify...

			(have been NULL at least in calcBBoxSizeWithChilds...)

*/			

	for (int i=0; i<treeItem->imageCount(); ++i)

		if (!treeItem->isHidden())

			r=addBBox(treeItem->getImageObjNum(i)->getTotalBBox(),r);

	return r;

}

QRectF BranchObj::getBBoxSizeWithChildren()

{

	return bboxTotal;

}

void BranchObj::calcBBoxSizeWithChildren()

{	

	// This is initially called only from reposition and

	// and only for mapcenter. So it won't be

	// called more than once for a single user 

	// action

	// Calculate size of LMO including all children (to align them later)

	bboxTotal.setX(bbox.x() );

	bboxTotal.setY(bbox.y() );

	// if branch is scrolled, ignore children, but still consider floatimages

	BranchItem *bi=(BranchItem*)treeItem;

	if ( bi->isScrolled() ) 

	{

		bboxTotal.setWidth (bbox.width());

		bboxTotal.setHeight(bbox.height());

		return;

	}

	if (bi->isHidden())

	{

		bboxTotal.setWidth (0);

		bboxTotal.setHeight(0);

		if (parObj)

		{

			bboxTotal.setX (parObj->x());

			bboxTotal.setY (parObj->y());

		} else

		{

			bboxTotal.setX (bbox.x());

			bboxTotal.setY (bbox.y());

		}

		return;

	}

	QRectF r(0,0,0,0);

	QRectF br;

	// Now calculate recursivly

	// sum of heights 

	// maximum of widths 

	// minimum of y

	for (int i=0; i<treeItem->branchCount(); i++)

	{

		if (!bi->getBranchNum(i)->isHidden())

		{

			bi->getBranchObjNum(i)->calcBBoxSizeWithChildren();

			br=bi->getBranchObjNum(i)->getBBoxSizeWithChildren();

			r.setWidth( max (br.width(), r.width() ));

			r.setHeight(br.height() + r.height() );

			if (br.y()<bboxTotal.y()) bboxTotal.setY(br.y());

		}

	}

	// Add myself and also

	// add width of link to sum if necessary

	if (bi->branchCount()<1)

		bboxTotal.setWidth (bbox.width() + r.width() );

	else	

		bboxTotal.setWidth (bbox.width() + r.width() + linkwidth);

	bboxTotal.setHeight(max (r.height(),  bbox.height()));

}

QString BranchObj::getSelectString()

{

	VymModel *model=treeItem->getModel();

	if (model)

		return model->getSelectString (this);

	else

		return QString();

}

void BranchObj::setAnimation(const AnimPoint &ap)

{

	anim=ap;

}

bool BranchObj::animate()

{

	anim.animate ();

	if ( anim.isAnimated() )

	{

		setRelPos (anim);

		return true;

	}

	parObj->reposition();	// we might have been relinked meanwhile

	return false;

}