#include "MenuManager.h"
#include "render/TextRenderer.h"
#include <iostream>
#include <algorithm>
#include <string>

namespace ZL {

	static int questStatusPriority(Quest::QuestStatus status) {
		switch (status) {
		case Quest::QuestStatus::Active:    return 0;
		case Quest::QuestStatus::Available: return 1;
		case Quest::QuestStatus::Completed: return 2;
		case Quest::QuestStatus::Failed:    return 3;
		default:                            return 4;
		}
	}

	static int countWrappedLines(const std::string& text, const TextRenderer& tr, float maxWidth) {
		if (text.empty()) return 1;
		int lines = 0;
		std::string currentLine;

		auto flushLine = [&]() { ++lines; currentLine.clear(); };

		auto pushWord = [&](const std::string& word) {
			if (word.empty()) return;
			if (currentLine.empty()) {
				currentLine = word;
			} else {
				const std::string candidate = currentLine + " " + word;
				if (tr.measureTextWidth(candidate) <= maxWidth) {
					currentLine = candidate;
				} else {
					flushLine();
					currentLine = word;
				}
			}
		};

		std::string currentWord;
		for (char ch : text) {
			if (ch == '\n') {
				pushWord(currentWord); currentWord.clear(); flushLine();
			} else if (ch == ' ' || ch == '\t' || ch == '\r') {
				pushWord(currentWord); currentWord.clear();
			} else {
				currentWord.push_back(ch);
			}
		}
		pushWord(currentWord);
		if (!currentLine.empty()) flushLine();

		return max(1, lines);
	}

	static std::array<float, 4> questStatusColor(Quest::QuestStatus status) {
		switch (status) {
		case Quest::QuestStatus::Completed: return { 0.25f, 0.95f, 0.35f, 1.0f };
		case Quest::QuestStatus::Failed:    return { 1.0f,  0.25f, 0.25f, 1.0f };
		case Quest::QuestStatus::Active:    return { 1.0f,  1.0f,  1.0f,  1.0f };
		case Quest::QuestStatus::Available: return { 0.86f, 0.86f, 0.86f, 1.0f };
		default:                            return { 0.45f, 0.45f, 0.45f, 1.0f };
		}
	}

	MenuManager::MenuManager(Renderer& iRenderer) :
		renderer(iRenderer)
	{
	}

	void MenuManager::setup(Inventory& inv, const std::string& zipFile) {
		inventory = &inv;

		//hudRoot          = loadUiFromFile("resources/config2/hud.json",               renderer, zipFile);
		hudRoot       = loadUiFromFile("resources/w/ui/hud_step0.json",   renderer, zipFile);
		hudStep1Root  = loadUiFromFile("resources/w/ui/hud_step1.json",  renderer, zipFile);
		hudStep2Root  = loadUiFromFile("resources/w/ui/hud_step2.json",  renderer, zipFile);
		hudStep3Root  = loadUiFromFile("resources/w/ui/hud_step3.json",  renderer, zipFile);
		hudStep4Root  = loadUiFromFile("resources/w/ui/hud_step4.json",  renderer, zipFile);
		hudStep5aRoot = loadUiFromFile("resources/w/ui/hud_step5a.json", renderer, zipFile);
		hudStep5bRoot = loadUiFromFile("resources/w/ui/hud_step5b.json", renderer, zipFile);
		hudStep5abRoot   = loadUiFromFile("resources/w/ui/hud_step5ab.json",   renderer, zipFile);
		//phoneScreenRoot  = loadUiFromFile("resources/w/ui/screen_phone_chat_list.json",    renderer, zipFile);
		phoneScreenRoot = loadUiFromFile("resources/w/ui/screen_phone_chat.json", renderer, zipFile);
		newInventoryRoot = loadUiFromFile("resources/w/ui/screen_inventory.json", renderer, zipFile);
		questJournalRoot = loadUiFromFile("resources/w/ui/screen_journal.json",   renderer, zipFile);

		texObjectiveCompleted_ = renderer.textureManager.LoadFromPng("resources/w/ui/img/journal/quest_objective_completed.png", zipFile, true);
		texObjectiveBlank_     = renderer.textureManager.LoadFromPng("resources/w/ui/img/journal/quest_objective_blank.png",     zipFile, true);
		texItemSelected_       = renderer.textureManager.LoadFromPng("resources/w/ui/img/journal/ButtonBkg001.png",              zipFile, true);
		texItemTransparent_    = renderer.textureManager.LoadFromPng("resources/w/ui/img/journal/ButtonBkgTransparent001.png",   zipFile, true);

		questJournal.loadFromFile("resources/quests/quests.json", zipFile);

		enterGameplay();
	}

	void MenuManager::enterGameplay() {
		state = GameState::Gameplay;
		uiManager.replaceRoot(hudRoot);
		/*
		uiManager.setTextButtonCallback("inventory_button", [this](const std::string&) {
			openInventory();
			});

		uiManager.setTextButtonCallback("quest_journal_button", [this](const std::string&) {
			openQuestJournal();
			});*/

		uiManager.setButtonCallback("inventoryButton", [this](const std::string&) {
			openInventory();
			});
		//openInventory()
	}

	void MenuManager::openInventory() {
		state = GameState::Inventory;
		uiManager.pushMenuFromSavedRoot(newInventoryRoot);
		uiManager.setButtonCallback("inventoryExitButton", [this](const std::string&) {
			closeInventory();
			});
		/*
		uiManager.pushMenuFromSavedRoot(inventoryRoot);

		uiManager.setTextButtonCallback("close_inventory_button", [this](const std::string&) {
			closeInventory();
			});

		const auto& items = inventory->getItems();
		std::string itemText;
		if (items.empty()) {
			itemText = "Inventory (Empty)";
		}
		else {
			itemText = "Inventory (" + std::to_string(items.size()) + " items)\n\n";
			for (size_t i = 0; i < items.size(); ++i) {
				itemText += std::to_string(i + 1) + ". " + items[i].name + "\n";
			}
		}
		uiManager.setText("inventory_items_text", itemText);*/
	}

	void MenuManager::closeInventory() {
		state = GameState::Gameplay;
		uiManager.popMenu();
	}

	void MenuManager::openQuestJournal() {
		state = GameState::QuestJournal;
		tutorialJournalScreenOpened = true;
		uiManager.setNodeVisible("hint6b", false);
		uiManager.pushMenuFromSavedRoot(questJournalRoot);

		uiManager.setButtonCallback("journalExitButton", [this](const std::string&) {
			closeQuestJournal();
		});

		static const char* kItemNames[9] = {
			"item1name","item2name","item3name",
			"item4name","item5name","item6name",
			"item7name","item8name","item9name"
		};
		for (int i = 0; i < 9; ++i) {
			uiManager.setTextButtonCallback(kItemNames[i], [this, i](const std::string&) {
				selectQuestByIndex(i);
			});
		}

		refreshQuestJournalUi();
		if (!visibleQuestIds.empty()) {
			selectQuestByIndex(0);
		}
	}

	void MenuManager::closeQuestJournal() {
		state = GameState::Gameplay;
		selectedQuestIndex = -1;
		visibleQuestIds.clear();
		uiManager.popMenu();
	}

	void MenuManager::toggleQuestJournal() {
		std::cout << "[quest] toggleQuestJournal: " << (isQuestJournalOpen() ? "closing" : "opening") << std::endl;
		if (state == GameState::QuestJournal) {
			closeQuestJournal();
		}
		else {
			if (state == GameState::Inventory) {
				closeInventory();
			}
			openQuestJournal();
		}
	}

	void MenuManager::openPhoneScreen() {
		state = GameState::PhoneScreen;
		tutorialPhoneScreenOpened = true;
		// Hide the phone hint on the current HUD so it stays hidden when we return.
		uiManager.setNodeVisible("hint6a", false);
		uiManager.pushMenuFromSavedRoot(phoneScreenRoot);
		uiManager.setButtonCallback("phoneExitButton", [this](const std::string&) {
			closePhoneScreen();
		});
		uiManager.setButtonCallback("phoneMain", [this](const std::string&) {
			//Keep the callback
			});
		uiManager.setTextButtonCallback("chat1button", [this](const std::string&) {
			std::cout << "Hello test " << std::endl;

			});
	}

	void MenuManager::closePhoneScreen() {
		state = GameState::Gameplay;
		uiManager.popMenu();
	}

	// Registers phoneButton / journalButton callbacks on the current HUD root
	// and hides any hints that have already been completed.
	// Called after every replaceRoot during step 5.
	void MenuManager::setupStep5Callbacks() {
		if (uiManager.findButton("phoneButton")) {
			uiManager.setButtonCallback("phoneButton", [this](const std::string&) {
				openPhoneScreen();
			});
		}
		if (uiManager.findButton("journalButton")) {
			uiManager.setButtonCallback("journalButton", [this](const std::string&) {
				openQuestJournal();
			});
		}
		if (tutorialPhoneScreenOpened)  uiManager.setNodeVisible("hint6a", false);
		if (tutorialJournalScreenOpened) uiManager.setNodeVisible("hint6b", false);
	}

	void MenuManager::advanceTutorialStep() {
		std::shared_ptr<UiNode> nextRoot;

		switch (tutorialStep) {
		case TutorialStep::Step0:
			tutorialStep = TutorialStep::Step1;
			nextRoot = hudStep1Root;
			break;
		case TutorialStep::Step1:
			tutorialStep = TutorialStep::Step2;
			nextRoot = hudStep2Root;
			break;
		case TutorialStep::Step2:
			tutorialStep = TutorialStep::Step3;
			nextRoot = hudStep3Root;
			break;
		case TutorialStep::Step3:
			tutorialStep = TutorialStep::Step4;
			nextRoot = hudStep4Root;
			break;
		default:
			return; // Step4/Step5 transitions are driven by onItemPickedUp
		}

		if (state == GameState::Gameplay && nextRoot) {
			uiManager.replaceRoot(nextRoot);

			uiManager.setButtonCallback("inventoryButton", [this](const std::string&) {
				openInventory();
				});
		}
	}

	void MenuManager::onItemPickedUp(const std::string& itemId) {
		if (tutorialStep != TutorialStep::Step4 && tutorialStep != TutorialStep::Step5) {
			return;
		}

		if (itemId == "phone")   tutorialPhonePickedUp   = true;
		if (itemId == "journal") tutorialJournalPickedUp = true;

		if (tutorialStep == TutorialStep::Step4) {
			tutorialStep = TutorialStep::Step5;
		}

		refreshItemPickupHud();
	}

	void MenuManager::refreshItemPickupHud() {
		if (state != GameState::Gameplay) return;

		std::shared_ptr<UiNode> nextRoot;
		if (tutorialPhonePickedUp && tutorialJournalPickedUp) {
			nextRoot = hudStep5abRoot;
		} else if (tutorialPhonePickedUp) {
			nextRoot = hudStep5aRoot;
		} else if (tutorialJournalPickedUp) {
			nextRoot = hudStep5bRoot;
		}

		if (nextRoot) {
			uiManager.replaceRoot(nextRoot);
			// Register item-screen buttons and re-apply any already-completed hint visibility.
			setupStep5Callbacks();
		}
	}

	void MenuManager::refreshQuestJournalUi() {
		visibleQuestIds.clear();
		auto quests = questJournal.getVisibleQuests();

		std::sort(quests.begin(), quests.end(), [](const Quest::QuestState* a, const Quest::QuestState* b) {
			const int pa = questStatusPriority(a->status);
			const int pb = questStatusPriority(b->status);
			if (pa != pb) return pa < pb;
			return a->orderIndex > b->orderIndex;
		});

		static const char* kItemNames[9] = {
			"item1name","item2name","item3name",
			"item4name","item5name","item6name",
			"item7name","item8name","item9name"
		};

		for (int i = 0; i < 9; ++i) {
			if (i < static_cast<int>(quests.size())) {
				const auto* quest = quests[i];
				visibleQuestIds.push_back(quest->definition.id);

				const bool selected = (i == selectedQuestIndex);

				std::array<float, 4> color;
				if (selected) {
					color = { 0.996f, 0.977f, 0.761f, 1.0f };
				} else if (quest->status == Quest::QuestStatus::Completed) {
					color = { 0.02f, 0.875f, 0.447f, 0.6f };
				} else if (quest->status == Quest::QuestStatus::Failed) {
					color = { 1.0f, 0.25f, 0.25f, 0.6f };
				} else {
					color = { 0.996f, 0.977f, 0.761f, 0.7f };
				}

				auto tb = uiManager.findTextButton(kItemNames[i]);
				if (tb) {
					auto tex = selected ? texItemSelected_ : texItemTransparent_;
					tb->texNormal = tb->texHover = tb->texPressed = tex;
				}
				uiManager.setTextButtonText(kItemNames[i], quest->definition.title);
				uiManager.setTextButtonColor(kItemNames[i], color);
				uiManager.setNodeVisible(kItemNames[i], true);

				auto node = uiManager.findNode(kItemNames[i]);
				if (node && tb && tb->textRenderer) {
					const float availW = node->width - 2.0f * tb->textPaddingX;
					const int numLines = countWrappedLines(quest->definition.title, *tb->textRenderer, availW);
					node->height = numLines * 30.0f + 30.0f;
				}
			} else {
				uiManager.setTextButtonText(kItemNames[i], "");
				uiManager.setNodeVisible(kItemNames[i], false);

				auto node = uiManager.findNode(kItemNames[i]);
				if (node) node->height = 60.0f;
			}
		}

		uiManager.updateAllLayouts();
	}

	void MenuManager::selectQuestByIndex(int index) {
		if (index < 0 || index >= static_cast<int>(visibleQuestIds.size())) {
			return;
		}

		selectedQuestIndex = index;
		Quest::QuestState* quest = questJournal.findQuest(visibleQuestIds[index]);
		if (!quest) {
			return;
		}

		const auto& def = quest->definition;

		uiManager.setText("quest_title", def.title);

		static const char* kCheckboxes[3] = { "objective1checkbox", "objective2checkbox", "objective3checkbox" };
		static const char* kObjNames[3]   = { "objective1name",     "objective2name",     "objective3name"     };

		for (int i = 0; i < 3; ++i) {
			if (i < static_cast<int>(def.objectives.size())) {
				const auto& obj = def.objectives[i];
				const bool isActive = (i == quest->activeObjectiveIndex);

				auto img = uiManager.findStaticImage(kCheckboxes[i]);
				if (img) img->texture = obj.completed ? texObjectiveCompleted_ : texObjectiveBlank_;

				std::array<float, 4> color;
				if (obj.completed) {
					color = { 0.02f, 0.875f, 0.447f, 0.6f };
				} else if (isActive) {
					color = { 0.996f, 0.977f, 0.761f, 1.0f };
				} else {
					color = { 0.996f, 0.977f, 0.761f, 0.9f };
				}
				uiManager.setText(kObjNames[i], obj.text);
				uiManager.setTextColor(kObjNames[i], color);
				uiManager.setNodeVisible(kCheckboxes[i], true);
				uiManager.setNodeVisible(kObjNames[i], true);
			} else {
				uiManager.setNodeVisible(kCheckboxes[i], false);
				uiManager.setNodeVisible(kObjNames[i], false);
			}
		}

		uiManager.setText("quest_description", def.description);

		refreshQuestJournalUi();
	}

} // namespace ZL