#include "UI.hpp"

#include "Model/GlobalStates.hpp"
#include "Model/Project.hpp"
#include "Model/Template/TableTemplate.hpp"
#include "Model/Template/TableTemplateIterator.hpp"
#include "Model/Template/Template.hpp"
#include "Utils/I18n.hpp"

#include <IconsFontAwesome.h>
#include <imgui.h>
#include <imgui_extra_math.h>
#include <imgui_internal.h>
#include <imgui_stdlib.h>
#include <charconv>
#include <fstream>
#include <iostream>
#include <utility>

namespace {
class TemplateUI
{
public:
	static std::unique_ptr<TemplateUI> CreateByKind(Template::Kind kind, std::unique_ptr<Template> tmpl);
	static std::unique_ptr<TemplateUI> CreateByKind(Template::Kind kind);

	virtual ~TemplateUI() = default;
	virtual void Display() = 0;
};

// Table template styles
constexpr ImU32 kSingleParamOutline = IM_COL32(255, 255, 0, 255);
constexpr ImU32 kArrayGroupOutline = IM_COL32(255, 0, 0, 255);

class TableTemplateUI : public TemplateUI
{
private:
	std::unique_ptr<TableTemplate> mTable;

	struct UICell
	{
		bool Hovered = false;
		bool Held = false;
		bool Selected = false;
	};
	std::vector<UICell> mUICells;

	struct UIArrayGroup
	{
		ImVec2 Pos;
		ImVec2 Size;
	};
	std::vector<UIArrayGroup> mUIArrayGroups;

	/* Selection range */
	Vec2i mSelectionTL;
	Vec2i mSelectionBR;

	/* Selection states */
	union
	{
		/// "CS" stands for "Constant cell selection States"
		struct
		{
		} mCS{}; // Initialize to this element

		/// "SS" stands for "Singular parameter selection States".
		struct
		{
			bool ErrorDuplicateVarName;
			bool HasLeftAG;
			bool HasRightAG;
		} mSS;

		/// "AS" stands for "Array group parameter selection States".
		struct
		{
			bool ErrorDuplicateVarName;
		} mAS;
	};

	/* Table states */
	bool mDirty = false;
	bool mFirstDraw = true;

public:
	TableTemplateUI(std::unique_ptr<TableTemplate> table)
		: mTable{ std::move(table) }
		, mSelectionTL{ -1, -1 }
		, mSelectionBR{ -1, -1 }
	{
		// TODO debug code
		Resize(6, 5);
	}

	virtual void Display() override
	{
		ImGui::Columns(2);
		if (mFirstDraw) {
			mFirstDraw = false;
			ImGui::SetColumnWidth(0, ImGui::GetWindowWidth() * 0.15f);
		}

		DisplayInspector();
		ImGui::NextColumn();

		DisplayTable();
		ImGui::NextColumn();

		ImGui::Columns(1);
	}

	void Resize(int width, int height)
	{
		mTable->Resize(width, height);
		mUICells.resize(width * height);
		mUIArrayGroups.resize(mTable->GetArrayGroupCount());

		for (size_t i = 0; i < mUIArrayGroups.size(); ++i) {
			auto& ag = mTable->GetArrayGroup(i);
			auto& uag = mUIArrayGroups[i];

			auto itemSpacing = ImGui::GetStyle().ItemSpacing;
			uag.Pos.x = 0;
			for (int x = 0; x < ag.LeftCell; ++x) {
				uag.Pos.x += mTable->GetColumnWidth(x) + itemSpacing.x;
			}
			uag.Pos.y = 0;
			for (int y = 0; y < ag.Row; ++y) {
				uag.Pos.y += mTable->GetRowHeight(y) + itemSpacing.y;
			}

			uag.Size.x = mTable->GetRowHeight(ag.Row);
			uag.Size.y = 0;
			for (int x = ag.LeftCell; x <= ag.RightCell; ++x) {
				uag.Size.y += mTable->GetColumnWidth(x);
			}
		}
	}

private:
	void DisplayInspector()
	{
		bool openedDummy = true;

		// This is an id, no need to localize
		if (ImGui::BeginTabBar("Inspector")) {
			if (ImGui::BeginTabItem(I18N_TEXT("Cell", L10N_TABLE_CELL))) {
				if (!IsSelected()) {
					ImGui::Text(I18N_TEXT("Select a cell to edit", L10N_TABLE_CELL_SELECT_MSG));
				} else if (mSelectionTL == mSelectionBR) {
					auto& selectCell = mTable->GetCell(mSelectionTL);
					DisplayCellProperties(mSelectionTL);
				} else {
					DisplayRangeProperties(mSelectionTL, mSelectionBR);
				}
				ImGui::EndTabItem();
			}

			if (ImGui::BeginTabItem(I18N_TEXT("Table", L10N_TABLE))) {
				// Table properties
				if (ImGui::Button(I18N_TEXT("Configure table properties...", L10N_TABLE_CONFIGURE_PROPERTIES))) {
					// Act as if ImGui::OpenPopup is executed in the previous id stack frame (tab bar level)
					// Note: we can't simply use ImGui::GetItemID() here, because that would return the id of the ImGui::Button
					auto tabBar = ImGui::GetCurrentContext()->CurrentTabBar;
					auto id = tabBar->Tabs[tabBar->LastTabItemIdx].ID;
					ImGui::PopID();
					ImGui::OpenPopup(I18N_TEXT("Table properties", L10N_TABLE_PROPERTIES));
					ImGui::PushOverrideID(id);
				}

				// Table contents
				DisplayTableContents();

				ImGui::EndTabItem();
			}
			if (ImGui::BeginPopupModal(I18N_TEXT("Table properties", L10N_TABLE_PROPERTIES), &openedDummy, ImGuiWindowFlags_AlwaysAutoResize)) {
				DisplayTableProperties();
				ImGui::EndPopup();
			}

			ImGui::EndTabBar();
		}
	}

	static char NthUppercaseLetter(int n)
	{
		return (char)((int)'A' + n);
	}

	static void ExcelRow(int row, char* bufferBegin, char* bufferEnd)
	{
		auto res = std::to_chars(bufferBegin, bufferEnd, row);
		if (res.ec != std::errc()) {
			return;
		}
	}

	static char* ExcelColumn(int column, char* bufferBegin, char* bufferEnd)
	{
		// https://stackoverflow.com/a/182924/11323702

		int dividend = column;
		int modulo;

		char* lastChar = bufferEnd - 1;
		*lastChar = '\0';
		char* writeHead = lastChar - 1;

		while (dividend > 0) {
			if (writeHead < bufferBegin) {
				return nullptr;
			}

			modulo = (dividend - 1) % 26;

			*writeHead = NthUppercaseLetter(modulo);
			--writeHead;

			dividend = (dividend - modulo) / 26;
		}

		// `writeHead` at this point would be a one-past-the-bufferEnd reverse iterator (i.e. one-past-the-(text)beginning in the bufferBegin)
		// add 1 to get to the actual beginning of the text
		return writeHead + 1;
	}

	void DisplayCellProperties(Vec2i pos)
	{
		auto& cell = mTable->GetCell(pos);
		auto& uiCell = mUICells[pos.y * mTable->GetTableWidth() + pos.x];

		char colStr[8]; // 2147483647 -> FXSHRXW, len == 7, along with \0
		char* colBegin = ExcelColumn(pos.x + 1, std::begin(colStr), std::end(colStr));
		char rowStr[11]; // len(2147483647) == 10, along with \0
		ExcelRow(pos.y + 1, std::begin(rowStr), std::end(rowStr));
		ImGui::Text(I18N_TEXT("Location: %s%s", L10N_TABLE_CELL_POS), colBegin, rowStr);

		switch (cell.Type)
		{
			case TableCell::ConstantCell:
				ImGui::Text(I18N_TEXT("Type: Constant", L10N_TABLE_CELL_TYPE_CONST));
				break;
			case TableCell::SingularParametricCell:
				ImGui::Text(I18N_TEXT("Type: Single parameter", L10N_TABLE_CELL_TYPE_PARAM));
				break;
			case TableCell::ArrayParametricCell:
				ImGui::Text(I18N_TEXT("Type: Array group", L10N_TABLE_CELL_TYPE_CREATE_AG));
				break;
		}

		if (ImGui::Button(I18N_TEXT("Convert to...", L10N_TABLE_CELL_CONV))) {
			ImGui::OpenPopup("ConvertCtxMenu");
		}
		if (ImGui::BeginPopup("ConvertCtxMenu")) {
			bool constantDisabled = cell.Type == TableCell::ConstantCell;
			if (ImGui::MenuItem(I18N_TEXT("Convert to regular cell", L10N_TABLE_CELL_CONV_CONST), nullptr, false, !constantDisabled)) {
				mTable->SetCellType(pos, TableCell::ConstantCell);
			}

			bool singleDisabled = cell.Type == TableCell::SingularParametricCell;
			if (ImGui::MenuItem(I18N_TEXT("Convert to parameter cell", L10N_TABLE_CELL_CONV_PARAM), nullptr, false, !singleDisabled)) {
				mTable->SetCellType(pos, TableCell::SingularParametricCell);
			}

			bool arrayDisabled = cell.Type == TableCell::ArrayParametricCell;
			if (ImGui::MenuItem(I18N_TEXT("Add to a new array group", L10N_TABLE_CELL_CONV_CREATE_AG), nullptr, false, !arrayDisabled)) {
				mTable->AddArrayGroup(pos.x, pos.x, pos.y);
			}

			bool leftDisabled = !mSS.HasLeftAG || arrayDisabled;
			if (ImGui::MenuItem(I18N_TEXT("Add to the array group to the left", L10N_TABLE_CELL_CONV_ADD_AG_LEFT), nullptr, false, !leftDisabled)) {
				auto& leftCell = mTable->GetCell((Vec2i){ pos.x - 1, pos.y });
				mTable->ExtendArrayGroupRight(leftCell.DataId, 1);
			}

			bool rightDisabled = !mSS.HasRightAG || arrayDisabled;
			if (ImGui::MenuItem(I18N_TEXT("Add to the array group to the right", L10N_TABLE_CELL_CONV_ADD_AG_RIGHT), nullptr, false, !rightDisabled)) {
				auto& rightCell = mTable->GetCell((Vec2i){ pos.x + 1, pos.y });
				mTable->ExtendArrayGroupLeft(rightCell.DataId, 1);
			}

			ImGui::EndPopup();
		}

		ImGui::Spacing();

		constexpr auto kLeft = I18N_TEXT("Left", L10N_TABLE_CELL_ALIGN_LEFT);
		constexpr auto kCenter = I18N_TEXT("Center", L10N_TABLE_CELL_ALIGN_CENTER);
		constexpr auto kRight = I18N_TEXT("Right", L10N_TABLE_CELL_ALIGN_RIGHT);

		const char* horizontalText;
		switch (cell.HorizontalAlignment) {
			case TableCell::AlignAxisMin: horizontalText = kLeft; break;
			case TableCell::AlignCenter: horizontalText = kCenter; break;
			case TableCell::AlignAxisMax: horizontalText = kRight; break;
		}

		if (ImGui::BeginCombo(I18N_TEXT("Horizontal alignment", L10N_TABLE_CELL_HORIZONTAL_ALIGNMENT), horizontalText)) {
			if (ImGui::Selectable(kLeft, cell.HorizontalAlignment == TableCell::AlignAxisMin)) {
				cell.HorizontalAlignment = TableCell::AlignAxisMin;
			}
			if (ImGui::Selectable(kCenter, cell.HorizontalAlignment == TableCell::AlignCenter)) {
				cell.HorizontalAlignment = TableCell::AlignCenter;
			}
			if (ImGui::Selectable(kRight, cell.HorizontalAlignment == TableCell::AlignAxisMax)) {
				cell.HorizontalAlignment = TableCell::AlignAxisMax;
			}
			ImGui::EndCombo();
		}

		constexpr auto kTop = I18N_TEXT("Left", L10N_TABLE_CELL_ALIGN_TOP);
		constexpr auto kMiddle = I18N_TEXT("Middle", L10N_TABLE_CELL_ALIGN_MIDDLE);
		constexpr auto kBottom = I18N_TEXT("Right", L10N_TABLE_CELL_ALIGN_BOTTOM);

		const char* verticalText;
		switch (cell.VerticalAlignment) {
			case TableCell::AlignAxisMin: verticalText = kTop; break;
			case TableCell::AlignCenter: verticalText = kMiddle; break;
			case TableCell::AlignAxisMax: verticalText = kBottom; break;
		}

		if (ImGui::BeginCombo(I18N_TEXT("Vertical alignment", L10N_TABLE_CELL_VERTICAL_ALIGNMENT), verticalText)) {
			if (ImGui::Selectable(kTop, cell.VerticalAlignment == TableCell::AlignAxisMin)) {
				cell.VerticalAlignment = TableCell::AlignAxisMin;
			}
			if (ImGui::Selectable(kMiddle, cell.VerticalAlignment == TableCell::AlignCenter)) {
				cell.VerticalAlignment = TableCell::AlignCenter;
			}
			if (ImGui::Selectable(kBottom, cell.VerticalAlignment == TableCell::AlignAxisMax)) {
				cell.VerticalAlignment = TableCell::AlignAxisMax;
			}
			ImGui::EndCombo();
		}

		switch (cell.Type) {
			case TableCell::ConstantCell:
				ImGui::InputText(I18N_TEXT("Content", L10N_TABLE_CELL_CONTENT), &cell.Content);
				break;

			case TableCell::SingularParametricCell:
				if (ImGui::InputText(I18N_TEXT("Variable name", L10N_TABLE_CELL_VAR_NAME), &cell.Content)) {
					auto c = mTable->FindCell(cell.Content);
					mSS.ErrorDuplicateVarName = c != nullptr;
				}
				if (ImGui::IsItemHovered()) {
					ImGui::SetTooltip(I18N_TEXT("Name of the parameter link to this cell.", L10N_TABLE_CELL_VAR_TOOLTIP));
				}

				if (mSS.ErrorDuplicateVarName) {
					ImGui::ErrorMessage(I18N_TEXT("Variable name duplicated.", L10N_TABLE_CELL_VAR_NAME_DUP));
				}
				break;

			case TableCell::ArrayParametricCell:
				if (ImGui::InputText(I18N_TEXT("Variable name", L10N_TABLE_CELL_VAR_NAME), &cell.Content)) {
					auto ag = mTable->GetArrayGroup(cell.DataId);
					auto cl = ag.FindCell(cell.Content);
					mAS.ErrorDuplicateVarName = cl.x != -1 && cl.y != -1;
				}
				if (ImGui::IsItemHovered()) {
					ImGui::SetTooltip(I18N_TEXT("Name of the parameter lnk to this cell; local within the array group.", L10N_TABLE_CELL_ARRAY_VAR_TOOLTIP));
				}

				if (mAS.ErrorDuplicateVarName) {
					ImGui::ErrorMessage(I18N_TEXT("Variable name duplicated.", L10N_TABLE_CELL_VAR_NAME_DUP));
				}
				break;
		}
	}

	void DisplayRangeProperties(Vec2i tl, Vec2i br)
	{
		// TODO
	}

	void DisplayTableContents()
	{
		if (ImGui::TreeNode(ICON_FA_BONG " " I18N_TEXT("Parameters", L10N_TABLE_SINGLE_PARAMS))) {
			TableSingleParamsIter iter(*mTable);
			while (iter.HasNext()) {
				auto& cell = iter.Next();
				if (ImGui::Selectable(cell.Content.c_str())) {
					SelectCell(cell.Location);
				}
			}
			ImGui::TreePop();
		}
		if (ImGui::TreeNode(ICON_FA_LIST " " I18N_TEXT("Array groups", L10N_TABLE_ARRAY_GROUPS))) {
			TableArrayGroupsIter iter(*mTable);
			// For each array group
			while (iter.HasNext()) {
				if (ImGui::TreeNode(iter.PeekNameCStr())) {
					auto& ag = iter.Peek();
					// For each cell in the array group
					for (int x = ag.LeftCell; x <= ag.RightCell; ++x) {
						Vec2i pos{ x, ag.Row };
						auto& cell = mTable->GetCell(pos);
						if (ImGui::Selectable(cell.Content.c_str())) {
							SelectCell(pos);
						}
					}
					ImGui::TreePop();
				}
				iter.Next();
			}
			ImGui::TreePop();
		}
	}

	void DisplayTableProperties()
	{
		// TODO
	}

	void DisplayTable()
	{
		ImGui::PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(8, 8));
		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(8, 8));
		ImGui::BeginChild("TableTemplate");

		auto regularColor = ImGui::GetColorU32(ImGuiCol_Button);
		auto hoveredColor = ImGui::GetColorU32(ImGuiCol_ButtonHovered);
		auto activeColor = ImGui::GetColorU32(ImGuiCol_ButtonActive);
		auto navHighlight = ImGui::GetColorU32(ImGuiCol_NavHighlight);

		int colCount = mTable->GetTableWidth();
		int rowCount = mTable->GetTableHeight();
		for (int rowIdx = 0; rowIdx < rowCount; ++rowIdx) {
			int rowHeight = mTable->GetRowHeight(rowIdx);

			for (int colIdx = 0; colIdx < colCount; ++colIdx) {
				int colWidth = mTable->GetColumnWidth(colIdx);

				int i = rowIdx * colCount + colIdx;
				auto window = ImGui::GetCurrentWindow();
				auto id = window->GetID(i);

				Vec2i cellLoc{ colIdx, rowIdx };
				auto& cell = mTable->GetCell(cellLoc);
				auto& uiCell = mUICells[i];

				ImVec2 size(colWidth, rowHeight);
				ImRect rect{
					window->DC.CursorPos,
					window->DC.CursorPos + ImGui::CalcItemSize(size, 0.0f, 0.0f),
				};

				/* Draw cell body */

				if (uiCell.Selected) {
					window->DrawList->AddRectFilled(
						rect.Min - ImVec2(2, 1),
						rect.Max + ImVec2(2, 1),
						navHighlight);
				} else {
					ImU32 color;
					if (uiCell.Held) {
						color = activeColor;
					} else if (uiCell.Hovered) {
						color = hoveredColor;
					} else {
						color = regularColor;
					}
					window->DrawList->AddRectFilled(rect.Min, rect.Max, color);
				}

				/* Draw cell type indicator */
				switch (cell.Type) {
					// No indicator
					case TableCell::ConstantCell: break;

					case TableCell::SingularParametricCell:
						window->DrawList->AddRect(
							rect.Min - ImVec2(1, 1),
							rect.Max + ImVec2(1, 1),
							kSingleParamOutline);
						break;

					// Drawn separately in loop below
					case TableCell::ArrayParametricCell: break;
				}

				/* Draw cell content */

				auto content = cell.Content.c_str();
				auto contentEnd = content + cell.Content.size();
				auto textSize = ImGui::CalcTextSize(content, contentEnd);

				ImVec2 textRenderPos;
				switch (cell.HorizontalAlignment) {
					case TableCell::AlignAxisMin: textRenderPos.x = rect.Min.x; break;
					case TableCell::AlignCenter: textRenderPos.x = rect.Min.x + colWidth / 2 - textSize.x / 2; break;
					case TableCell::AlignAxisMax: textRenderPos.x = rect.Max.x - textSize.x; break;
				}
				switch (cell.VerticalAlignment) {
					case TableCell::AlignAxisMin: textRenderPos.y = rect.Min.y; break;
					case TableCell::AlignCenter: textRenderPos.y = rect.Min.y + rowHeight / 2 - textSize.y / 2; break;
					case TableCell::AlignAxisMax: textRenderPos.y = rect.Max.y - textSize.y; break;
				}
				window->DrawList->AddText(textRenderPos, IM_COL32(0, 0, 0, 255), content, contentEnd);

				/* Update ImGui cursor */

				ImGui::ItemSize(size);
				if (!ImGui::ItemAdd(rect, id)) {
					continue;
				}

				if (ImGui::ButtonBehavior(rect, id, &uiCell.Hovered, &uiCell.Held)) {
					if (ImGui::GetIO().KeyShift && IsSelected()) {
						SelectRange(mSelectionTL, { colIdx, rowIdx });
					} else {
						SelectCell({ colIdx, rowIdx });
					}
				}

				// Don't SameLine() if we are on the last cell in the row
				if (colIdx != colCount - 1) {
					ImGui::SameLine();
				}
			}
		}

		for (auto& uag : mUIArrayGroups) {
			ImGui::GetCurrentWindow()->DrawList->AddRect(
				uag.Pos - ImVec2(1, 1),
				uag.Pos + uag.Size + ImVec2(1, 1),
				kArrayGroupOutline);
		}

		ImGui::EndChild();
		ImGui::PopStyleVar(2);
	}

	template <class TFunction>
	void ForeachSelectedCell(const TFunction& func)
	{
		for (int y = mSelectionTL.y; y <= mSelectionBR.y; ++y) {
			for (int x = mSelectionTL.x; x <= mSelectionBR.x; ++x) {
				int i = y * mTable->GetTableWidth() + x;
				func(i, x, y);
			}
		}
	}

	bool IsSelected() const
	{
		return mSelectionTL.x != -1;
	}

	void ClearSelection()
	{
		if (IsSelected()) {
			ForeachSelectedCell([this](int i, int, int) {
				auto& uiCell = mUICells[i];
				uiCell.Selected = false;
			});
		}

		mSelectionTL = { -1, -1 };
		mSelectionBR = { -1, -1 };

		ResetCS();
	}

	void ResetCS()
	{
		mCS = {};
	}

	void SelectRange(Vec2i p1, Vec2i p2)
	{
		ClearSelection();

		if (p2.x < p1.x) {
			std::swap(p2.x, p1.x);
		}
		if (p2.y < p1.y) {
			std::swap(p2.y, p1.y);
		}

		mSelectionTL = p1;
		mSelectionBR = p2;

		ForeachSelectedCell([this](int i, int, int) {
			auto& uiCell = mUICells[i];
			uiCell.Selected = true;
		});

		ResetAS();
	}

	void ResetSS(Vec2i pos)
	{
		mSS = {};
		mSS.ErrorDuplicateVarName = false;
		mSS.HasLeftAG = pos.x > 1 && mTable->GetCell({ pos.x - 1, pos.y }).Type == TableCell::ArrayParametricCell;
		mSS.HasRightAG = pos.x < mTable->GetTableWidth() - 1 && mTable->GetCell({ pos.x + 1, pos.y }).Type == TableCell::ArrayParametricCell;
	}

	void SelectCell(Vec2i cell)
	{
		ClearSelection();

		mSelectionTL = cell;
		mSelectionBR = cell;

		int i = cell.y * mTable->GetTableWidth() + cell.x;
		mUICells[i].Selected = true;

		ResetSS(cell);
	}

	void ResetAS()
	{
		mAS = {};
		mAS.ErrorDuplicateVarName = false;
	}
};

std::unique_ptr<TemplateUI> TemplateUI::CreateByKind(Template::Kind kind, std::unique_ptr<Template> tmpl)
{
#pragma push_macro("UNIQUE_CAST")
#undef UNIQUE_CAST
#define UNIQUE_CAST(TargetType, input) std::unique_ptr<TargetType>(static_cast<TargetType*>(input.release()))
	switch (kind) {
		case Template::KD_Table: return std::make_unique<TableTemplateUI>(UNIQUE_CAST(TableTemplate, tmpl));
		case Template::InvalidKind: return nullptr;
	}
#pragma pop_macro("UNIQUE_CAST")
}

std::unique_ptr<TemplateUI> TemplateUI::CreateByKind(Template::Kind kind)
{
	switch (kind) {
		case Template::KD_Table: return std::make_unique<TableTemplateUI>(std::make_unique<TableTemplate>());
		case Template::InvalidKind: return nullptr;
	}
}
} // namespace

void UI::TemplatesTab()
{
	auto& project = *GlobalStates::GetInstance().GetCurrentProject();

	static std::unique_ptr<TemplateUI> openTemplate;
	static AssetList::ListState state;
	bool openedDummy = true;

	// Toolbar item: close
	if (ImGui::Button(ICON_FA_TIMES " " I18N_TEXT("Close", L10N_CLOSE), openTemplate == nullptr)) {
		openTemplate = nullptr;
	}

	// Toolbar item: open...
	ImGui::SameLine();
	if (ImGui::Button(I18N_TEXT("Open asset...", L10N_ASSET_OPEN))) {
		ImGui::OpenPopup(I18N_TEXT("Open asset", L10N_ASSET_OPEN_DIALOG_TITLE));
	}
	if (ImGui::BeginPopupModal(I18N_TEXT("Open asset", L10N_ASSET_OPEN_DIALOG_TITLE), &openedDummy, ImGuiWindowFlags_AlwaysAutoResize)) {
		if (ImGui::Button(ICON_FA_FOLDER_OPEN " " I18N_TEXT("Open", L10N_OPEN), state.SelectedAsset == nullptr)) {
			ImGui::CloseCurrentPopup();
			auto kind = static_cast<Template::Kind>(state.SelectedAsset->Payload);
			openTemplate = TemplateUI::CreateByKind(kind);
		}
		ImGui::SameLine();
		project.Templates.DisplayControls(state);
		project.Templates.DisplayDetailsList(state);

		ImGui::EndPopup();
	}

	// Toolbar item: manage...
	ImGui::SameLine();
	if (ImGui::Button(I18N_TEXT("Manage assets...", L10N_ASSET_MANAGE))) {
		ImGui::OpenPopup(I18N_TEXT("Manage assets", L10N_ASSET_MANAGE_DIALOG_TITLE));
	}
	if (ImGui::BeginPopupModal(I18N_TEXT("Manage assets", L10N_ASSET_MANAGE_DIALOG_TITLE), &openedDummy, ImGuiWindowFlags_AlwaysAutoResize)) {
		project.Templates.DisplayControls(state);
		project.Templates.DisplayDetailsList(state);
		ImGui::EndPopup();
	}

	if (openTemplate) {
		openTemplate->Display();
	}
}