#ifndef FXSCHEMATIC_H

#define FXSCHEMATIC_H

#include "toonzqt/addfxcontextmenu.h"

#include "schematicviewer.h"

#include "tgeometry.h"

#include <qmap></qmap>

#include <tfx.h></tfx.h>

#include <set></set>

//forward declaration

class FxSchematicNode;

class TFxHandle;

class FxSelection;

class FxSchematicNode;

class TXsheet;

class TSceneHandle;

class QMenu;

class SchematicLink;

class FxGroupNode;

class FxSchematicGroupEditor;

class FxSchematicMacroEditor;

class TMacroFx;

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

//

// FXSchematic

//

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

class FxSchematicScene : public SchematicScene

{

	Q_OBJECT

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

	class SupportLinks

	{

		QList<schematiclink *=""> m_bridges;</schematiclink>

		QList<schematiclink *=""> m_inputs;</schematiclink>

		QList<schematiclink *=""> m_outputs;</schematiclink>

	public:

		SupportLinks() {}

		void addBridgeLink(SchematicLink *link);

		void addInputLink(SchematicLink *link);

		void addOutputLink(SchematicLink *link);

		QList<schematiclink *=""> getBridgeLinks() { return m_bridges; }</schematiclink>

		QList<schematiclink *=""> getInputLinks() { return m_inputs; }</schematiclink>

		QList<schematiclink *=""> getOutputLinks() { return m_outputs; }</schematiclink>

		void hideBridgeLinks();

		void hideInputLinks();

		void hideOutputLinks();

		void showBridgeLinks();

		void showInputLinks();

		void showOutputLinks();

		void removeBridgeLinks(bool deleteLink = false);

		void removeInputLinks(bool deleteLink = false);

		void removeOutputLinks(bool deleteLink = false);

		bool isABridgeLink(SchematicLink *link) { return m_bridges.contains(link); }

		bool isAnInputLink(SchematicLink *link) { return m_inputs.contains(link); }

		bool isAnOutputLink(SchematicLink *link) { return m_outputs.contains(link); }

		void clearAll();

		int size();

	};

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

	TApplication *m_app;

	TXsheetHandle *m_xshHandle;

	TFxHandle *m_fxHandle;

	TFrameHandle *m_frameHandle;

	TColumnHandle *m_columnHandle;

	QPointF m_firstPoint;

	QMap<tfx *="" *,="" fxschematicnode=""> m_table;</tfx>

	QMap<int, *="" fxgroupnode=""> m_groupedTable;</int,>

	QMap<int, *="" fxschematicgroupeditor=""> m_groupEditorTable;</int,>

	QMap<tmacrofx *="" *,="" fxschematicmacroeditor=""> m_macroEditorTable;</tmacrofx>

	FxSelection *m_selection;

	AddFxContextMenu m_addFxContextMenu;

	SupportLinks m_disconnectionLinks, m_connectionLinks;

	bool m_isConnected;

	bool m_linkUnlinkSimulation;

	bool m_altPressed;

	QPointF m_lastPos;

	QList<qpair<tfxp, tpointd="">> m_selectionOldPos;</qpair<tfxp,>

	QList<tfx *=""> m_placedFxs;</tfx>

	FxSchematicNode *m_currentFxNode;

	int m_gridDimension;

	bool m_isLargeScaled;

	QMap<tfx *="" *,="" qlist<fxschematicnode="">> m_nodesToPlace;</tfx>

public:

	FxSchematicScene(QWidget *parent);

	~FxSchematicScene();

	void updateScene();

	QGraphicsItem *getCurrentNode();

	void reorderScene();

	TXsheet *getXsheet();

	void setApplication(TApplication *app);

	TApplication *getApplication() const { return m_app; }

	TXsheetHandle *getXsheetHandle() const { return m_xshHandle; }

	TFxHandle *getFxHandle() const { return m_fxHandle; }

	TFrameHandle *getFrameHandle() const { return m_frameHandle; }

	TColumnHandle *getColumnHandle() const { return m_columnHandle; }

	TFx *getCurrentFx();

	QMenu *getInsertFxMenu() { return m_addFxContextMenu.getInsertMenu(); }

	QMenu *getAddFxMenu() { return m_addFxContextMenu.getAddMenu(); }

	QMenu *getReplaceFxMenu() { return m_addFxContextMenu.getReplaceMenu(); }

	QAction *getAgainAction(int commands) { return m_addFxContextMenu.getAgainCommand(commands); }

	FxSelection *getFxSelection() const { return m_selection; }

	//!Disconnects or connects selected item from the rest of the graph.

	//!Selection must be a connected subgraph. If \b disconnect is true, the selection is disconnected; connected otherwise.

	void simulateDisconnectSelection(bool disconnect);

	//!Updates all Group Editors containing fx.

	//!Each fx is only in one group, but each gruop can contains othe group. All nested Groups must be updated.

	void updateNestedGroupEditors(FxSchematicNode *node, const QPointF &newPos);

	void closeInnerMacroEditor(int groupId);

	void resizeNodes(bool maximizedNode);

	void initCursorScenePos()

	{

		m_addFxContextMenu.setCurrentCursorScenePos(QPointF(0, 0));

	}

	void selectNodes(QList<tfxp> &fxs);</tfxp>

	bool isLargeScaled() { return m_isLargeScaled; }

protected:

	void contextMenuEvent(QGraphicsSceneContextMenuEvent *cme);

	void mousePressEvent(QGraphicsSceneMouseEvent *me);

	void mouseMoveEvent(QGraphicsSceneMouseEvent *me);

	void mouseReleaseEvent(QGraphicsSceneMouseEvent *me);

	bool event(QEvent *e);

private:

	FxSchematicNode *addFxSchematicNode(TFx *fx);

	FxSchematicNode *addGroupedFxSchematicNode(int groupId, const QList<tfxp> &groupedFxs);</tfxp>

	FxSchematicGroupEditor *addEditedGroupedFxSchematicNode(int groupId, const QList<schematicnode *=""> &groupedFxs);</schematicnode>

	FxSchematicMacroEditor *addEditedMacroFxSchematicNode(TMacroFx *macro, const QList<schematicnode *=""> &groupedFxs);</schematicnode>

	FxSchematicNode *createFxSchematicNode(TFx *fx);

	void placeNode(FxSchematicNode *node);

	void updateLink();

	void updateDuplcatedNodesLink();

	void updateEditedGroups(const QMap<int, *="" qlist<schematicnode="">> &editedGroup);</int,>

	void updateEditedMacros(const QMap<tmacrofx *="" *,="" qlist<schematicnode="">> &editedMacro);</tmacrofx>

	FxSchematicNode *getFxNodeFromPosition(const QPointF &pos);

	void placeNodeAndParents(TFx *fx, double x, double &maxX, double &maxY);

	QPointF nearestPoint(const QPointF &point);

	void highlightLinks(FxSchematicNode *node, bool value);

	void updatePosition(FxSchematicNode *node, const TPointD &pos);

	void simulateInsertSelection(SchematicLink *link, bool connect);

	void updatePositionOnResize(TFx *fx, bool maximizedNode);

	void removeRetroLinks(TFx *fx, double &maxX);

signals:

	void showPreview(TFxP);

	void cacheFx(TFxP);

	void doCollapse(const QList<tfxp> &);</tfxp>

	void doExplodeChild(const QList<tfxp> &);</tfxp>

	void editObject();

protected slots:

	void onSelectionSwitched(TSelection *oldSel, TSelection *newSel);

	void onSelectionChanged();

	//void onOutputFxAdded();

	void onDisconnectFromXSheet();

	void onConnectToXSheet();

	void onDeleteFx();

	void onDuplicateFx();

	void onUnlinkFx();

	void onMacroFx();

	void onExplodeMacroFx();

	void onOpenMacroFx();

	void onSavePresetFx();

	void onRemoveOutput();

	void onActivateOutput();

	void onPreview();

	void onCacheFx();

	void onUncacheFx();

	void onCollapse(const QList<tfxp> &);</tfxp>

	void onOpenSubxsheet();

	void onXsheetChanged();

	void onSceneChanged();

	void onSwitchCurrentFx(TFx *);

	void onCurrentFxSwitched();

	void onCurrentColumnChanged(int);

	void onFxNodeDoubleClicked();

	void onInsertPaste();

	void onAddPaste();

	void onReplacePaste();

	void onAltModifierChanged(bool);

	void onEditGroup();

private:

	void setEnableCache(bool toggle);

	// not implemented

	FxSchematicScene(const FxSchematicScene &);

	const FxSchematicScene &operator=(const FxSchematicScene &);

};

#endif //FXSCHEMATIC_H