#include "toonzqt/schematicgroupeditor.h"

#include "toonzqt/fxschematicnode.h"

#include "toonzqt/fxschematicscene.h"

#include "toonzqt/stageschematicnode.h"

#include "toonzqt/stageschematicscene.h"

#include "toonzqt/schematicnode.h"

#include "toonzqt/gutil.h"

#include "toonz/fxcommand.h"

#include "toonz/tstageobjectcmd.h"

#include "toonz/tstageobject.h"

#include "tfxattributes.h"

#include "tmacrofx.h"

#include <qaction></qaction>

#include <qmenu></qmenu>

#include <qgraphicsscenecontextmenuevent></qgraphicsscenecontextmenuevent>

//=====================================================

//

//SchematicGroupEditor

//

//=====================================================

SchematicWindowEditor::SchematicWindowEditor(const QList<schematicnode *=""> &groupedNode, SchematicScene *scene)</schematicnode>

#if QT_VERSION >= 0x050000

	: QGraphicsItem()

#else

	: QGraphicsItem(0, scene)

#endif

	  ,

	  m_groupedNode(groupedNode), m_scene(scene), m_lastPos(), m_button(Qt::NoButton), m_isMacroEditor(false)

{

#if QT_VERSION >= 0x050000

	scene->addItem(this);

#endif

	m_nameItem = new SchematicName(this, 67, 14);

	m_nameItem->setPos(-2, -2);

	m_nameItem->setZValue(1);

	m_nameItem->hide();

	connect(m_nameItem, SIGNAL(focusOut()), this, SLOT(onNameChanged()));

}

//---------------------------------------------------------------

SchematicWindowEditor::~SchematicWindowEditor()

{

}

//---------------------------------------------------------------

QRectF SchematicWindowEditor::boundingRect() const

{

	QRectF rect = boundingSceneRect();

	rect.moveTopLeft(QPointF(0, 0));

	rect.adjust(-1, -1, 1, 1);

	return rect;

}

//---------------------------------------------------------------

void SchematicWindowEditor::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)

{

	painter->setPen(QColor(0, 0, 0, 255));

	if (m_isMacroEditor)

		painter->setBrush(QColor(132, 86, 123, 255));

	else

		painter->setBrush(QColor(76, 148, 177, 255));

	QRectF bRect = boundingRect();

	QRectF rect(0, 0, bRect.width(), 15);

	painter->drawRect(rect);

	rect = QRectF(0, 15, bRect.width(), bRect.height() - 15);

	painter->setBrush(QColor(180, 180, 180, 125));

	painter->drawRect(rect);

	//draw the topRight cross

	rect = QRectF(0, 0, 11, 11);

	rect.moveTopLeft(QPointF(bRect.width() - 13, 2));

	painter->drawRoundedRect(rect, 2, 2);

	painter->setPen(Qt::black);

	painter->drawLine(QPointF(rect.left() + 2, rect.top() + 2), QPointF(rect.right() - 2, rect.bottom() - 2));

	painter->drawLine(QPointF(rect.left() + 2, rect.bottom() - 2), QPointF(rect.right() - 2, rect.top() + 2));

	if (!m_nameItem->isVisible()) {

		painter->setPen(Qt::white);

		QFont font("Verdana", 7);

		painter->setFont(font);

		QRectF rect = QRectF(2, 1, bRect.width() - 15, 13);

		QString elidedName = elideText(m_groupName, font, rect.width());

		painter->drawText(rect, elidedName);

	}

}

//---------------------------------------------------------------

void SchematicWindowEditor::resizeNodes(bool maximizeNodes)

{

	prepareGeometryChange();

	doResizeNodes(maximizeNodes);

}

//---------------------------------------------------------------

void SchematicWindowEditor::mousePressEvent(QGraphicsSceneMouseEvent *e)

{

	QRectF bRect = boundingRect();

	QRectF rect = QRectF(0, 0, 11, 11);

	rect.moveTopLeft(QPointF(bRect.width() - 13, 2));

	if (rect.contains(e->pos())) {

		closeEditor();

		return;

	}

	rect = QRectF(0, 0, bRect.width(), 15);

	if (rect.contains(e->pos())) {

		m_button = e->button();

		m_lastPos = e->scenePos();

	}

}

//---------------------------------------------------------------

void SchematicWindowEditor::mouseMoveEvent(QGraphicsSceneMouseEvent *e)

{

	if (m_button == Qt::LeftButton) {

		QPointF delta = e->scenePos() - m_lastPos;

		setPos(scenePos() + delta);

		m_lastPos = e->scenePos();

		int i;

		for (i = 0; i < m_groupedNode.size(); i++) {

			SchematicNode *node = m_groupedNode[i];

			node->setPosition(node->scenePos() + delta);

			node->setSchematicNodePos(node->scenePos());

			node->updateLinksGeometry();

		}

	} else

		e->ignore();

}

//---------------------------------------------------------------

void SchematicWindowEditor::mouseReleaseEvent(QGraphicsSceneMouseEvent *e)

{

	m_button = Qt::NoButton;

}

//---------------------------------------------------------------

void SchematicWindowEditor::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *e)

{

	QRectF bRect = boundingRect();

	QRectF rect = QRectF(2, 0, bRect.width() - 15, 15);

	if (rect.contains(e->pos())) {

		m_nameItem->setPlainText(m_groupName);

		m_nameItem->show();

		m_nameItem->setFocus();

		setFlag(QGraphicsItem::ItemIsSelectable, false);

	}

}

//---------------------------------------------------------------

void SchematicWindowEditor::contextMenuEvent(QGraphicsSceneContextMenuEvent *e)

{

	QRectF bRect = boundingRect();

	QRectF rect(0, 0, bRect.width(), 15);

	if (!rect.contains(e->pos())) {

		e->ignore();

		return;

	}

	QMenu menu(scene()->views()[0]);

	QAction *close = new QAction(tr("&Close Editor"), &menu);

	connect(close, SIGNAL(triggered()), this, SLOT(closeEditor()));

	menu.addAction(close);

	menu.exec(e->screenPos());

}

//=====================================================

//

//FxSchematicGroupEditor

//

//=====================================================

FxSchematicGroupEditor::FxSchematicGroupEditor(int groupId, const QList<schematicnode *=""> &groupedNode, SchematicScene *scene)</schematicnode>

	: SchematicWindowEditor(groupedNode, scene), m_groupId(groupId)

{

	initializeEditor();

	setPos(boundingSceneRect().topLeft());

	m_nameItem->setName(m_groupName);

}

//---------------------------------------------------------------

FxSchematicGroupEditor::~FxSchematicGroupEditor()

{

}

//---------------------------------------------------------------

void FxSchematicGroupEditor::initializeEditor()

{

	FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[0]);</fxschematicnode>

	assert(node);

	TFx *fx = node->getFx();

	assert(fx);

	assert(m_groupId == fx->getAttributes()->getEditingGroupId());

	m_groupName = QString::fromStdWString(fx->getAttributes()->getEditingGroupName());

}

//---------------------------------------------------------------

void FxSchematicGroupEditor::closeEditor()

{

	//Ptrebbero esserci delle macro aperte per edit nel gruppo...

	//devo chiedere alla scena di chiuderle per me... da qui non posso farlo!

	FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

	assert(fxScene);

	fxScene->closeInnerMacroEditor(m_groupId);

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		if (!node)

			continue;

		FxGroupNode *groupNode = dynamic_cast<fxgroupnode *="">(node);</fxgroupnode>

		if (groupNode) {

			QList<tfxp> fxs = groupNode->getGroupedFxs();</tfxp>

			assert(!fxs.isEmpty());

			int j;

			for (j = 0; j < fxs.size(); j++) {

				fxs[j]->getAttributes()->closeEditingGroup(m_groupId);

				TMacroFx *macro = dynamic_cast<tmacrofx *="">(fxs[j].getPointer());</tmacrofx>

				if (macro) {

					std::vector<tfxp> macroFxs = macro->getFxs();</tfxp>

					int j;

					for (j = 0; j < (int)macroFxs.size(); j++)

						macroFxs[j]->getAttributes()->closeEditingGroup(m_groupId);

				}

			}

		} else {

			TFx *fx = node->getFx();

			assert(fx);

			fx->getAttributes()->closeEditingGroup(m_groupId);

			TMacroFx *macro = dynamic_cast<tmacrofx *="">(fx);</tmacrofx>

			if (macro) {

				std::vector<tfxp> macroFxs = macro->getFxs();</tfxp>

				int j;

				for (j = 0; j < (int)macroFxs.size(); j++)

					macroFxs[j]->getAttributes()->closeEditingGroup(m_groupId);

			}

		}

	}

	m_scene->updateScene();

}

//---------------------------------------------------------------

void FxSchematicGroupEditor::onNameChanged()

{

	int i;

	QList<tfxp> fxs;</tfxp>

	m_nameItem->hide();

	m_groupName = m_nameItem->toPlainText();

	for (i = 0; i < m_groupedNode.size(); i++) {

		FxGroupNode *groupNode = dynamic_cast<fxgroupnode *="">(m_groupedNode[i]);</fxgroupnode>

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		if (groupNode)

			fxs.append(groupNode->getGroupedFxs());

		else if (node)

			fxs.append(node->getFx());

	}

	setFlag(QGraphicsItem::ItemIsSelectable, true);

	FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

	if (!fxScene)

		return;

	TFxCommand::renameGroup(fxs.toStdList(), m_groupName.toStdWString(), true, fxScene->getXsheetHandle());

	update();

}

//---------------------------------------------------------------

QRectF FxSchematicGroupEditor::boundingSceneRect() const

{

	QRectF rect = m_groupedNode[0]->boundingRect();

	rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		assert(node);

		TFx *fx = node->getFx();

		assert(fx);

		QRectF app = node->boundingRect();

		app.moveTopLeft(node->scenePos() - app.topLeft());

		bool isASubgroupedNode = fx->getAttributes()->getEditingGroupId() != m_groupId;

		if (isASubgroupedNode) {

			QStack<int> idStack = fx->getAttributes()->getGroupIdStack();</int>

			int start = idStack.indexOf(fx->getAttributes()->getEditingGroupId());

			int k = idStack.indexOf(m_groupId, start) + 1;

			int factor = k * 30;

			app.adjust(-factor, -factor, factor, factor);

		}

#if QT_VERSION >= 0x050000

		rect = rect.united(app);

#else

		rect = rect.unite(app);

#endif

	}

	rect.adjust(-20, -35, 0, 20);

	return rect;

}

//---------------------------------------------------------------

void FxSchematicGroupEditor::setGroupedNodeZValue(int zValue)

{

	int i, size = m_groupedNode.size();

	for (i = 0; i < size; i++) {

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		if (!node)

			continue;

		if (node->getFx()->getAttributes()->getEditingGroupId() == m_groupId)

			node->setZValue(zValue);

	}

}

//---------------------------------------------------------------

void FxSchematicGroupEditor::doResizeNodes(bool maximizeNodes)

{

}

//=====================================================

//

//FxSchematicMacroEditor

//

//=====================================================

FxSchematicMacroEditor::FxSchematicMacroEditor(TMacroFx *macro,

											   const QList<schematicnode *=""> &groupedNode,</schematicnode>

											   SchematicScene *scene)

	: SchematicWindowEditor(groupedNode, scene), m_macro(macro)

{

	m_isMacroEditor = true;

	initializeEditor();

	setPos(boundingSceneRect().topLeft());

	m_nameItem->setName(m_groupName);

}

//---------------------------------------------------------------

FxSchematicMacroEditor::~FxSchematicMacroEditor()

{

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::initializeEditor()

{

	m_groupName = QString::fromStdWString(m_macro->getName());

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::closeEditor()

{

	m_macro->editMacro(false);

	m_scene->updateScene();

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::onNameChanged()

{

	QList<tfxp> fxs;</tfxp>

	m_nameItem->hide();

	m_groupName = m_nameItem->toPlainText();

	setFlag(QGraphicsItem::ItemIsSelectable, true);

	FxSchematicScene *fxScene = dynamic_cast<fxschematicscene *="">(scene());</fxschematicscene>

	if (!fxScene)

		return;

	TFxCommand::renameFx(m_macro, m_groupName.toStdWString(), fxScene->getXsheetHandle());

	update();

}

//---------------------------------------------------------------

QRectF FxSchematicMacroEditor::boundingSceneRect() const

{

	QRectF rect = m_groupedNode[0]->boundingRect();

	rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		assert(node);

		TFx *fx = node->getFx();

		assert(fx);

		QRectF app = node->boundingRect();

		app.moveTopLeft(node->scenePos() - app.topLeft());

#if QT_VERSION >= 0x050000

		rect = rect.united(app);

#else

		rect = rect.unite(app);

#endif

	}

	rect.adjust(-20, -35, 0, 20);

	return rect;

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::setGroupedNodeZValue(int zValue)

{

	int i, size = m_groupedNode.size();

	for (i = 0; i < size; i++) {

		FxSchematicNode *node = dynamic_cast<fxschematicnode *="">(m_groupedNode[i]);</fxschematicnode>

		if (!node)

			continue;

		node->setZValue(zValue);

	}

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::mouseMoveEvent(QGraphicsSceneMouseEvent *e)

{

	SchematicWindowEditor::mouseMoveEvent(e);

	if (m_button == Qt::LeftButton) {

		TFx *root = m_macro->getRoot();

		TPointD pos = root->getAttributes()->getDagNodePos();

		m_macro->getAttributes()->setDagNodePos(pos);

	}

}

//---------------------------------------------------------------

void FxSchematicMacroEditor::doResizeNodes(bool maximizeNodes)

{

	m_macro->getAttributes()->setIsOpened(maximizeNodes);

}

//=====================================================

//

//StageSchematicGroupEditor

//

//=====================================================

StageSchematicGroupEditor::StageSchematicGroupEditor(int groupId, const QList<schematicnode *=""> &groupedNode,</schematicnode>

													 SchematicScene *scene)

	: SchematicWindowEditor(groupedNode, scene), m_groupId(groupId)

{

	initializeEditor();

	setPos(boundingSceneRect().topLeft());

	m_nameItem->setName(m_groupName);

}

//---------------------------------------------------------------

StageSchematicGroupEditor::~StageSchematicGroupEditor()

{

}

//---------------------------------------------------------------

QRectF StageSchematicGroupEditor::boundingSceneRect() const

{

	QRectF rect = m_groupedNode[0]->boundingRect();

	rect.moveTopLeft(m_groupedNode[0]->scenePos() - rect.topLeft());

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[i]);</stageschematicnode>

		assert(node);

		TStageObject *obj = node->getStageObject();

		assert(obj);

		QRectF app = node->boundingRect();

		app.moveTopLeft(node->scenePos() - app.topLeft());

		bool isASubgroupedNode = obj->getEditingGroupId() != m_groupId;

		if (isASubgroupedNode)

			app.adjust(-30, -30, 30, 30);

#if QT_VERSION >= 0x050000

		rect = rect.united(app);

#else

		rect = rect.unite(app);

#endif

	}

	rect.adjust(-20, -35, 0, 0);

	return rect;

}

//---------------------------------------------------------------

void StageSchematicGroupEditor::setGroupedNodeZValue(int zValue)

{

	int i, size = m_groupedNode.size();

	for (i = 0; i < size; i++) {

		StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[i]);</stageschematicnode>

		if (!node)

			continue;

		if (node->getStageObject()->getEditingGroupId() == m_groupId)

			node->setZValue(zValue);

	}

}

//---------------------------------------------------------------

void StageSchematicGroupEditor::closeEditor()

{

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[i]);</stageschematicnode>

		if (!node)

			continue;

		StageSchematicGroupNode *groupNode = dynamic_cast<stageschematicgroupnode *="">(node);</stageschematicgroupnode>

		if (groupNode) {

			QList<tstageobject *=""> objs = groupNode->getGroupedObjects();</tstageobject>

			assert(!objs.isEmpty());

			int j;

			for (j = 0; j < objs.size(); j++)

				objs[j]->closeEditingGroup(m_groupId);

		} else {

			TStageObject *obj = node->getStageObject();

			assert(obj);

			obj->closeEditingGroup(m_groupId);

		}

	}

	m_scene->updateScene();

}

//---------------------------------------------------------------

void StageSchematicGroupEditor::onNameChanged()

{

	int i;

	QList<tstageobject *=""> objs;</tstageobject>

	m_nameItem->hide();

	m_groupName = m_nameItem->toPlainText();

	for (i = 0; i < m_groupedNode.size(); i++) {

		StageSchematicGroupNode *groupNode = dynamic_cast<stageschematicgroupnode *="">(m_groupedNode[i]);</stageschematicgroupnode>

		StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[i]);</stageschematicnode>

		if (groupNode)

			objs.append(groupNode->getGroupedObjects());

		else if (node)

			objs.append(node->getStageObject());

	}

	setFlag(QGraphicsItem::ItemIsSelectable, true);

	StageSchematicScene *stageScene = dynamic_cast<stageschematicscene *="">(scene());</stageschematicscene>

	if (!stageScene)

		return;

	TStageObjectCmd::renameGroup(objs, m_groupName.toStdWString(), true, stageScene->getXsheetHandle());

	update();

}

//---------------------------------------------------------------

void StageSchematicGroupEditor::initializeEditor()

{

	StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[0]);</stageschematicnode>

	assert(node);

	TStageObject *obj = node->getStageObject();

	assert(obj);

	assert(m_groupId == obj->getEditingGroupId());

	m_groupName = QString::fromStdWString(obj->getEditingGroupName());

}

//---------------------------------------------------------------

void StageSchematicGroupEditor::doResizeNodes(bool maximizeNodes)

{

	int i;

	for (i = 0; i < m_groupedNode.size(); i++) {

		StageSchematicNode *node = dynamic_cast<stageschematicnode *="">(m_groupedNode[i]);</stageschematicnode>

		assert(node);

		node->getStageObject()->setIsOpened(maximizeNodes);

	}

}