#include "UI.hpp"

#include "Model/Workflow/Nodes/DocumentNodes.hpp"
#include "Model/Workflow/Nodes/NumericNodes.hpp"
#include "Model/Workflow/Nodes/TextNodes.hpp"
#include "Model/Workflow/Nodes/UserInputNodes.hpp"
#include "Model/Workflow/Workflow.hpp"
#include "UI/Localization.hpp"
#include "Utils/Macros.hpp"

#include <imgui.h>
#include <imgui_node_editor.h>
#include <memory>
#include <span>
#include <vector>

namespace ImNodes = ax::NodeEditor;

namespace {
class WorkflowCreationMenu
{
private:
	using WorkflowNodeConstructor = std::unique_ptr<WorkflowNode> (*)();

	enum Category
	{
		NumericCategory,
		TextCategory,
		DocumentsCategory,
		UserInputCategory,
		SystemInputCategory,
		OutputCategory,
	};

	struct Candidate
	{
		WorkflowNodeConstructor Constructor;
		std::string Name;
		Category Category;
	};

	std::vector<Candidate> mCandidates;

#define SUB_RANGE_ACCESS(Type, AccessorName, storage, begin, nextBegin) \
	std::span<Type> AccessorName()                                      \
	{                                                                   \
		return { &storage[begin], (size_t)(nextBegin - begin) };        \
	}

	int mTextOffset;
	int mDocumentOffset;
	int mUserInputOffset;
	int mSystemInputNodes;
	int mOutputOffset;

	SUB_RANGE_ACCESS(Candidate, GetNumericNodes, mCandidates, 0, mTextOffset);
	SUB_RANGE_ACCESS(Candidate, GetTextNodes, mCandidates, mTextOffset, mDocumentOffset);
	SUB_RANGE_ACCESS(Candidate, GetDocumentNodes, mCandidates, mDocumentOffset, mUserInputOffset);
	SUB_RANGE_ACCESS(Candidate, GetUserInputNodes, mCandidates, mUserInputOffset, mSystemInputNodes);
	SUB_RANGE_ACCESS(Candidate, GetSystemInputNodes, mCandidates, mSystemInputNodes, mOutputOffset);
	SUB_RANGE_ACCESS(Candidate, GetOutputNodes, mCandidates, mOutputOffset, mCandidates.size());

#undef SUB_RANGE_ACCESS

public:
	WorkflowCreationMenu()
	{
		SetupCandidates();
	}

private:
	void SetupCandidates()
	{
		// Numeric nodes offset start at 0
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<NumericOperationNode>(NumericOperationNode::Addition); },
			.Name = "Add",
			.Category = NumericCategory,
		});
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<NumericOperationNode>(NumericOperationNode::Subtraction); },
			.Name = "Subtract",
			.Category = NumericCategory,
		});
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<NumericOperationNode>(NumericOperationNode::Multiplication); },
			.Name = "Multiply",
			.Category = NumericCategory,
		});
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<NumericOperationNode>(NumericOperationNode::Division); },
			.Name = "Divide",
			.Category = NumericCategory,
		});
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<NumericExpressionNode>(); },
			.Name = "Evaluate expression",
			.Category = NumericCategory,
		});

		mTextOffset = mCandidates.size();
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<TextFormatterNode>(); },
			.Name = "Fill template text",
			.Category = TextCategory,
		});

		mDocumentOffset = mCandidates.size();
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<DocumentTemplateExpansionNode>(); },
			.Name = "Document template",
			.Category = Category::DocumentsCategory,
		});

		/* Inputs */

		mUserInputOffset = mCandidates.size();
		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<FormInputNode>(); },
			.Name = "Input: form",
			.Category = Category::UserInputCategory,
		});

		mCandidates.push_back(Candidate{
			.Constructor = []() -> std::unique_ptr<WorkflowNode> { return std::make_unique<DatabaseRowsInputNode>(); },
			.Name = "Input: database rows",
			.Category = Category::UserInputCategory,
		});

		mSystemInputNodes = mCandidates.size();

		/* Outputs */

		mOutputOffset = mCandidates.size();
	}
};

class WorkflowUI
{
private:
	Workflow* mWorkflow;
	ImNodes::EditorContext* mContext;

public:
	WorkflowUI()
	{
		mContext = ImNodes::CreateEditor();
	}

	~WorkflowUI()
	{
		ImNodes::DestroyEditor(mContext);
	}

	void Draw()
	{
		ImNodes::SetCurrentEditor(mContext);
		ImNodes::Begin("");

		for (auto& node : mWorkflow->GetNodes()) {
			if (!node) continue;

			ImNodes::BeginNode(node->GetId());
			node->Draw();
			ImNodes::EndNode();
		}

		for (auto& conn : mWorkflow->GetConnections()) {
			if (!conn.IsValid()) continue;

			// TODO create link
		}

		ImNodes::End();
	}
};
} // namespace

void UI::WorkflowsTab()
{
	static std::unique_ptr<WorkflowUI> openWorkflow;
	// TODO
}