#pragma once
 
#ifndef FXSCHEMATIC_H
#define FXSCHEMATIC_H
 
#include "toonzqt/addfxcontextmenu.h"
#include "schematicviewer.h"
#include "tgeometry.h"
#include <QMap>
#include <tfx.h>
#include <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;
		QList<SchematicLink *> m_inputs;
		QList<SchematicLink *> m_outputs;
 
	public:
		SupportLinks() {}
 
		void addBridgeLink(SchematicLink *link);
		void addInputLink(SchematicLink *link);
		void addOutputLink(SchematicLink *link);
 
		QList<SchematicLink *> getBridgeLinks() { return m_bridges; }
		QList<SchematicLink *> getInputLinks() { return m_inputs; }
		QList<SchematicLink *> getOutputLinks() { return m_outputs; }
 
		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;
	QMap<int, FxGroupNode *> m_groupedTable;
	QMap<int, FxSchematicGroupEditor *> m_groupEditorTable;
	QMap<TMacroFx *, FxSchematicMacroEditor *> m_macroEditorTable;
	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;
	QList<TFx *> m_placedFxs;
	FxSchematicNode *m_currentFxNode;
	int m_gridDimension;
 
	bool m_isLargeScaled;
 
	QMap<TFx *, QList<FxSchematicNode *>> m_nodesToPlace;
 
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);
	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);
	FxSchematicGroupEditor *addEditedGroupedFxSchematicNode(int groupId, const QList<SchematicNode *> &groupedFxs);
	FxSchematicMacroEditor *addEditedMacroFxSchematicNode(TMacroFx *macro, const QList<SchematicNode *> &groupedFxs);
	FxSchematicNode *createFxSchematicNode(TFx *fx);
	void placeNode(FxSchematicNode *node);
	void updateLink();
	void updateDuplcatedNodesLink();
	void updateEditedGroups(const QMap<int, QList<SchematicNode *>> &editedGroup);
	void updateEditedMacros(const QMap<TMacroFx *, QList<SchematicNode *>> &editedMacro);
	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> &);
	void doExplodeChild(const QList<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> &);
	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