// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.

#if USE_VISUAL_STUDIO_DTE

// Import EnvDTE
#pragma warning(disable : 4278)
#pragma warning(disable : 4146)
#import "libid:80cc9f66-e7d8-4ddd-85b6-d9e6cd0e93e2" version("8.0") lcid("0") raw_interfaces_only named_guids
#pragma warning(default : 4146)
#pragma warning(default : 4278)

// Import Microsoft.VisualStudio.Setup.Configuration.Native
#include <Microsoft.VisualStudio.Setup.Configuration.Native/Setup.Configuration.h>
#pragma comment(lib, "Microsoft.VisualStudio.Setup.Configuration.Native.lib")

#include "VisualStudioConnection.h"
#include "Engine/Platform/Windows/ComPtr.h"

/// <summary>
/// Handles retrying of calls that fail to access Visual Studio.
/// This is due to the weird nature of VS when calling its methods from external code.
/// If this message filter isn't registered some calls will just fail silently.
/// </summary>
class VSMessageFilter : public IMessageFilter
{
private:

	LONG _refCount;

public:

	VSMessageFilter()
	{
		_refCount = 0;
	}

	virtual ~VSMessageFilter()
	{
	}

public:

	DWORD __stdcall HandleInComingCall(DWORD dwCallType, HTASK htaskCaller, DWORD dwTickCount, LPINTERFACEINFO lpInterfaceInfo) override
	{
		return SERVERCALL_ISHANDLED;
	}

	DWORD __stdcall RetryRejectedCall(HTASK htaskCallee, DWORD dwTickCount, DWORD dwRejectType) override
	{
		if (dwRejectType == SERVERCALL_RETRYLATER)
		{
			// Retry immediatey
			return 99;
		}

		// Cancel the call
		return -1;
	}

	DWORD __stdcall MessagePending(HTASK htaskCallee, DWORD dwTickCount, DWORD dwPendingType) override
	{
		return PENDINGMSG_WAITDEFPROCESS;
	}

	//	COM requirement. Returns instance of an interface of provided type.
	HRESULT __stdcall QueryInterface(REFIID iid, void** ppvObject) override
	{
		if (iid == IID_IDropTarget || iid == IID_IUnknown)
		{
			AddRef();
			*ppvObject = this;
			return S_OK;
		}

		*ppvObject = nullptr;
		return E_NOINTERFACE;
	}

	// COM requirement. Increments objects reference count.
	ULONG __stdcall AddRef() override
	{
		return _InterlockedIncrement(&_refCount);
	}

	//	COM requirement. Decreases the objects reference count and deletes the object if its zero.
	ULONG __stdcall Release() override
	{
		LONG count = _InterlockedDecrement(&_refCount);

		if (count == 0)
		{
			delete this;
			return 0;
		}

		return count;
	}
};

// Helper macro
#define CHECK_VS_RESULT(target) if (FAILED(result)) return #target " failed with result: " + std::to_string((int)result);

#define USE_ITEM_OPERATIONS_OPEN 0
#define USE_PROJECT_ITEM_OPEN 1
#define USE_DOCUMENT_OPEN 0

class LocalBSTR
{
public:

	BSTR Str;

public:

	LocalBSTR()
	{
		Str = nullptr;
	}

	LocalBSTR(const LPSTR str)
	{
		const auto wslen = MultiByteToWideChar(CP_ACP, 0, str, (int)strlen(str), nullptr, 0);
		Str = SysAllocStringLen(0, wslen);
		MultiByteToWideChar(CP_ACP, 0, str, (int)strlen(str), Str, wslen);
	}

	LocalBSTR(const wchar_t* str)
	{
		Str = ::SysAllocString(str);
	}

	~LocalBSTR()
	{
		if (Str)
		{
			::SysFreeString(Str);
		}
	}

public:

	operator const BSTR() const
	{
		return Str;
	}

	operator const wchar_t*() const
	{
		return Str;
	}
};

namespace VisualStudio
{
	bool SameFile(HANDLE h1, HANDLE h2)
	{
		BY_HANDLE_FILE_INFORMATION bhfi1 = { 0 };
		BY_HANDLE_FILE_INFORMATION bhfi2 = { 0 };

		if (::GetFileInformationByHandle(h1, &bhfi1) && ::GetFileInformationByHandle(h2, &bhfi2))
		{
			return ((bhfi1.nFileIndexHigh == bhfi2.nFileIndexHigh) && (bhfi1.nFileIndexLow == bhfi2.nFileIndexLow) && (bhfi1.dwVolumeSerialNumber == bhfi2.dwVolumeSerialNumber));
		}

		return false;
	}

	bool AreFilePathsEqual(const wchar_t* path1, const wchar_t* path2)
	{
		if (wcscmp(path1, path2) == 0)
			return true;

		HANDLE file1 = CreateFileW(path1, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
		HANDLE file2 = CreateFileW(path2, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);

		bool result = SameFile(file1, file2);

		CloseHandle(file1);
		CloseHandle(file2);

		return result;
	}

	class ConnectionInternal
	{
	public:

		const wchar_t* ClsID;
		LocalBSTR SolutionPath;

		CLSID CLSID;
		ComPtr<EnvDTE::_DTE> DTE;

	public:

		ConnectionInternal(const wchar_t* clsID, const wchar_t* solutionPath)
			: ClsID(clsID)
			, SolutionPath(solutionPath)
		{
		}

	public:

		bool IsValid() const
		{
			return DTE != nullptr;
		}
	};

	// Scans the running processes to find a running Visual Studio instance with the specified version and open solution.
	//
	// @param[in]	clsID			Class ID of the specific Visual Studio version we are looking for.
	// @param[in]	solutionPath	Path to the solution the instance needs to have open.
	// @return						DTE object that may be used to interact with the Visual Studio instance, or null if
	//								not found.
	static Result FindRunningInstance(ConnectionHandle connection)
	{
		HRESULT result;

		ComPtr<IRunningObjectTable> runningObjectTable;
		result = GetRunningObjectTable(0, &runningObjectTable);
		CHECK_VS_RESULT("VisualStudio::FindRunningInstance - GetRunningObjectTable");

		ComPtr<IEnumMoniker> enumMoniker;
		result = runningObjectTable->EnumRunning(&enumMoniker);
		CHECK_VS_RESULT("VisualStudio::FindRunningInstance - EnumRunning");

		ComPtr<IMoniker> dteMoniker;
		result = CreateClassMoniker(connection->CLSID, &dteMoniker);
		CHECK_VS_RESULT("VisualStudio::FindRunningInstance - CreateClassMoniker");

		ComPtr<IMoniker> moniker;
		ULONG count = 0;
		while (enumMoniker->Next(1, &moniker, &count) == S_OK)
		{
			if (moniker->IsEqual(dteMoniker))
			{
				ComPtr<IUnknown> curObject;
				result = runningObjectTable->GetObjectW(moniker, &curObject);
				moniker.Detach();

				if (result != S_OK)
					continue;

				ComPtr<EnvDTE::_DTE> dte;
				curObject->QueryInterface(__uuidof(EnvDTE::_DTE), (void**)&dte);

				if (dte == nullptr)
					continue;

				ComPtr<EnvDTE::_Solution> solution;
				if (FAILED(dte->get_Solution(&solution)))
					continue;

				LocalBSTR fullName;
				if (FAILED(solution->get_FullName(&fullName.Str)))
					continue;

				if (AreFilePathsEqual(connection->SolutionPath, fullName))
				{
					// Found
					connection->DTE = dte;
					break;
				}
			}
		}

		return Result::Ok;
	}

	// Opens a new Visual Studio instance of the specified version with the provided solution.
	//
	// @param[in]	clsID			Class ID of the specific Visual Studio version to start.
	// @param[in]	solutionPath	Path to the solution the instance needs to open.
	static Result OpenInstance(ConnectionHandle connection)
	{
		HRESULT result;

		ComPtr<IUnknown> newInstance = nullptr;
		result = CoCreateInstance(connection->CLSID, nullptr, CLSCTX_LOCAL_SERVER, EnvDTE::IID__DTE, (LPVOID*)&newInstance);
		CHECK_VS_RESULT("VisualStudio::OpenInstance - CoCreateInstance");

		newInstance->QueryInterface(&connection->DTE);
		if (connection->DTE == nullptr)
			return "Invalid DTE handle";

		connection->DTE->put_UserControl(TRUE);

		ComPtr<EnvDTE::_Solution> solution;
		result = connection->DTE->get_Solution(&solution);
		CHECK_VS_RESULT("VisualStudio::OpenInstance - dte->get_Solution");

		result = solution->Open(connection->SolutionPath);
		CHECK_VS_RESULT("VisualStudio::OpenInstance - solution->Open");

		// Wait until VS opens
		int maxWaitMs = 10 * 1000;
		int elapsedMs = 0;
		int stepTimeMs = 100;
		while (elapsedMs < maxWaitMs)
		{
			ComPtr<EnvDTE::Window> window = nullptr;
			if (SUCCEEDED(connection->DTE->get_MainWindow(&window)))
				return Result::Ok;

			Sleep(stepTimeMs);
			elapsedMs += stepTimeMs;
		}

		return "Visual Studio open timout";
	}

	static ComPtr<EnvDTE::ProjectItem> FindItem(const ComPtr<EnvDTE::ProjectItems>& projectItems, BSTR filePath)
	{
		long count;
		projectItems->get_Count(&count);
		if (count == 0)
			return nullptr;

		for (long i = 1; i <= count; i++) // They are counting from [1..Count]
		{
			ComPtr<EnvDTE::ProjectItem> projectItem;
		    projectItems->Item(_variant_t(i), &projectItem);
            if (!projectItem)
                continue;

			short fileCount = 0;
			projectItem->get_FileCount(&fileCount);
			for (short fileIndex = 1; fileIndex <= fileCount; fileIndex++)
			{
				_bstr_t filename;
				projectItem->get_FileNames(fileIndex, filename.GetAddress());

				if (filename.GetBSTR() != nullptr && AreFilePathsEqual(filePath, filename))
				{
					return projectItem;
				}
			}

			ComPtr<EnvDTE::ProjectItems> childProjectItems;
			projectItem->get_ProjectItems(&childProjectItems);
			if (childProjectItems)
			{
			    ComPtr<EnvDTE::ProjectItem> result = FindItem(childProjectItems, filePath);
			    if (result)
				    return result;
			}
		}

		return nullptr;
	}

	static ComPtr<EnvDTE::ProjectItem> FindItem(const ComPtr<EnvDTE::_Solution>& solution, BSTR filePath)
	{
        HRESULT result;

		ComPtr<EnvDTE::Projects> projects;
		result = solution->get_Projects(&projects);
        if (FAILED(result))
            return nullptr;

		long projectsCount = 0;
		result = projects->get_Count(&projectsCount);
        if (FAILED(result))
            return nullptr;

		for (long projectIndex = 1; projectIndex <= projectsCount; projectIndex++) // They are counting from [1..Count]
		{
			ComPtr<EnvDTE::Project> project;
			result = projects->Item(_variant_t(projectIndex), &project);
			if (FAILED(result) || !project)
				continue;

			ComPtr<EnvDTE::ProjectItems> projectItems;
			result = project->get_ProjectItems(&projectItems);
			if (FAILED(result) || !projectItems)
				continue;

			auto projectItem = FindItem(projectItems, filePath);
			if (projectItem)
			{
                return projectItem;
			}
		}

		return nullptr;
	}

	// Opens a file on a specific line in a running Visual Studio instance.
	//
	// @param[in]	dte			DTE object retrieved from FindRunningInstance() or OpenInstance().
	// @param[in]	filePath	Path of the file to open. File should be a part of the VS solution.
	// @param[in]	line		Line on which to focus Visual Studio after the file is open.
	static Result OpenFile(ConnectionHandle handle, BSTR filePath, unsigned int line)
	{
		HRESULT result;
		LocalBSTR viewKind(EnvDTE::vsViewKindPrimary);

#if USE_ITEM_OPERATIONS_OPEN
		ComPtr<EnvDTE::ItemOperations> itemOperations;
		result = handle->DTE->get_ItemOperations(&itemOperations);
		CHECK_VS_RESULT("VisualStudio::OpenFile - DTE->get_ItemOperations");
#endif

		// Check if that file is opened
		VARIANT_BOOL isOpen = 0;
#if USE_ITEM_OPERATIONS_OPEN
		result = itemOperations->IsFileOpen(filePath, viewKind.Str, &isOpen);
		CHECK_VS_RESULT("VisualStudio::OpenFile - itemOperations->IsFileOpen");
#else
		result = handle->DTE->get_IsOpenFile(viewKind.Str, filePath, &isOpen);
		CHECK_VS_RESULT("VisualStudio::OpenFile - DTE->get_IsOpenFile");
#endif

		// Open or navigate to a window with a file
		ComPtr<EnvDTE::Window> window;
		ComPtr<EnvDTE::Document> document;
		if (isOpen == 0)
		{
			// Open file
#if USE_DOCUMENT_OPEN
			ComPtr<EnvDTE::Documents> documents;
			result = handle->DTE->get_Documents(&documents);
			CHECK_VS_RESULT("VisualStudio::OpenInstance - DTE->get_Documents");

			ComPtr<EnvDTE::Document> tmp;
			LocalBSTR kind(_T("Auto"));
			result = documents->Open(filePath, kind.Str, VARIANT_FALSE, &tmp);
			CHECK_VS_RESULT("VisualStudio::OpenInstance - documents->Open");

			result = tmp->get_ActiveWindow(&window);
			CHECK_VS_RESULT("VisualStudio::OpenFile - tmp->get_ActiveWindow");
#elif USE_PROJECT_ITEM_OPEN
			ComPtr<EnvDTE::_Solution> solution;
			result = handle->DTE->get_Solution(&solution);
			CHECK_VS_RESULT("VisualStudio::OpenInstance - DTE->get_Solution");
            
            ComPtr<EnvDTE::ProjectItem> projectItem = FindItem(solution, filePath);
            if (projectItem)
			{
				result = projectItem->Open(viewKind, &window);
				CHECK_VS_RESULT("VisualStudio::OpenFile - projectItem->Open");
			}
#elif USE_ITEM_OPERATIONS_OPEN
			result = itemOperations->OpenFile(filePath, viewKind, &window);
			CHECK_VS_RESULT("VisualStudio::OpenFile - itemOperations->OpenFile");
#else
			result = handle->DTE->OpenFile(viewKind, filePath, &window);
			CHECK_VS_RESULT("VisualStudio::OpenFile - DTE->OpenFile");
#endif
			if (window == nullptr)
				return Result::Ok;

			// Activate window and get document handle
			result = window->Activate();
			CHECK_VS_RESULT("VisualStudio::OpenFile - window->Activate");
			result = handle->DTE->get_ActiveDocument(&document);
			CHECK_VS_RESULT("VisualStudio::OpenFile - dte->get_ActiveDocument");
		}
		else
		{
			// Find opened document

			ComPtr<EnvDTE::Documents> documents;
			result = handle->DTE->get_Documents(&documents);
			CHECK_VS_RESULT("VisualStudio::OpenFile - DTE->get_Documents");

			long documentsCount;
			result = documents->get_Count(&documentsCount);
			CHECK_VS_RESULT("VisualStudio::OpenFile - documents->get_Count");

			for (int i = 1; i <= documentsCount; i++) // They are counting from [1..Count]
			{
				ComPtr<EnvDTE::Document> tmp;
				result = documents->Item(_variant_t(i), &tmp);
				CHECK_VS_RESULT("VisualStudio::OpenFile - documents->Item");
				if (tmp == nullptr)
					continue;

				BSTR tmpPath;
				result = tmp->get_FullName(&tmpPath);
				CHECK_VS_RESULT("VisualStudio::OpenFile - tmp->get_FullName");

				if (AreFilePathsEqual(filePath, tmpPath))
				{
					result = tmp->Activate();
					CHECK_VS_RESULT("VisualStudio::OpenFile - tmp->Activate");

					// Found
					document = tmp;
					break;
				}
			}
		}
		if (document == nullptr)
			return "Cannot open a file";

		// Check if need to select a given line
		if (line != 0)
		{
			ComPtr<IDispatch> selection;
			result = document->get_Selection(&selection);
			CHECK_VS_RESULT("VisualStudio::OpenFile - activeDocument->get_Selection");
			if (selection == nullptr)
				return Result::Ok;

			ComPtr<EnvDTE::TextSelection> textSelection;
			result = selection->QueryInterface(&textSelection);
			CHECK_VS_RESULT("VisualStudio::OpenFile - selection->QueryInterface");

			textSelection->GotoLine(line, VARIANT_TRUE);
		}

		/*
		// Bring the window in focus
		window = nullptr;
		if (SUCCEEDED(dte->get_MainWindow(&window)))
		{
			window->Activate();

			HWND hWnd;
			window->get_HWnd((LONG*)&hWnd);
			SetForegroundWindow(hWnd);
		}
		*/

		return Result::Ok;
	}

	// Adds a file to the project opened in a running Visual Studio instance.
	//
	// @param[in]	dte			DTE object retrieved from FindRunningInstance() or OpenInstance().
	// @param[in]	filePath	Path of the file to add.
	// @param[in]	localPath	Path of the file to add relative to the solution folder.
	static Result AddFile(ConnectionHandle handle, BSTR filePath, const wchar_t* localPath)
	{
		HRESULT result;

		ComPtr<EnvDTE::_Solution> solution;
		result = handle->DTE->get_Solution(&solution);
		CHECK_VS_RESULT("VisualStudio::OpenInstance - DTE->get_Solution");
        
        ComPtr<EnvDTE::ProjectItem> projectItem = FindItem(solution, filePath);
        if (projectItem)
        {
            // Already added
            return Result::Ok;
        }
   
        ComPtr<EnvDTE::Projects> projects;
        result = solution->get_Projects(&projects);
        if (FAILED(result))
            return nullptr;

        long projectsCount = 0;
        result = projects->get_Count(&projectsCount);
        if (FAILED(result))
            return nullptr;

	    ComPtr<EnvDTE::Project> project;
	    wchar_t buffer[500];

        // Place .Build.cs scripts into BuildScripts project
        const int localPathLength = (int)wcslen(localPath);
        if (localPathLength >= 10 && _wcsicmp(localPath + localPathLength - ARRAY_COUNT(".Build.cs") + 1, TEXT(".Build.cs")) == 0)
        {
            for (long projectIndex = 1; projectIndex <= projectsCount; projectIndex++) // They are counting from [1..Count]
            {
	            result = projects->Item(_variant_t(projectIndex), &project);
	            if (FAILED(result) || !project)
		            continue;
                
				_bstr_t name;
                if (SUCCEEDED(project->get_Name(name.GetAddress())) && wcscmp(name, TEXT("BuildScripts")) == 0)
                    break;
                project = nullptr;
            }
        }
        else
        {
            // TODO: find the project to add script to? for .cs scripts it should be csproj, for c++ vcproj?

            // Find parent folder
            wchar_t* path = filePath + wcslen(localPath) + 1;
            int length = (int)wcslen(path);
            memcpy(buffer, path, length * sizeof(wchar_t));
            for (int i = length - 1; i >= 0; i--)
            {
                if (buffer[i] == '\\' || buffer[i] == '/')
                {
                    buffer[i] = '\0';
                    length = i;
                    break;
                }
            }
            const LocalBSTR parentPath(TEXT("MyProject"));
            projectItem = FindItem(solution, parentPath);
            // ...
        }

        // TODO: add file and all missing parent folders to the project

		return Result::Ok;
	}

	class CleanupHelper
	{
	public:

		IMessageFilter* oldFilter;
		VSMessageFilter* newFilter;

		CleanupHelper()
		{
			CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
			newFilter = new VSMessageFilter();
			CoRegisterMessageFilter(newFilter, &oldFilter);
		}

		~CleanupHelper()
		{
			CoRegisterMessageFilter(oldFilter, nullptr);
			CoUninitialize();
		}
	};
};

VisualStudio::Result VisualStudio::Result::Ok;

int VisualStudio::GetVisualStudioVersions(InstanceInfo* infos, int infosCount)
{
    // Try to create the CoCreate the class; if that fails, likely no instances are registered
	ComPtr<ISetupConfiguration2> query;
	HRESULT result = CoCreateInstance(__uuidof(SetupConfiguration), nullptr, CLSCTX_ALL, __uuidof(ISetupConfiguration2), (LPVOID*)&query);
	if (FAILED(result))
	{
		return 0;
	}

	// Get the enumerator
	ComPtr<IEnumSetupInstances> enumSetupInstances;
	result = query->EnumAllInstances(&enumSetupInstances);
	if (FAILED(result))
	{
		return 0;
	}

	// Check the state and version of the enumerated instances
    int32 count = 0;
    ComPtr<ISetupInstance> instance;
	while(count < infosCount)
    {
        ULONG fetched = 0;
        result = enumSetupInstances->Next(1, &instance, &fetched);
        if (FAILED(result) || fetched == 0)
        {
            break;
        }

        ComPtr<ISetupInstance2> setupInstance2;
        result = instance->QueryInterface(__uuidof(ISetupInstance2), (LPVOID*)&setupInstance2);
        if (SUCCEEDED(result))
        {
            InstanceState state;
            result = setupInstance2->GetState(&state);
            if (SUCCEEDED(result) && (state & eLocal) != 0)
            {
                BSTR installationVersion;
                result = setupInstance2->GetInstallationVersion(&installationVersion);
                if (SUCCEEDED(result))
                {
                    BSTR installationPath;
                    result = setupInstance2->GetInstallationPath(&installationPath);
                    if (SUCCEEDED(result))
                    {
                        BSTR productPath;
                        result = setupInstance2->GetProductPath(&productPath);
                        if (SUCCEEDED(result))
                        {
                            auto& info = infos[count++];

                            char version[3];
                            version[0] = (char)installationVersion[0];
                            version[1] = (char)installationVersion[1];
                            version[2] = 0;
                            info.VersionMajor = atoi(version);

                            swprintf_s(info.ExecutablePath, MAX_PATH, L"%s\\%s", installationPath, productPath);

                            wchar_t progID[100];
                            swprintf_s(progID, 100, L"VisualStudio.DTE.%d.0", info.VersionMajor);

                            CLSID clsid;
                            CLSIDFromProgID(progID, &clsid);
                            StringFromGUID2(clsid, info.CLSID, 40);

                            SysFreeString(productPath);
                        }
                        SysFreeString(installationPath);
                    }
                    SysFreeString(installationVersion);
                }
            }
        }
    }

    return count;
}

void VisualStudio::OpenConnection(ConnectionHandle& connection, const wchar_t* clsID, const wchar_t* solutionPath)
{
	connection = new ConnectionInternal(clsID, solutionPath);
}

void VisualStudio::CloseConnection(ConnectionHandle& connection)
{
	if (connection)
	{
		delete connection;
		connection = nullptr;
	}
}

bool VisualStudio::IsActive(const ConnectionHandle& connection)
{
	// Check if already opened
	if (connection->IsValid())
		return true;

	// Try to find active
	auto e = FindRunningInstance(connection);
	return connection->DTE != nullptr;
}

VisualStudio::Result VisualStudio::OpenSolution(ConnectionHandle connection)
{
	// Check if already opened
	if (connection->IsValid())
		return Result::Ok;

	// Temporary data
	CleanupHelper helper;
	HRESULT result;

	// Cache VS version CLSID
	result = CLSIDFromString(connection->ClsID, &connection->CLSID);
	CHECK_VS_RESULT("VisualStudio::CLSIDFromString");

	// Get or open VS with solution
	auto e = FindRunningInstance(connection);
	if (e.Failed())
		return e;
	if (connection->DTE == nullptr)
	{
		e = OpenInstance(connection);
		if (e.Failed())
			return e;
		if (connection->DTE == nullptr)
			return "Cannot open Visual Studio";
	}

	// Focus VS main window
	ComPtr<EnvDTE::Window> window;
	if (SUCCEEDED(connection->DTE->get_MainWindow(&window)))
		window->Activate();

	return Result::Ok;
}

VisualStudio::Result VisualStudio::OpenFile(ConnectionHandle connection, const wchar_t* path, unsigned int line)
{
	// Ensure to have valid connection
	auto result = OpenSolution(connection);
	if (result.Failed())
		return result;

	// Open file
	CleanupHelper helper;
    const LocalBSTR pathBstr(path);
	return OpenFile(connection, pathBstr.Str, line);
}

VisualStudio::Result VisualStudio::AddFile(ConnectionHandle connection, const wchar_t* path, const wchar_t* localPath)
{
	// Ensure to have valid connection
	auto result = OpenSolution(connection);
	if (result.Failed())
		return result;

	// Add file
	CleanupHelper helper;
	LocalBSTR pathBstr(path);
	return AddFile(connection, pathBstr.Str, localPath);
}

#endif