#include "vmt_hook.hpp"

namespace big
{
	vmt_hook::vmt_hook(void* obj, std::size_t num_funcs) :
	    m_object(static_cast<void***>(obj)),
	    m_num_funcs(num_funcs),
	    m_original_table(*m_object),
	    m_new_table(std::make_unique<void*[]>(m_num_funcs))
	{
		std::copy_n(m_original_table, m_num_funcs, m_new_table.get());
	}

	vmt_hook::~vmt_hook()
	{
		disable();
	}

	void vmt_hook::hook(std::size_t index, void* func)
	{
		m_new_table[index] = func;
	}

	void vmt_hook::unhook(std::size_t index)
	{
		m_new_table[index] = m_original_table[index];
	}

	void vmt_hook::enable()
	{
		*m_object = m_new_table.get();
	}

	void vmt_hook::disable()
	{
		*m_object = m_original_table;
	}
}#include "vtable_hook.hpp"

namespace big
{
	vtable_hook::vtable_hook(void** vft, std::size_t num_funcs) :
	    m_num_funcs(num_funcs),
	    m_table(vft),
	    m_backup_table(std::make_unique<void*[]>(m_num_funcs)),
	    m_hook_table(std::make_unique<void*[]>(m_num_funcs))
	{
		std::memcpy(m_backup_table.get(), m_table, m_num_funcs * sizeof(void*));
		std::memcpy(m_hook_table.get(), m_table, m_num_funcs * sizeof(void*));
	}

	vtable_hook::~vtable_hook()
	{
		disable();
	}

	void vtable_hook::hook(std::size_t index, void* func)
	{
		m_hook_table[index] = func;
	}

	void vtable_hook::unhook(std::size_t index)
	{
		m_hook_table[index] = m_backup_table[index];
	}

	void vtable_hook::enable()
	{
		std::memcpy(m_table, m_hook_table.get(), m_num_funcs * sizeof(void*));
	}

	void vtable_hook::disable()
	{
		std::memcpy(m_table, m_backup_table.get(), m_num_funcs * sizeof(void*));
	}
}#pragma once

namespace big
{
	class vtable_hook
	{
	public:
		explicit vtable_hook(void** vft, std::size_t num_funcs);
		~vtable_hook();

		vtable_hook(vtable_hook&& that)            = delete;
		vtable_hook& operator=(vtable_hook&& that) = delete;
		vtable_hook(vtable_hook const&)            = delete;
		vtable_hook& operator=(vtable_hook const&) = delete;

		void hook(std::size_t index, void* func);
		void unhook(std::size_t index);

		template
		T get_original(std::size_t index);

		inline void** get_original_table()
		{
			return m_backup_table.get();
		}

		void enable();
		void disable();

	private:
		std::size_t m_num_funcs;
		void** m_table;
		std::unique_ptr<void*[]> m_backup_table;
		std::unique_ptr<void*[]> m_hook_table;
	};

	template
	inline T vtable_hook::get_original(std::size_t index)
	{
		return static_cast(m_backup_table[index]);
	}

}