#include "binaryninjaapi.h"

using namespace BinaryNinja;
using namespace std;

bool Component::operator==(const Component& other) const
{
	return BNComponentsEqual(m_object, other.m_object);
}


bool Component::operator!=(const Component& other) const
{
	return BNComponentsNotEqual(m_object, other.m_object);
}


Component::Component(BNComponent* component)
{
	m_object = component;
}


std::string Component::GetDisplayName()
{
	char* result = BNComponentGetDisplayName(m_object);
	string stringResult = result;
	BNFreeString(result);
	return stringResult;
}


std::string Component::GetName()
{
	char* result = BNComponentGetOriginalName(m_object);
	string stringResult = result;
	BNFreeString(result);
	return stringResult;
}


Ref Component::GetView()
{
	return new BinaryView(BNComponentGetView(m_object));
}


void Component::SetName(const std::string &name)
{
	BNComponentSetName(m_object, name.c_str());
}


Ref Component::GetParent()
{
	return new Component(BNComponentGetParent(m_object));
}


std::string Component::GetGuid()
{
	char* result = BNComponentGetGuid(m_object);
	string stringResult = result;
	BNFreeString(result);
	return stringResult;
}


bool Component::AddFunction(Ref func)
{
	return BNComponentAddFunctionReference(m_object, func->GetObject());
}


bool Component::AddComponent(Ref component)
{
	return BNComponentAddComponent(m_object, component->m_object);
}


bool Component::AddDataVariable(DataVariable dataVariable)
{
	return BNComponentAddDataVariable(m_object, dataVariable.address);
}


bool Component::RemoveComponent(Ref component)
{
	return BNComponentRemoveComponent(component->m_object);
}


bool Component::RemoveFunction(Ref func)
{
	return BNComponentRemoveFunctionReference(m_object, func->GetObject());
}


bool Component::RemoveDataVariable(DataVariable dataVariable)
{
	return BNComponentRemoveDataVariable(m_object, dataVariable.address);
}


std::vector Component::GetContainedComponents()
{
	std::vector components;

	size_t count;
	BNComponent** list = BNComponentGetContainedComponents(m_object, &count);

	components.reserve(count);
	for (size_t i = 0; i < count; i++)
	{
		Ref component = new Component(BNNewComponentReference(list[i]));
		components.push_back(component);
	}

	BNFreeComponents(list, count);

	return components;
}


std::vector Component::GetContainedFunctions()
{
	std::vector functions;

	size_t count;
	BNFunction** list = BNComponentGetContainedFunctions(m_object, &count);

	functions.reserve(count);
	for (size_t i = 0; i < count; i++)
	{
		Ref function = new Function(BNNewFunctionReference(list[i]));
		functions.push_back(function);
	}

	BNFreeFunctionList(list, count);

	return functions;
}


std::vector Component::GetContainedDataVariables()
{
	vector result;

	size_t count;
	BNDataVariable* variables = BNComponentGetContainedDataVariables(m_object, &count);

	result.reserve(count);
	for (size_t i = 0; i < count; ++i)
	{
		result.emplace_back(variables[i].address,
			Confidence(new Type(BNNewTypeReference(variables[i].type)), variables[i].typeConfidence),
			variables[i].autoDiscovered);
	}

	BNFreeDataVariables(variables, count);
	return result;
}


std::vector Component::GetReferencedTypes()
{
	std::vector types;

	size_t count;
	BNType** list = BNComponentGetReferencedTypes(m_object, &count);

	types.reserve(count);
	for (size_t i = 0; i < count; i++)
	{
		Ref type = new Type(BNNewTypeReference(list[i]));
		types.push_back(type);
	}

	BNComponentFreeReferencedTypes(list, count);

	return types;
}


std::vector Component::GetReferencedDataVariables()
{
	vector result;

	size_t count;
	BNDataVariable* variables = BNComponentGetReferencedDataVariables(m_object, &count);

	result.reserve(count);
	for (size_t i = 0; i < count; ++i)
	{
		result.emplace_back(variables[i].address,
			Confidence(new Type(BNNewTypeReference(variables[i].type)), variables[i].typeConfidence),
			variables[i].autoDiscovered);
	}

	BNFreeDataVariables(variables, count);
	return result;
}