/* -LICENSE-START-
 ** Copyright (c) 2012 Blackmagic Design
 **  
 ** Permission is hereby granted, free of charge, to any person or organization 
 ** obtaining a copy of the software and accompanying documentation (the 
 ** "Software") to use, reproduce, display, distribute, sub-license, execute, 
 ** and transmit the Software, and to prepare derivative works of the Software, 
 ** and to permit third-parties to whom the Software is furnished to do so, in 
 ** accordance with:
 ** 
 ** (1) if the Software is obtained from Blackmagic Design, the End User License 
 ** Agreement for the Software Development Kit ("EULA") available at 
 ** https://www.blackmagicdesign.com/EULA/DeckLinkSDK; or
 ** 
 ** (2) if the Software is obtained from any third party, such licensing terms 
 ** as notified by that third party,
 ** 
 ** and all subject to the following:
 ** 
 ** (3) the copyright notices in the Software and this entire statement, 
 ** including the above license grant, this restriction and the following 
 ** disclaimer, must be included in all copies of the Software, in whole or in 
 ** part, and all derivative works of the Software, unless such copies or 
 ** derivative works are solely in the form of machine-executable object code 
 ** generated by a source language processor.
 ** 
 ** (4) THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
 ** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
 ** FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT 
 ** SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE 
 ** FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, 
 ** ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
 ** DEALINGS IN THE SOFTWARE.
 ** 
 ** A copy of the Software is available free of charge at 
 ** https://www.blackmagicdesign.com/desktopvideo_sdk under the EULA.
 ** 
 ** -LICENSE-END-
 */

#include "ControlServer.h"
#include "DeckLinkDisplayMode.h"
#include "DeckLinkFrameTransfer.h"
#include "DeckLinkSession.h"
#include "OpenGLComposite.h"
#include "GLExtensions.h"
#include "GlRenderConstants.h"
#include "OpenGLDeckLinkBridge.h"
#include "OpenGLRenderPass.h"
#include "OpenGLShaderPrograms.h"
#include "OscServer.h"
#include "RuntimeControlBridge.h"

#include <memory>
#include <string>
#include <thread>
#include <vector>

OpenGLComposite::OpenGLComposite(HWND hWnd, HDC hDC, HGLRC hRC) :
	hGLWnd(hWnd), hGLDC(hDC), hGLRC(hRC),
	mDeckLink(std::make_unique<DeckLinkSession>()),
	mRenderer(std::make_unique<OpenGLRenderer>()),
	mRuntimePollRunning(false),
	mRuntimeRegistryChanged(false),
	mRuntimeReloadRequested(false),
	mRuntimePollFailed(false)
{
	InitializeCriticalSection(&pMutex);
	mRuntimeHost = std::make_unique<RuntimeHost>();
	mDeckLinkBridge = std::make_unique<OpenGLDeckLinkBridge>(
		*mDeckLink,
		*mRenderer,
		*mRuntimeHost,
		pMutex,
		hGLDC,
		hGLRC,
		[this]() { renderEffect(); },
		[this]() { paintGL(); });
	mRenderPass = std::make_unique<OpenGLRenderPass>(*mRenderer);
	mShaderPrograms = std::make_unique<OpenGLShaderPrograms>(*mRenderer, *mRuntimeHost);
	mControlServer = std::make_unique<ControlServer>();
	mOscServer = std::make_unique<OscServer>();
}

OpenGLComposite::~OpenGLComposite()
{
	StopRuntimePolling();
	mDeckLink->ReleaseResources();
	mRenderer->DestroyResources();
	if (mOscServer)
		mOscServer->Stop();
	if (mControlServer)
		mControlServer->Stop();

	DeleteCriticalSection(&pMutex);
}

bool OpenGLComposite::InitDeckLink()
{
	VideoFormatSelection		videoModes;
	std::string						initFailureReason;

	if (mRuntimeHost && mRuntimeHost->GetRepoRoot().empty())
	{
		std::string runtimeError;
		if (!mRuntimeHost->Initialize(runtimeError))
		{
			MessageBoxA(NULL, runtimeError.c_str(), "Runtime host failed to initialize", MB_OK);
			return false;
		}
	}

	if (mRuntimeHost)
	{
		if (!ResolveConfiguredVideoFormats(
			mRuntimeHost->GetInputVideoFormat(),
			mRuntimeHost->GetInputFrameRate(),
			mRuntimeHost->GetOutputVideoFormat(),
			mRuntimeHost->GetOutputFrameRate(),
			videoModes,
			initFailureReason))
		{
			MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink mode configuration error", MB_OK);
			return false;
		}
	}

	if (!mDeckLink->DiscoverDevicesAndModes(videoModes, initFailureReason))
	{
		const char* title = initFailureReason == "Please install the Blackmagic DeckLink drivers to use the features of this application."
			? "This application requires the DeckLink drivers installed."
			: "DeckLink initialization failed";
		MessageBoxA(NULL, initFailureReason.c_str(), title, MB_OK | MB_ICONERROR);
		return false;
	}

	if (! CheckOpenGLExtensions())
	{
		initFailureReason = "OpenGL extension checks failed.";
		goto error;
	}
	if (mDeckLink->InputOutputDimensionsDiffer())
	{
		mRenderer->SetFastTransferAvailable(false);
		OutputDebugStringA("Input/output dimensions differ; using regular OpenGL transfer fallback instead of fast transfer.\n");
	}

	if (! InitOpenGLState())
	{
		initFailureReason = "OpenGL state initialization failed.";
		goto error;
	}

	PublishDeckLinkOutputStatus(mDeckLink->OutputModelName().empty()
		? "DeckLink output device selected."
		: ("Selected output device: " + mDeckLink->OutputModelName()));

	// Resize window to match output video frame, but scale large formats down by half for viewing.
	if (mDeckLink->OutputFrameWidth() < 1920)
		resizeWindow(mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight());
	else
		resizeWindow(mDeckLink->OutputFrameWidth() / 2, mDeckLink->OutputFrameHeight() / 2);

	if (mRenderer->FastTransferAvailable())
	{
		// Initialize fast video frame transfers
		if (! VideoFrameTransfer::initialize(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mRenderer->CaptureTexture(), mRenderer->OutputTexture()))
		{
			MessageBox(NULL, _T("Cannot initialize video transfers."), _T("VideoFrameTransfer error."), MB_OK);
			goto error;
		}
	}

	if (!mDeckLink->ConfigureInput(this, hGLDC, hGLRC, videoModes.input, initFailureReason))
	{
		goto error;
	}
	if (!mDeckLink->HasInputDevice() && mRuntimeHost)
	{
		mRuntimeHost->SetSignalStatus(false, mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mDeckLink->InputDisplayModeName());
	}

	if (!mDeckLink->ConfigureOutput(this, hGLDC, hGLRC, videoModes.output, mRuntimeHost && mRuntimeHost->ExternalKeyingEnabled(), initFailureReason))
	{
		goto error;
	}

	PublishDeckLinkOutputStatus(mDeckLink->StatusMessage());

	return true;

error:
	if (!initFailureReason.empty())
		MessageBoxA(NULL, initFailureReason.c_str(), "DeckLink initialization failed", MB_OK | MB_ICONERROR);
	mDeckLink->ReleaseResources();
	return false;
}

void OpenGLComposite::paintGL()
{
	if (!TryEnterCriticalSection(&pMutex))
	{
		ValidateRect(hGLWnd, NULL);
		return;
	}

	mRenderer->PresentToWindow(hGLDC, mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight());
	ValidateRect(hGLWnd, NULL);
	LeaveCriticalSection(&pMutex);
}

void OpenGLComposite::resizeGL(WORD width, WORD height)
{
	// We don't set the project or model matrices here since the window data is copied directly from
	// an off-screen FBO in paintGL().  Just save the width and height for use in paintGL().
	mRenderer->ResizeView(width, height);
}

void OpenGLComposite::resizeWindow(int width, int height)
{
	RECT r;
	if (GetWindowRect(hGLWnd, &r))
	{
		SetWindowPos(hGLWnd, HWND_TOP, r.left, r.top, r.left + width, r.top + height, 0);
	}
}

void OpenGLComposite::PublishDeckLinkOutputStatus(const std::string& statusMessage)
{
	if (!mRuntimeHost)
		return;

	if (!statusMessage.empty())
		mDeckLink->SetStatusMessage(statusMessage);

	mRuntimeHost->SetDeckLinkOutputStatus(
		mDeckLink->OutputModelName(),
		mDeckLink->SupportsInternalKeying(),
		mDeckLink->SupportsExternalKeying(),
		mDeckLink->KeyerInterfaceAvailable(),
		mRuntimeHost->ExternalKeyingEnabled(),
		mDeckLink->ExternalKeyingActive(),
		mDeckLink->StatusMessage());
}

bool OpenGLComposite::InitOpenGLState()
{
	if (! ResolveGLExtensions())
		return false;

	std::string runtimeError;
	if (mRuntimeHost->GetRepoRoot().empty() && !mRuntimeHost->Initialize(runtimeError))
	{
		MessageBoxA(NULL, runtimeError.c_str(), "Runtime host failed to initialize", MB_OK);
		return false;
	}

	if (!StartRuntimeControlServices(*this, *mRuntimeHost, *mControlServer, *mOscServer, runtimeError))
	{
		MessageBoxA(NULL, runtimeError.c_str(), "Runtime control services failed to start", MB_OK);
		return false;
	}

	// Prepare the runtime shader program generated from the active shader package.
	char compilerErrorMessage[1024];
	if (!mShaderPrograms->CompileDecodeShader(sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		MessageBoxA(NULL, compilerErrorMessage, "OpenGL decode shader failed to load or compile", MB_OK);
		return false;
	}

	if (!mShaderPrograms->CompileLayerPrograms(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		MessageBoxA(NULL, compilerErrorMessage, "OpenGL shader failed to load or compile", MB_OK);
		return false;
	}
	mShaderPrograms->ResetTemporalHistoryState();

	std::string rendererError;
	if (!mRenderer->InitializeResources(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), mDeckLink->OutputFrameWidth(), mDeckLink->OutputFrameHeight(), rendererError))
	{
		MessageBoxA(NULL, rendererError.c_str(), "OpenGL initialization error.", MB_OK);
		return false;
	}

	broadcastRuntimeState();
	StartRuntimePolling();
	return true;
}

// DeckLink delegates still target OpenGLComposite; the bridge owns the per-frame work.
void OpenGLComposite::VideoFrameArrived(IDeckLinkVideoInputFrame* inputFrame, bool hasNoInputSource)
{
	mDeckLinkBridge->VideoFrameArrived(inputFrame, hasNoInputSource);
}

void OpenGLComposite::PlayoutFrameCompleted(IDeckLinkVideoFrame* completedFrame, BMDOutputFrameCompletionResult completionResult)
{
	mDeckLinkBridge->PlayoutFrameCompleted(completedFrame, completionResult);
}

bool OpenGLComposite::Start()
{
	return mDeckLink->Start();
}

bool OpenGLComposite::Stop()
{
	StopRuntimePolling();

	if (mOscServer)
		mOscServer->Stop();

	if (mControlServer)
		mControlServer->Stop();

	const bool wasExternalKeyingActive = mDeckLink->ExternalKeyingActive();
	mDeckLink->Stop();
	if (wasExternalKeyingActive)
		PublishDeckLinkOutputStatus("External keying has been disabled.");

	return true;
}

bool OpenGLComposite::ReloadShader()
{
	char compilerErrorMessage[1024];

	EnterCriticalSection(&pMutex);
	wglMakeCurrent(hGLDC, hGLRC);

	bool success = mShaderPrograms->CompileLayerPrograms(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage);
	if (mRuntimeHost)
		mRuntimeHost->ClearReloadRequest();

	wglMakeCurrent(NULL, NULL);
	LeaveCriticalSection(&pMutex);

	if (!success)
	{
		if (mRuntimeHost)
			mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
		MessageBoxA(NULL, compilerErrorMessage, "Slang shader reload failed", MB_OK);
	}
	else
	{
		if (mRuntimeHost)
			mRuntimeHost->SetCompileStatus(true, "Shader compiled successfully.");
		broadcastRuntimeState();
	}

	return success;
}

void OpenGLComposite::renderEffect()
{
	ProcessRuntimePollResults();

	const bool hasInputSource = mDeckLink->HasInputSource();
	std::vector<RuntimeRenderState> layerStates;
	if (mRuntimeHost)
	{
		if (mRuntimeHost->TryGetLayerRenderStates(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), layerStates))
			mCachedLayerRenderStates = layerStates;
		else
			layerStates = mCachedLayerRenderStates;
	}
	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
	mRenderPass->Render(
		hasInputSource,
		layerStates,
		mDeckLink->InputFrameWidth(),
		mDeckLink->InputFrameHeight(),
		historyCap,
		[this](const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error) {
			return mShaderPrograms->UpdateTextBindingTexture(state, textBinding, error);
		},
		[this](const RuntimeRenderState& state, unsigned availableSourceHistoryLength, unsigned availableTemporalHistoryLength) {
			return mShaderPrograms->UpdateGlobalParamsBuffer(state, availableSourceHistoryLength, availableTemporalHistoryLength);
		});
}

void OpenGLComposite::StartRuntimePolling()
{
	if (!mRuntimeHost || mRuntimePollRunning.exchange(true))
		return;

	mRuntimePollThread = std::thread([this]() { RuntimePollLoop(); });
}

void OpenGLComposite::StopRuntimePolling()
{
	if (!mRuntimePollRunning.exchange(false))
		return;

	if (mRuntimePollThread.joinable())
		mRuntimePollThread.join();
}

void OpenGLComposite::RuntimePollLoop()
{
	while (mRuntimePollRunning)
	{
		bool registryChanged = false;
		bool reloadRequested = false;
		std::string runtimeError;
		if (!mRuntimeHost->PollFileChanges(registryChanged, reloadRequested, runtimeError))
		{
			{
				std::lock_guard<std::mutex> lock(mRuntimePollErrorMutex);
				mRuntimePollError = runtimeError;
			}
			mRuntimePollFailed = true;
		}
		else
		{
			if (registryChanged)
				mRuntimeRegistryChanged = true;
			if (reloadRequested)
				mRuntimeReloadRequested = true;
		}

		for (int i = 0; i < 25 && mRuntimePollRunning; ++i)
			Sleep(10);
	}
}

bool OpenGLComposite::ProcessRuntimePollResults()
{
	if (!mRuntimeHost)
		return true;

	if (mRuntimePollFailed.exchange(false))
	{
		std::string runtimeError;
		{
			std::lock_guard<std::mutex> lock(mRuntimePollErrorMutex);
			runtimeError = mRuntimePollError;
		}
		mRuntimeHost->SetCompileStatus(false, runtimeError);
		broadcastRuntimeState();
		return false;
	}

	if (mRuntimeRegistryChanged.exchange(false))
		broadcastRuntimeState();

	if (!mRuntimeReloadRequested.exchange(false))
		return true;

	char compilerErrorMessage[1024] = {};
	if (!mShaderPrograms->CompileLayerPrograms(mDeckLink->InputFrameWidth(), mDeckLink->InputFrameHeight(), sizeof(compilerErrorMessage), compilerErrorMessage))
	{
		mRuntimeHost->SetCompileStatus(false, compilerErrorMessage);
		mRuntimeHost->ClearReloadRequest();
		broadcastRuntimeState();
		return false;
	}

	mShaderPrograms->ResetTemporalHistoryState();
	broadcastRuntimeState();
	return true;
}

void OpenGLComposite::broadcastRuntimeState()
{
	if (mControlServer)
		mControlServer->BroadcastState();
}

void OpenGLComposite::resetTemporalHistoryState()
{
	mShaderPrograms->ResetTemporalHistoryState();
}

bool OpenGLComposite::CheckOpenGLExtensions()
{
	mRenderer->SetFastTransferAvailable(VideoFrameTransfer::checkFastMemoryTransferAvailable());

	if (!mRenderer->FastTransferAvailable())
		OutputDebugStringA("Fast memory transfer extension not available, using regular OpenGL transfer fallback instead\n");

	return true;
}

////////////////////////////////////////////