#include "DeckLinkSession.h"

#include "GlRenderConstants.h"

#include <atlbase.h>
#include <cstdio>
#include <cstring>
#include <new>
#include <sstream>
#include <vector>

namespace
{
std::string BstrToUtf8(BSTR value)
{
	if (value == nullptr)
		return std::string();

	const int requiredBytes = WideCharToMultiByte(CP_UTF8, 0, value, -1, NULL, 0, NULL, NULL);
	if (requiredBytes <= 1)
		return std::string();

	std::vector<char> utf8Name(static_cast<std::size_t>(requiredBytes), '\0');
	if (WideCharToMultiByte(CP_UTF8, 0, value, -1, utf8Name.data(), requiredBytes, NULL, NULL) <= 0)
		return std::string();

	return std::string(utf8Name.data());
}

bool InputSupportsFormat(IDeckLinkInput* input, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat)
{
	if (input == nullptr)
		return false;

	BOOL supported = FALSE;
	BMDDisplayMode actualMode = bmdModeUnknown;
	const HRESULT result = input->DoesSupportVideoMode(
		bmdVideoConnectionUnspecified,
		displayMode,
		pixelFormat,
		bmdNoVideoInputConversion,
		bmdSupportedVideoModeDefault,
		&actualMode,
		&supported);
	return result == S_OK && supported != FALSE;
}

bool OutputSupportsFormat(IDeckLinkOutput* output, BMDDisplayMode displayMode, BMDPixelFormat pixelFormat)
{
	if (output == nullptr)
		return false;

	BOOL supported = FALSE;
	BMDDisplayMode actualMode = bmdModeUnknown;
	const HRESULT result = output->DoesSupportVideoMode(
		bmdVideoConnectionUnspecified,
		displayMode,
		pixelFormat,
		bmdNoVideoOutputConversion,
		bmdSupportedVideoModeDefault,
		&actualMode,
		&supported);
	return result == S_OK && supported != FALSE;
}
}

DeckLinkSession::~DeckLinkSession()
{
	ReleaseResources();
}

void DeckLinkSession::ReleaseResources()
{
	if (input != nullptr)
		input->SetCallback(nullptr);
	captureDelegate.Release();
	input.Release();

	if (output != nullptr)
		output->SetScheduledFrameCompletionCallback(nullptr);

	if (keyer != nullptr)
	{
		keyer->Disable();
		externalKeyingActive = false;
	}
	keyer.Release();

	playoutDelegate.Release();
	outputVideoFrameQueue.clear();
	output.Release();
}

bool DeckLinkSession::DiscoverDevicesAndModes(const VideoFormatSelection& videoModes, std::string& error)
{
	CComPtr<IDeckLinkIterator> deckLinkIterator;
	CComPtr<IDeckLinkDisplayMode> inputMode;
	CComPtr<IDeckLinkDisplayMode> outputMode;

	inputDisplayModeName = videoModes.input.displayName;
	outputDisplayModeName = videoModes.output.displayName;

	HRESULT result = CoCreateInstance(CLSID_CDeckLinkIterator, nullptr, CLSCTX_ALL, IID_IDeckLinkIterator, reinterpret_cast<void**>(&deckLinkIterator));
	if (FAILED(result))
	{
		error = "Please install the Blackmagic DeckLink drivers to use the features of this application.";
		return false;
	}

	CComPtr<IDeckLink> deckLink;
	while (deckLinkIterator->Next(&deckLink) == S_OK)
	{
		int64_t duplexMode;
		bool deviceSupportsInternalKeying = false;
		bool deviceSupportsExternalKeying = false;
		std::string modelName;
		CComPtr<IDeckLinkProfileAttributes> deckLinkAttributes;

		if (deckLink->QueryInterface(IID_IDeckLinkProfileAttributes, (void**)&deckLinkAttributes) != S_OK)
		{
			printf("Could not obtain the IDeckLinkProfileAttributes interface\n");
			deckLink.Release();
			continue;
		}

		result = deckLinkAttributes->GetInt(BMDDeckLinkDuplex, &duplexMode);
		BOOL attributeFlag = FALSE;
		if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsInternalKeying, &attributeFlag) == S_OK)
			deviceSupportsInternalKeying = (attributeFlag != FALSE);
		attributeFlag = FALSE;
		if (deckLinkAttributes->GetFlag(BMDDeckLinkSupportsExternalKeying, &attributeFlag) == S_OK)
			deviceSupportsExternalKeying = (attributeFlag != FALSE);
		CComBSTR modelNameBstr;
		if (deckLinkAttributes->GetString(BMDDeckLinkModelName, &modelNameBstr) == S_OK)
			modelName = BstrToUtf8(modelNameBstr);

		if (result != S_OK || duplexMode == bmdDuplexInactive)
		{
			deckLink.Release();
			continue;
		}

		bool inputUsed = false;
		if (!input && deckLink->QueryInterface(IID_IDeckLinkInput, (void**)&input) == S_OK)
			inputUsed = true;

		if (!output && (!inputUsed || (duplexMode == bmdDuplexFull)))
		{
			if (deckLink->QueryInterface(IID_IDeckLinkOutput, (void**)&output) != S_OK)
				output.Release();
			else
			{
				outputModelName = modelName;
				supportsInternalKeying = deviceSupportsInternalKeying;
				supportsExternalKeying = deviceSupportsExternalKeying;
			}
		}

		deckLink.Release();

		if (output && input)
			break;
	}

	if (!output)
	{
		error = "Expected an Output DeckLink device";
		ReleaseResources();
		return false;
	}

	CComPtr<IDeckLinkDisplayModeIterator> inputDisplayModeIterator;
	if (input && input->GetDisplayModeIterator(&inputDisplayModeIterator) != S_OK)
	{
		error = "Cannot get input Display Mode Iterator.";
		ReleaseResources();
		return false;
	}

	if (input && !FindDeckLinkDisplayMode(inputDisplayModeIterator, videoModes.input.displayMode, &inputMode))
	{
		error = "Cannot get specified input BMDDisplayMode for configured mode: " + videoModes.input.displayName;
		ReleaseResources();
		return false;
	}
	inputDisplayModeIterator.Release();

	CComPtr<IDeckLinkDisplayModeIterator> outputDisplayModeIterator;
	if (output->GetDisplayModeIterator(&outputDisplayModeIterator) != S_OK)
	{
		error = "Cannot get output Display Mode Iterator.";
		ReleaseResources();
		return false;
	}

	if (!FindDeckLinkDisplayMode(outputDisplayModeIterator, videoModes.output.displayMode, &outputMode))
	{
		error = "Cannot get specified output BMDDisplayMode for configured mode: " + videoModes.output.displayName;
		ReleaseResources();
		return false;
	}

	outputFrameSize = { static_cast<unsigned>(outputMode->GetWidth()), static_cast<unsigned>(outputMode->GetHeight()) };
	inputFrameSize = inputMode
		? FrameSize{ static_cast<unsigned>(inputMode->GetWidth()), static_cast<unsigned>(inputMode->GetHeight()) }
		: outputFrameSize;
	if (!input)
		inputDisplayModeName = "No input - black frame";
	outputMode->GetFrameRate(&frameDuration, &frameTimescale);

	inputFrameRowBytes = inputFrameSize.width * 2u;
	outputFrameRowBytes = outputFrameSize.width * 4u;
	captureTextureWidth = inputFrameSize.width / 2u;
	outputPackTextureWidth = outputFrameSize.width;

	return true;
}

bool DeckLinkSession::SelectPreferredFormats(const VideoFormatSelection& videoModes, std::string& error)
{
	if (!output)
	{
		error = "Expected an Output DeckLink device";
		return false;
	}

	formatStatusMessage.clear();

	const bool inputTenBitSupported = input != nullptr && InputSupportsFormat(input, videoModes.input.displayMode, bmdFormat10BitYUV);
	inputPixelFormat = input != nullptr ? ChoosePreferredVideoIOFormat(inputTenBitSupported) : VideoIOPixelFormat::Uyvy8;
	if (input != nullptr && !inputTenBitSupported)
		formatStatusMessage += "DeckLink input does not report 10-bit YUV support for the configured mode; using 8-bit capture. ";

	const bool outputTenBitSupported = OutputSupportsFormat(output, videoModes.output.displayMode, bmdFormat10BitYUV);
	outputPixelFormat = ChoosePreferredVideoIOFormat(outputTenBitSupported);
	if (!outputTenBitSupported)
		formatStatusMessage += "DeckLink output does not report 10-bit YUV support for the configured mode; using 8-bit BGRA output. ";

	int deckLinkOutputRowBytes = 0;
	if (output->RowBytesForPixelFormat(OutputIsTenBit() ? bmdFormat10BitYUV : bmdFormat8BitBGRA, outputFrameSize.width, &deckLinkOutputRowBytes) != S_OK)
	{
		error = "DeckLink output setup failed while calculating output row bytes.";
		return false;
	}
	outputFrameRowBytes = static_cast<unsigned>(deckLinkOutputRowBytes);
	outputPackTextureWidth = OutputIsTenBit()
		? PackedTextureWidthFromRowBytes(outputFrameRowBytes)
		: outputFrameSize.width;

	if (InputIsTenBit())
	{
		int deckLinkInputRowBytes = 0;
		if (output->RowBytesForPixelFormat(bmdFormat10BitYUV, inputFrameSize.width, &deckLinkInputRowBytes) == S_OK)
			inputFrameRowBytes = static_cast<unsigned>(deckLinkInputRowBytes);
		else
			inputFrameRowBytes = MinimumV210RowBytes(inputFrameSize.width);
	}
	else
	{
		inputFrameRowBytes = inputFrameSize.width * 2u;
	}
	captureTextureWidth = InputIsTenBit()
		? PackedTextureWidthFromRowBytes(inputFrameRowBytes)
		: inputFrameSize.width / 2u;

	std::ostringstream status;
	status << "DeckLink formats: capture " << (input ? VideoIOPixelFormatName(inputPixelFormat) : "none")
		<< ", output " << (OutputIsTenBit() ? "10-bit YUV v210" : "8-bit BGRA") << ".";
	if (!formatStatusMessage.empty())
		status << " " << formatStatusMessage;
	formatStatusMessage = status.str();
	return true;
}

bool DeckLinkSession::ConfigureInput(OpenGLComposite* owner, HDC hdc, HGLRC hglrc, const VideoFormat& inputVideoMode, std::string& error)
{
	(void)hdc;
	(void)hglrc;

	if (!input)
	{
		hasNoInputSource = true;
		inputDisplayModeName = "No input - black frame";
		return true;
	}

	const BMDPixelFormat deckLinkInputPixelFormat = DeckLinkPixelFormatForVideoIO(inputPixelFormat);
	if (input->EnableVideoInput(inputVideoMode.displayMode, deckLinkInputPixelFormat, bmdVideoInputFlagDefault) != S_OK)
	{
		if (inputPixelFormat == VideoIOPixelFormat::V210)
		{
			OutputDebugStringA("DeckLink 10-bit input could not be enabled; falling back to 8-bit capture.\n");
			inputPixelFormat = VideoIOPixelFormat::Uyvy8;
			inputFrameRowBytes = inputFrameSize.width * 2u;
			captureTextureWidth = inputFrameSize.width / 2u;
			if (input->EnableVideoInput(inputVideoMode.displayMode, bmdFormat8BitYUV, bmdVideoInputFlagDefault) == S_OK)
			{
				std::ostringstream status;
				status << "DeckLink formats: capture " << VideoIOPixelFormatName(inputPixelFormat)
					<< ", output " << (OutputIsTenBit() ? "10-bit YUV v210" : "8-bit BGRA")
					<< ". DeckLink 10-bit input enable failed; using 8-bit capture.";
				formatStatusMessage = status.str();
				goto input_enabled;
			}
		}

		OutputDebugStringA("DeckLink input could not be enabled; continuing in output-only black-frame mode.\n");
		input.Release();
		hasNoInputSource = true;
		inputDisplayModeName = "No input - black frame";
		return true;
	}

input_enabled:
	captureDelegate.Attach(new (std::nothrow) CaptureDelegate(owner));
	if (captureDelegate == nullptr)
	{
		error = "DeckLink input setup failed while creating the capture callback.";
		return false;
	}
	if (input->SetCallback(captureDelegate) != S_OK)
	{
		error = "DeckLink input setup failed while installing the capture callback.";
		return false;
	}

	return true;
}

bool DeckLinkSession::ConfigureOutput(OpenGLComposite* owner, HDC hdc, HGLRC hglrc, const VideoFormat& outputVideoMode, bool externalKeyingEnabled, std::string& error)
{
	(void)hdc;
	(void)hglrc;

	if (output->EnableVideoOutput(outputVideoMode.displayMode, bmdVideoOutputFlagDefault) != S_OK)
	{
		error = "DeckLink output setup failed while enabling video output.";
		return false;
	}

	if (output->QueryInterface(IID_IDeckLinkKeyer, (void**)&keyer) == S_OK && keyer != NULL)
		keyerInterfaceAvailable = true;

	if (externalKeyingEnabled)
	{
		if (!supportsExternalKeying)
		{
			statusMessage = "External keying was requested, but the selected DeckLink output does not report external keying support.";
		}
		else if (!keyerInterfaceAvailable)
		{
			statusMessage = "External keying was requested, but the selected DeckLink output does not expose the IDeckLinkKeyer interface.";
		}
		else if (keyer->Enable(TRUE) != S_OK || keyer->SetLevel(255) != S_OK)
		{
			statusMessage = "External keying was requested, but enabling the DeckLink keyer failed.";
		}
		else
		{
			externalKeyingActive = true;
			statusMessage = "External keying is active on the selected DeckLink output.";
		}
	}
	else if (supportsExternalKeying)
	{
		statusMessage = "Selected DeckLink output supports external keying. Set enableExternalKeying to true in runtime-host.json to request it.";
	}

	for (int i = 0; i < 10; i++)
	{
		CComPtr<IDeckLinkMutableVideoFrame> outputFrame;

		const BMDPixelFormat deckLinkOutputPixelFormat = OutputIsTenBit() ? bmdFormat10BitYUV : bmdFormat8BitBGRA;
		if (output->CreateVideoFrame(outputFrameSize.width, outputFrameSize.height, outputFrameRowBytes, deckLinkOutputPixelFormat, bmdFrameFlagFlipVertical, &outputFrame) != S_OK)
		{
			error = "DeckLink output setup failed while creating an output video frame.";
			return false;
		}

		outputVideoFrameQueue.push_back(outputFrame);
	}

	playoutDelegate.Attach(new (std::nothrow) PlayoutDelegate(owner));
	if (playoutDelegate == nullptr)
	{
		error = "DeckLink output setup failed while creating the playout callback.";
		return false;
	}

	if (output->SetScheduledFrameCompletionCallback(playoutDelegate) != S_OK)
	{
		error = "DeckLink output setup failed while installing the scheduled-frame callback.";
		return false;
	}

	if (!formatStatusMessage.empty())
		statusMessage = statusMessage.empty() ? formatStatusMessage : formatStatusMessage + " " + statusMessage;

	return true;
}

double DeckLinkSession::FrameBudgetMilliseconds() const
{
	return frameTimescale != 0
		? (static_cast<double>(frameDuration) * 1000.0) / static_cast<double>(frameTimescale)
		: 0.0;
}

IDeckLinkMutableVideoFrame* DeckLinkSession::RotateOutputFrame()
{
	CComPtr<IDeckLinkMutableVideoFrame> outputVideoFrame = outputVideoFrameQueue.front();
	outputVideoFrameQueue.push_back(outputVideoFrame);
	outputVideoFrameQueue.pop_front();
	return outputVideoFrame.p;
}

void DeckLinkSession::AccountForCompletionResult(BMDOutputFrameCompletionResult completionResult)
{
	if (completionResult == bmdOutputFrameDisplayedLate || completionResult == bmdOutputFrameDropped)
		totalPlayoutFrames += 2;
}

bool DeckLinkSession::ScheduleOutputFrame(IDeckLinkMutableVideoFrame* outputVideoFrame)
{
	if (output->ScheduleVideoFrame(outputVideoFrame, (totalPlayoutFrames * frameDuration), frameDuration, frameTimescale) != S_OK)
		return false;

	totalPlayoutFrames++;
	return true;
}

bool DeckLinkSession::Start()
{
	totalPlayoutFrames = 0;
	if (!output)
	{
		MessageBoxA(NULL, "Cannot start playout because no DeckLink output device is available.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}
	if (outputVideoFrameQueue.empty())
	{
		MessageBoxA(NULL, "Cannot start playout because the output frame queue is empty.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}

	for (unsigned i = 0; i < kPrerollFrameCount; i++)
	{
		CComPtr<IDeckLinkMutableVideoFrame> outputVideoFrame = outputVideoFrameQueue.front();
		outputVideoFrameQueue.push_back(outputVideoFrame);
		outputVideoFrameQueue.pop_front();

		CComPtr<IDeckLinkVideoBuffer> outputVideoFrameBuffer;
		if (outputVideoFrame->QueryInterface(IID_IDeckLinkVideoBuffer, (void**)&outputVideoFrameBuffer) != S_OK)
		{
			MessageBoxA(NULL, "Could not query the preroll output frame buffer.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}

		if (outputVideoFrameBuffer->StartAccess(bmdBufferAccessWrite) != S_OK)
		{
			MessageBoxA(NULL, "Could not write to the preroll output frame buffer.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}

		void* pFrame;
		outputVideoFrameBuffer->GetBytes((void**)&pFrame);
		memset(pFrame, 0, outputVideoFrame->GetRowBytes() * outputFrameSize.height);

		outputVideoFrameBuffer->EndAccess(bmdBufferAccessWrite);

		if (output->ScheduleVideoFrame(outputVideoFrame, (totalPlayoutFrames * frameDuration), frameDuration, frameTimescale) != S_OK)
		{
			MessageBoxA(NULL, "Could not schedule a preroll output frame.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}

		totalPlayoutFrames++;
	}

	if (input)
	{
		if (input->StartStreams() != S_OK)
		{
			MessageBoxA(NULL, "Could not start the DeckLink input stream.", "DeckLink start failed", MB_OK | MB_ICONERROR);
			return false;
		}
	}
	if (output->StartScheduledPlayback(0, frameTimescale, 1.0) != S_OK)
	{
		MessageBoxA(NULL, "Could not start DeckLink scheduled playback.", "DeckLink start failed", MB_OK | MB_ICONERROR);
		return false;
	}

	return true;
}

bool DeckLinkSession::Stop()
{
	if (keyer != nullptr)
	{
		keyer->Disable();
		externalKeyingActive = false;
	}

	if (input)
	{
		input->StopStreams();
		input->DisableVideoInput();
	}

	if (output)
	{
		output->StopScheduledPlayback(0, NULL, 0);
		output->DisableVideoOutput();
	}

	return true;
}