#pragma region License
/*
License (OLC-3)
~~~~~~~~~~~~~~~

Copyright 2024 Joshua Sigona <sigonasr2@gmail.com>

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions or derivations of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

2. Redistributions or derivative works in binary form must reproduce the above
copyright notice. This list of conditions and the following	disclaimer must be
reproduced in the documentation and/or other materials provided with the distribution.

3. Neither the name of the copyright holder nor the names of its contributors may
be used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS	"AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL THE COPYRIGHT	HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL,	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

Portions of this software are copyright © 2024 The FreeType
Project (www.freetype.org). Please see LICENSE_FT.txt for more information.
All rights reserved.
*/
#pragma endregion
#pragma once
#include <string>
#include <functional>
#include <map>
#include "olcUTIL_DataFile.h"
#include "AttributableStat.h"
#include "BitwiseEnum.h"
#include <optional>
#include "Merchant.h"
#include "CraftingRequirement.h"
#include "FunctionPriming.h"
#include "IT.h"
#include <unordered_set>
#include "Buff.h"
#include "ItemEnchant.h"

class AiL;
class ItemInfo;
class ItemProps;

using ITCategory=std::string;
using EventName=std::string;
using EnchantName=std::string;

using ItemScript=std::function<bool(AiL*game,std::optional<vf2d>targetingPos,ItemProps props)>;

enum class EquipSlot{
	HELMET=	0b0000'0001,
	WEAPON=	0b0000'0010,
	ARMOR=	0b0000'0100,
	GLOVES=	0b0000'1000,
	PANTS=	0b0001'0000,
	SHOES=	0b0010'0000,
	RING1=	0b0100'0000,
	RING2=	0b1000'0000,
	NONE=	0b0000'0000,
};

enum class CompactText{
	COMPACT,
	NON_COMPACT,
	CRAFTING_INFO
};

using enum CompactText;

struct Stats:ItemAttributable{
	static safemap<int,float>maxDamageReductionTable;
	static void InitializeDamageReductionTable();
	static Stats NO_MAX_HIGHLIGHT;
public:
	inline static const float&GetDamageReductionPct(int defense){
		return maxDamageReductionTable.at(std::clamp(defense,0,1000));
	}
	inline Stats&operator+=(Stats&rhs){
		for(auto&[key,value]:ItemAttribute::attributes){
			A(value)+=rhs.get_readOnly(value);
		}
		return *this;
	};
	inline Stats&operator+=(ItemAttributable&rhs){
		for(auto&[key,value]:ItemAttribute::attributes){
			A(value)+=rhs.get_readOnly(value);
		}
		return *this;
	};
	auto begin()const{
		return attributes.begin();
	}
	auto end()const{
		return attributes.end();
	}
	const size_t size()const{
		return attributes.size();
	}
	const std::string GetStatsString(const Stats&maxStats,CompactText compact=NON_COMPACT)const;
	friend const bool operator==(const Stats&lhs,const Stats&rhs){return lhs.attributes==rhs.attributes;}
	static const Pixel GetShimmeringColor();
};

struct Stats;
class CraftingRequirement;

struct EnhancementLevelInfo{
	const Stats&stats;
	const CraftingRequirement&craftingRequirement;
	const uint8_t chapterAvailable;
	EnhancementLevelInfo(const Stats&stats,const CraftingRequirement&craftingRequirement,const uint8_t chapterAvailable);
};

struct EnhancementInfo{
private:
	std::vector<Stats>enhancementStats;
	std::vector<CraftingRequirement>craftingRequirements;
public:
	void SetAttribute(int enhanceLevel,ItemAttribute attribute,float value);
	void SetCraftingRequirements(const int enhanceLevel,const std::vector<ItemPair>&requiredItems,const uint32_t goldCost,const uint8_t availableChapter);
	const bool CanBeEnhanced()const;
	const EnhancementLevelInfo operator[](int level)const;
	const size_t size()const;
};

class ItemSortRules{
	friend class ItemInfo;
public:
	static std::vector<std::string>primarySort;
	static std::vector<std::string>secondarySort;
	//Returns a number based on what the equipment type of an item is. The lower the number, the earlier it should appear in the list.
	static uint16_t GetItemSortRanking(const std::weak_ptr<Item>&it);
	static uint16_t MaxSortRanking();
};

//You cannot create instances of this class, access sets from ItemSet::sets and add the appropriate set bonuses.
class ItemSet{
	friend class ItemInfo;
	static std::map<std::string,ItemSet>sets;
	std::array<Stats,8>setBonuses; //Stores the set bonuses with the amount of pieces being the index array - 1 internally. So if we wanted the set bonus for having 1 of this set equipped, we ask for [1] (and it's stored internally at index 0.)
	std::string name;
	std::vector<std::pair<int,Stats>>setBonusBreakpoints;
public:
	//NO CONSTRUCTOR REQUIRED! 
	//Specify the piece count(1-8) for a set bonus to be applied.
	static void AddSetBonus(std::string setName,int pieceCount,Stats&bonuses);
	//Gets a set bonus based on number of pieces (1-8)
	const Stats&operator[](int setPieces)const;
	const std::string&GetSetName()const;
	bool operator<(const ItemSet&rhs)const{
		return name<rhs.name;
	}
	const std::vector<std::pair<int,Stats>>&GetSetBonusBreakpoints()const;
};

namespace PlayerTests{
	class PlayerTest;
};

namespace EnchantTests{
	class EnchantTest;
};

using IncreaseAmount=int;
using RefineResult=std::pair<ItemAttribute,IncreaseAmount>;

class Item{
	friend class Inventory;
	friend class AiL;
	friend class Menu;
	friend class SaveFile;
	friend void Merchant::PurchaseItem(IT item,uint32_t amt);
	friend void Merchant::SellItem(std::weak_ptr<Item>,uint32_t amt);
	friend class PlayerTests::PlayerTest;
	friend class EnchantTests::EnchantTest;
private:
	//The amount in the current item stack.
	uint32_t amt;
	uint8_t enhancementLevel;
	ItemInfo*it;
	Stats randomizedStats;
	bool locked=false;
	std::optional<ItemEnchant>enchant{};

	void SetAmt(uint32_t newAmt);
	static ItemEnhancementFunctionPrimingData enhanceFunctionPrimed;
	static int IsBlankStaticCallCounter;
	const bool _IsBlank()const;
public:
	static const std::string BLANK_ITEM_NAME;
	Item();
	Item(uint32_t amt,IT item,uint8_t enhancementLevel=0);
	uint32_t Amt()const;
	//Use this for places where the item name is used for item tracking. NOT for drawing. Hooks directly into item info's base item name.
	const std::string&ActualName()const;
	//Use for places where the item name is actually displayed. Provides modified text that shows additional information like enhancement levels.
	const std::string DisplayName()const;
	const std::string Description(CompactText compact=COMPACT)const;
	const EventName&UseSound()const;
	const ITCategory Category()const;
	const EquipSlot GetEquipSlot()const;
	const::Renderable&Icon()const;
	const Stats GetStats()const;
	const ItemScript&OnUseAction()const;
	const float CastTime()const;
	const float CastRange()const;
	const float CastSize()const;
	const bool UseDuringCast()const; //When true, the item is activated during the cast instead of after the cast.
	const float CooldownTime()const;
	//Use ISBLANK macro instead!! This should not be called directly!!
	const bool IsBlank()const;
	const uint8_t EnhancementLevel()const;
	//NOTE: This function must be primed with CanEnhanceItem()! Otherwise it will cause a runtime error.
	void EnhanceItem(uint8_t qty=1);
	//Whether or not this item can be enhanced/crafted.
	const bool EnhancementIsPossible()const;
	//A verification function that confirms if we are allowed to perform an enhancement. MUST BE CALLED to prime EnhanceItem() function!!
	const bool CanEnhanceItem(uint8_t qty=1)const;
	static std::shared_ptr<Item>BLANK;
	const std::optional<const::ItemSet*const>ItemSet()const;
	const bool IsEquippable()const;
	const bool IsCraftable()const;
	const bool IsWeapon()const;
	const bool IsArmor()const;
	const bool IsAccessory()const;
	const uint32_t BuyValue()const;
	const uint32_t SellValue()const;
	const bool CanBeSold()const;
	const bool CanBePurchased()const;
	const Stats&RandomStats()const;
	const std::unordered_set<std::string>&GetClass()const;
	void RandomizeStats();
	const bool HasRandomizedStats()const;
	const EnhancementInfo&GetEnhancementInfo()const;
	//Use ISBLANK macro instead!! This should not be called directly!!
	static bool IsBlank(std::shared_ptr<Item>item);
	//Use ISBLANK macro instead!! This should not be called directly!!
	static bool IsBlank(std::weak_ptr<Item>item);
	const bool IsLocked()const;
	const std::string&FragmentName()const;
	const bool CanBeRefined()const; //An item can be refined if the item has less than max stats and the player has enough fragments in their inventory.
	//Assumes an item can be refined. CHECK WITH CanBeRefined() First!!!
	//Refines a random stat by the parameters defined in the Accessories.txt configuration file. Also takes away the costs required to refine the item.
	RefineResult Refine(); 
	const bool CanBeEnchanted()const;
	void Lock();
	void Unlock();
	void RemoveEnchant();
	void _EnchantItem(const ItemEnchant&newEnchant);
	//Applies a random valid enchant to an item and consumes the materials in the process.
	//Assumes an item can be enchanted. CHECK WITH CanBeEnchanted() First!!!
	//Enchants the item based on its class parameters defined in the ItemEnchants.txt configuration file. Also takes away the costs required to refine the item (Located in Accessories.txt).
	const ItemEnchant&ApplyRandomEnchant();
	const std::optional<ItemEnchant>&GetEnchant()const;
	const bool HasEnchant()const;
	friend const bool operator==(std::shared_ptr<Item>lhs,std::shared_ptr<Item>rhs){return lhs->it==rhs->it&&lhs->randomizedStats==rhs->randomizedStats;};
	friend const bool operator==(std::shared_ptr<Item>lhs,const IT&rhs){return lhs->ActualName()==const_cast<IT&>(rhs);};
	friend const bool operator==(std::weak_ptr<Item>lhs,std::weak_ptr<Item>rhs){return !lhs.expired()&&!rhs.expired()&&lhs.lock()->it==rhs.lock()->it&&lhs.lock()->randomizedStats==rhs.lock()->randomizedStats;};
	friend const bool operator==(std::weak_ptr<Item>lhs,const IT&rhs){return !lhs.expired()&&lhs.lock()->ActualName()==const_cast<IT&>(rhs);};
	friend const bool operator==(const IT&lhs,std::weak_ptr<Item>rhs){return operator==(rhs,lhs);};
	friend const bool operator==(const IT&lhs,std::shared_ptr<Item>rhs){return operator==(rhs,lhs);};
	const Pixel GetDisplayNameColor()const;
	static const bool SelectedEquipIsDifferent(const std::weak_ptr<Item>equipAttemptingToEquip,const EquipSlot slotToEquipTo);
	const std::optional<std::string>&FragmentIcon()const;
};

class Inventory{
	friend class ItemInfo;
	friend class Item;
	friend class SaveFile;
	friend class InventoryCreator;
	friend class ItemTests::ItemTest;
public:

	enum class DisassembleResult{
		SUCCESS,
		FAILED, //Failure is due to an item being locked.
	};

	static std::weak_ptr<Item>AddItem(IT it,uint32_t amt=1,bool monsterDrop=false);
	//Returns the actual amount available in your main inventory.
	[[nodiscard]] static uint32_t GetItemCount(IT it);
	static std::vector<std::shared_ptr<Item>>CopyItem(IT it);
	static std::vector<std::weak_ptr<Item>>GetItem(IT it);
	//Auto-executes its use function and removes the amt specified from the inventory. Multiple amounts will cause the item to execute its useFunc multiple times.
	static bool UseItem(IT it,uint32_t amt=1,const std::optional<vf2d>targetingPos={});
	//Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
	static bool RemoveItem(std::weak_ptr<Item>itemRef,ITCategory inventory,uint32_t amt = 1);
	//Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
	static bool RemoveItem(std::weak_ptr<Item>itemRef,uint32_t amt=1);
	//Returns true if the item has been consumed completely and there are 0 remaining of that type in our inventory.
	static bool RemoveItem(IT it,uint32_t amt=1);
	static const std::vector<std::shared_ptr<Item>>&get(ITCategory itemCategory);
	static const std::weak_ptr<Item>GetInventorySlot(ITCategory itemCategory,size_t slot);
	static void Clear(ITCategory itemCategory);
	static void EquipItem(const std::weak_ptr<Item>it,EquipSlot slot);
	static void UnequipItem(EquipSlot slot);
	static EquipSlot GetSlotEquippedIn(const std::weak_ptr<Item>it);
	static std::weak_ptr<Item>GetEquip(EquipSlot slot);
	static const std::map<ItemSet,int>GetEquippedItemSets();
	//Gets all items currently on inventory (Ignores Stage Loot and Monster Loot Inventories)
	static const std::vector<std::shared_ptr<Item>>GetInventory();
	static void UpdateBlacksmithInventoryLists();
	static void AddLoadoutItemUsed(IT item,int slot);
	static void ResetLoadoutItemsUsed();
	static void GivePlayerLoadoutItemsUsed();
	static const bool EquipsFullyMaxedOut(int maxWeaponLevel=10,int maxArmorLevel=10);
	[[nodiscard]]static const Inventory::DisassembleResult Disassemble(std::weak_ptr<Item>itemRef);

	static bool SwapItems(ITCategory itemCategory,uint32_t slot1,uint32_t slot2);
	//Makes sure this is a valid category. Will error out if it doesn't exist! Use for ERROR HANDLING!
	static bool ValidateItemCategory(ITCategory itemCategory){
		get(itemCategory);
		return true;
	}
private:
	static void InsertIntoSortedInv(std::shared_ptr<Item>itemRef);
	static void InsertIntoStageInventoryCategory(std::shared_ptr<Item>itemRef,const bool monsterDrop);
	static bool ExecuteAction(IT item,const std::optional<vf2d>targetingPos);
	static std::multimap<IT,std::shared_ptr<Item>>_inventory;
	static std::vector<std::shared_ptr<Item>>blacksmithInventory;
	static std::map<EquipSlot,std::weak_ptr<Item>>equipment;
	static std::array<std::pair<IT,int>,3U>loadoutItemsUsed;
	//Only contains "1" of every item, as this is a map to index items and not the actual storage of items!
	static std::map<ITCategory,std::vector<std::shared_ptr<Item>>>sortedInv;
};

class ItemProps{
	friend class ItemInfo;
	utils::datafile*scriptProps; 
	utils::datafile*customProps; 
public:
	ItemProps(utils::datafile*scriptProps,utils::datafile*customProps);
	int GetIntProp(const std::string&prop,size_t index=0)const;
	float GetFloatProp(const std::string&prop,size_t index=0)const;
	std::string GetStringProp(const std::string&prop,size_t index=0)const;
	const uint32_t PropCount(const std::string&prop)const;
};

class ItemInfo{
	friend class Inventory;
	friend class Menu;
	std::string name;
	std::string description;
	std::string category;
	float castTime=0;
	float castRange=0;
	float castSize=0;
	float cooldownTime=0;
	EquipSlot slot=EquipSlot::NONE;
	EnhancementInfo enhancement;
	std::optional<std::reference_wrapper<Renderable>>img;
	EventName useSound="";
	std::string set="";
	//Returns true if the item can be used, false otherwise
	std::string useFunc="";
	//Custom properties for this specific item's script.
	static utils::datafile NOPROPS;
	ItemProps customProps;
	uint32_t buyValue=0;
	uint32_t sellValue=0;
	//If true, this item's action is activated at the beginning of the cast instead of after the cast completes.
	bool useDuringCast=false;
	//If blank, any class can equip this item.
	std::unordered_set<std::string>equippableClass;
	Stats minStats;
	Stats maxStats;
	std::optional<std::string>fragmentName;
	std::optional<std::string>fragmentIcon;
private:
	static void InitializeScripts();
	static void InitializeSets();
	static std::map<std::string,EquipSlot>nameToEquipSlot;
	static std::vector<std::shared_ptr<Item>>craftableConsumables;
	const static std::unordered_map<std::string,BuffOverTimeType::BuffOverTimeType>NameToBuffType;
public:
	static void InitializeItems();
	ItemInfo();
	const std::string&Name()const;
	const std::string&Description()const;
	const ITCategory Category()const;
	const::Renderable& Icon()const;
	static const EquipSlot StringToEquipSlot(std::string_view slotName);
	/*
	For the useFunc, return true if the item can be used, false otherwise.
	*/
	const EventName&UseSound()const;
	const ItemScript&OnUseAction()const;
	const Stats GetStats(int enhancementLevel)const;
	const float CastTime()const;
	const float CastRange()const;
	const float CastSize()const;
	const float CooldownTime()const;
	const EquipSlot Slot()const;
	const std::optional<const::ItemSet*const>ItemSet()const;
	ItemInfo&operator[](const IT&item);
	const uint32_t GetBuyValue()const;
	const uint32_t GetSellValue()const;
	const bool CanBeSold()const;
	const bool CanBePurchased()const;
	const bool UseDuringCast()const;
	const EnhancementInfo&GetEnhancementInfo()const;
	const bool IsEquippable()const;
	const bool IsCraftable()const;
	const bool IsWeapon()const;
	const bool IsArmor()const;
	const bool IsAccessory()const;
	const Stats GetMinStats()const;
	const Stats GetMaxStats()const;
	//Get the class that can equip this item.
	const std::unordered_set<std::string>&GetClass()const;
	Stats RandomizeStats();
	const std::string&FragmentName()const;
	const std::optional<std::string>&FragmentIcon()const;
};

class ItemOverlay{
	friend class ItemInfo;
	ItemInfo it;
	float timer=0;
	float xOffset=0;
	float width=0; //How wide the entire label is.
	static std::vector<ItemOverlay>items;
	ItemOverlay(ItemInfo item);
public:
	static void AddToItemOverlay(const ItemInfo&it);
	static void Update();
	static void Draw();
	void ResetTimer();
};

#define ISBLANK(itemRef) Item::IsBlank(itemRef)