// SPDX-FileCopyrightText: 2002-2026 PCSX2 Dev Team
// SPDX-License-Identifier: GPL-3.0+

#pragma once
#include "HeterogeneousContainers.h"
#include <algorithm>
#include <cstdint>
#include <map>

template <class K, class V>
class LRUCache
{
	using CounterType = std::uint64_t;

	struct Item
	{
		V value;
		CounterType last_access;
	};

	using MapType = std::conditional_t<std::is_same_v<K, std::string>, StringMap<Item>, std::map<K, Item>>;

public:
	LRUCache(std::size_t max_capacity = 16, bool manual_evict = false)
		: m_max_capacity(max_capacity)
		, m_manual_evict(manual_evict)
	{
	}
	~LRUCache() = default;

	std::size_t GetSize() const { return m_items.size(); }
	std::size_t GetMaxCapacity() const { return m_max_capacity; }

	void Clear() { m_items.clear(); }

	void SetMaxCapacity(std::size_t capacity)
	{
		m_max_capacity = capacity;
		if (m_items.size() > m_max_capacity)
			Evict(m_items.size() - m_max_capacity);
	}

	template <typename KeyT>
	V* Lookup(const KeyT& key)
	{
		auto iter = m_items.find(key);
		if (iter == m_items.end())
			return nullptr;

		iter->second.last_access = ++m_last_counter;
		return &iter->second.value;
	}

	V* Insert(K key, V value)
	{
		ShrinkForNewItem();

		auto iter = m_items.find(key);
		if (iter != m_items.end())
		{
			iter->second.value = std::move(value);
			iter->second.last_access = ++m_last_counter;
			return &iter->second.value;
		}
		else
		{
			Item it;
			it.last_access = ++m_last_counter;
			it.value = std::move(value);
			auto ip = m_items.emplace(std::move(key), std::move(it));
			return &ip.first->second.value;
		}
	}

	void Evict(std::size_t count = 1)
	{
		while (!m_items.empty() && count > 0)
		{
			auto lowest = std::min_element(m_items.begin(), m_items.end(), [](const auto& a, const auto& b) {
				return a.second.last_access < b.second.last_access;
			});
			m_items.erase(lowest);
			count--;
		}
	}

	template <typename KeyT>
	bool Remove(const KeyT& key)
	{
		auto iter = m_items.find(key);
		if (iter == m_items.end())
			return false;
		m_items.erase(iter);
		return true;
	}
	void SetManualEvict(bool block)
	{
		m_manual_evict = block;
		if (!m_manual_evict)
			ManualEvict();
	}
	void ManualEvict()
	{
		// evict if we went over
		while (m_items.size() > m_max_capacity)
			Evict(m_items.size() - m_max_capacity);
	}

private:
	void ShrinkForNewItem()
	{
		if (m_items.size() < m_max_capacity)
			return;

		Evict(m_items.size() - (m_max_capacity - 1));
	}

	MapType m_items;
	CounterType m_last_counter = 0;
	std::size_t m_max_capacity = 0;
	bool m_manual_evict = false;
};
