#include "Template.hpp"

#include "Model/GlobalStates.hpp"
#include "Model/Project.hpp"
#include "UI/UI.hpp"
#include "Utils/I18n.hpp"
#include "Utils/UUID.hpp"

#include <imgui.h>
#include <imgui_stdlib.h>
#include <algorithm>
#include <cstdint>
#include <fstream>

using namespace std::literals::string_view_literals;
namespace fs = std::filesystem;

Template::Template(Kind kind)
	: mKind{ kind }
{
}

Template::Kind Template::GetKind() const
{
	return mKind;
}

void TemplateAssetList::DiscoverFiles(const std::function<void(SavedAsset)>& callback) const
{
	auto dir = GetConnectedProject().GetTemplatesDirectory();
	DiscoverFilesByExtension(callback, dir, ".cplt-template"sv);
}

std::string TemplateAssetList::RetrieveNameFromFile(const fs::path& file) const
{
	std::ifstream ifs(file);
	if (!ifs) return "";

	uint64_t len;
	ifs >> len;

	std::string name;
	name.reserve(len);
	std::copy_n(std::istreambuf_iterator(ifs), len, std::back_inserter(name));

	return name;
}

uuids::uuid TemplateAssetList::RetrieveUuidFromFile(const fs::path& file) const
{
	return uuids::uuid::from_string(file.stem().string());
}

fs::path TemplateAssetList::RetrievePathFromAsset(const SavedAsset& asset) const
{
	auto fileName = uuids::to_string(asset.Uuid);
	return GetConnectedProject().GetTemplatePath(fileName);
}

bool TemplateAssetList::SaveInstance(const SavedAsset& assetInfo, const Asset* asset) const
{
	auto path = RetrievePathFromAsset(assetInfo);

	std::ofstream ofs(path, std::ios::binary);
	if (!ofs) return false;
	ofs << (uint64_t)assetInfo.Name.size();
	ofs << assetInfo.Name;
	ofs << static_cast<Template::Kind>(assetInfo.Payload);

	if (auto tmpl = static_cast<const Template*>(asset)) {
		tmpl->WriteTo(ofs);
	}

	return true;
}

static std::unique_ptr<Template> LoadTemplateFromFile(const fs::path& path)
{
	std::ifstream ifs(path, std::ios::binary);
	if (!ifs) return nullptr;

	// TODO fix serialization
	uint64_t nameSize;
	ifs >> nameSize;
	ifs.seekg(nameSize, std::ios::end);

	uint32_t iKind;
	ifs >> iKind;

	auto kind = static_cast<Template::Kind>(iKind);
	auto tmpl = Template::CreateByKind(kind);

	auto res = tmpl->ReadFrom(ifs);
	if (res != Template::RR_Success) {
		return nullptr;
	}

	return tmpl;
}

Template* TemplateAssetList::LoadInstance(const SavedAsset& assetInfo) const
{
	return ::LoadTemplateFromFile(RetrievePathFromAsset(assetInfo)).release();
}

Template* TemplateAssetList::CreateInstance(const SavedAsset& assetInfo) const
{
	auto kind = static_cast<Template::Kind>(assetInfo.Payload);
	return Template::CreateByKind(kind).release();
}

bool TemplateAssetList::RenameInstanceOnDisk(const SavedAsset& assetInfo, std::string_view oldName) const
{
	// Get asset path, which is only dependent on UUID
	auto path = RetrievePathFromAsset(assetInfo);

	auto tmpl = ::LoadTemplateFromFile(path);
	if (!tmpl) return false;

	// Rewrite the asset with the updated name (note the given assetInfo already has the update name)
	SaveInstance(assetInfo, tmpl.get());

	return true;
}

void TemplateAssetList::DisplayAssetCreator(ListState& state)
{
	auto ValidateNewName = [&]() -> void {
		if (mACNewName.empty()) {
			mACNewNameError = NameSelectionError::Empty;
			return;
		}

		if (FindByName(mACNewName)) {
			mACNewNameError = NameSelectionError::Duplicated;
			return;
		}

		mACNewNameError = NameSelectionError::None;
	};

	auto ShowNewNameErrors = [&]() -> void {
		switch (mACNewNameError) {
			case NameSelectionError::None: break;
			case NameSelectionError::Duplicated:
				ImGui::ErrorMessage(I18N_TEXT("Duplicate name", L10N_DUPLICATE_NAME_ERROR));
				break;
			case NameSelectionError::Empty:
				ImGui::ErrorMessage(I18N_TEXT("Name cannot be empty", L10N_EMPTY_NAME_ERROR));
				break;
		}
	};

	auto ShowNewKindErrors = [&]() -> void {
		if (mACNewKind == Template::InvalidKind) {
			ImGui::ErrorMessage(I18N_TEXT("Invalid template type", L10N_TEMPLATE_INVALID_TYPE_ERROR));
		}
	};

	auto IsInputValid = [&]() -> bool {
		return mACNewNameError == NameSelectionError::None &&
			mACNewKind != Template::InvalidKind;
	};

	auto ResetState = [&]() -> void {
		mACNewName.clear();
		mACNewKind = Template::InvalidKind;
		ValidateNewName();
	};

	if (ImGui::InputText(I18N_TEXT("Name", L10N_NAME), &mACNewName)) {
		ValidateNewName();
	}

	if (ImGui::BeginCombo(I18N_TEXT("Type", L10N_TYPE), Template::FormatKind(mACNewKind))) {
		for (int i = 0; i < Template::KindCount; ++i) {
			auto kind = static_cast<Template::Kind>(i);
			if (ImGui::Selectable(Template::FormatKind(kind), mACNewKind == kind)) {
				mACNewKind = kind;
			}
		}
		ImGui::EndCombo();
	}

	ShowNewNameErrors();
	ShowNewKindErrors();

	if (ImGui::Button(I18N_TEXT("OK", L10N_CONFIRM), !IsInputValid())) {
		ImGui::CloseCurrentPopup();

		Create(SavedAsset{
			.Name = mACNewName,
			.Payload = static_cast<uint64_t>(mACNewKind),
		});
		ResetState();
	}
	ImGui::SameLine();
	if (ImGui::Button(I18N_TEXT("Cancel", L10N_CANCEL))) {
		ImGui::CloseCurrentPopup();
	}
}

void TemplateAssetList::DisplayDetailsTable(ListState& state) const
{
	ImGui::BeginTable("AssetDetailsTable", 2, ImGuiTableFlags_Borders);

	ImGui::TableSetupColumn(I18N_TEXT("Name", L10N_NAME));
	ImGui::TableSetupColumn(I18N_TEXT("Type", L10N_TYPE));
	ImGui::TableHeadersRow();

	for (auto& asset : this->GetAssets()) {
		ImGui::TableNextRow();

		ImGui::TableNextColumn();
		if (ImGui::Selectable(asset.Name.c_str(), state.SelectedAsset == &asset, ImGuiSelectableFlags_SpanAllColumns | ImGuiSelectableFlags_DontClosePopups)) {
			state.SelectedAsset = &asset;
		}

		ImGui::TableNextColumn();
		auto kind = static_cast<Template::Kind>(asset.Payload);
		ImGui::TextUnformatted(Template::FormatKind(kind));
	}

	ImGui::EndTable();
}