// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "HAL/Platform.h"

#include "AudioMixer.h"
#include "ScopedCom.h"

#include "Windows/AllowWindowsPlatformTypes.h"
#include "Windows/AllowWindowsPlatformAtomics.h"

#include "Microsoft/COMPointer.h"

THIRD_PARTY_INCLUDES_START
#include <mmreg.h>				// WAVEFORMATEX
#include <mmdeviceapi.h>		// IMMDeviceEnumerator
THIRD_PARTY_INCLUDES_END

#include "Windows/HideWindowsPlatformTypes.h"
#include "Windows/HideWindowsPlatformAtomics.h"

#define UE_API WINDOWSMMDEVICEENUMERATION_API

namespace Audio
{		
struct FWindowsMMDeviceCache : IAudioMixerDeviceChangedListener, IAudioPlatformDeviceInfoCache
{
	struct FCacheEntry
	{
		enum class UE_DEPRECATED(5.6, "EEndpointType is deprecated. Please use EDeviceEndpointType instead.") EEndpointType { Unknown, Render, Capture };
		
		FName DeviceId;							// Key
		FString FriendlyName;
		FString DeviceFriendlyName;
		EAudioDeviceState State = EAudioDeviceState::NotPresent;
		int32 NumChannels = 0;
		int32 SampleRate = 0;
		EDeviceEndpointType Type = EDeviceEndpointType::Unknown;
		uint32 ChannelBitmask = 0;				// Bitfield used to build output channels, for easy comparison.
		FName HardwareId;						// Unique string of the physical hardware device this MMDevice belongs to
		FString FilterId;						// Unique identifier for this device containing product id (pid), vendor id (vid), etc.

		TArray<EAudioMixerChannel::Type> OutputChannels;	// TODO. Generate this from the ChannelNum and bitmask when we are asked for it.
		mutable FRWLock MutationLock;

		FCacheEntry& operator=(const FCacheEntry& InOther);

		FCacheEntry& operator=(FCacheEntry&& InOther);

		FCacheEntry(const FCacheEntry& InOther);

		FCacheEntry(FCacheEntry&& InOther);

		FCacheEntry(const FString& InDeviceId);
	};

	TComPtr<IMMDeviceEnumerator> DeviceEnumerator;

	mutable FRWLock CacheMutationLock;							// R/W lock protects map and default arrays.
	TMap<FName, FCacheEntry> Cache;								// DeviceID GUID -> Info.
	FName DefaultCaptureId[(int32)EAudioDeviceRole::COUNT];		// Role -> DeviceID GUID
	FName DefaultRenderId[(int32)EAudioDeviceRole::COUNT];		// Role -> DeviceID GUID

	UE_API FWindowsMMDeviceCache();
	UE_API explicit FWindowsMMDeviceCache(bool bInEnableAggregateDeviceSupport);
	virtual ~FWindowsMMDeviceCache() = default;

	UE_API bool EnumerateChannelMask(uint32 InMask, FCacheEntry& OutInfo);

	UE_API bool EnumerateChannelFormat(const WAVEFORMATEX* InFormat, FCacheEntry& OutInfo);

	UE_API EDeviceEndpointType QueryDeviceDataFlow(const TComPtr<IMMDevice>& InDevice) const;

	UE_API bool EnumerateDeviceProps(const TComPtr<IMMDevice>& InDevice, FCacheEntry& OutInfo);

	UE_API bool EnumerateHardwareTopology(const TComPtr<IMMDevice>& InDevice, FCacheEntry& OutInfo);

	UE_API void EnumerateEndpoints();

	UE_API void EnumerateDefaults();

	UE_API void OnDefaultCaptureDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) override;

	UE_API void OnDefaultRenderDeviceChanged(const EAudioDeviceRole InAudioDeviceRole, const FString& DeviceId) override;

	UE_API void OnDeviceAdded(const FString& DeviceId, bool bIsRender) override;

	UE_API void OnDeviceRemoved(const FString& DeviceId, bool) override;

	UE_API TOptional<FCacheEntry> BuildCacheEntry(const FString& DeviceId);

	UE_API FString GetFriendlyName(FName InDeviceId) const;

	UE_API void OnDeviceStateChanged(const FString& DeviceId, const EAudioDeviceState InState, bool) override;

	UE_API void OnFormatChanged(const FString& InDeviceId, const FFormatChangedData& InFormat) override;

	UE_API void MakeDeviceInfo(const FCacheEntry& InEntry, FName InDefaultDevice, FAudioPlatformDeviceInfo& OutInfo) const;

	UE_API virtual TArray<FAudioPlatformDeviceInfo> GetAllActiveOutputDevices() const override;

	UE_API virtual bool IsAggregateHardwareDeviceId(const FName InDeviceID) const override;

	UE_API virtual TOptional<FAudioPlatformDeviceInfo> GetAggregateHardwareDeviceInfo(const FName InHardwareId, const EDeviceEndpointType InEndpointType) const;

	UE_API virtual TArray<FAudioPlatformDeviceInfo> GetLogicalAggregateDevices(const FName InHardwareId, const EDeviceEndpointType InEndpointType) const override;

	UE_API virtual TArray<FAudioPlatformDeviceInfo> SynthesizeAggregateDeviceList(const EDeviceEndpointType InType) const;
	
	UE_API FName GetDefaultOutputDevice_NoLock() const;

	UE_API TOptional<FAudioPlatformDeviceInfo> FindDefaultOutputDevice() const override;

	UE_API TOptional<FAudioPlatformDeviceInfo> FindActiveOutputDevice(FName InDeviceID) const override;

	UE_API bool IsAggregateDeviceSupportEnabled() const;

	static UE_API FString ExtractAggregateDeviceName(const FString& InName);

private:
	struct FCacheKeyFuncs : BaseKeyFuncs<FWindowsMMDeviceCache::FCacheEntry, FName>
	{
		static KeyInitType GetSetKey(ElementInitType Element)
		{
			return Element.HardwareId;
		}

		static bool Matches(KeyInitType A, KeyInitType B)
		{
			return A.IsEqual(B, ENameCase::CaseSensitive);
		}

		static uint32 GetKeyHash(KeyInitType Key)
		{
			return GetTypeHash(Key);
		}
	};

	struct FDeviceChannelInfo
	{
		uint32 LogicDeviceChannelCount = 0;
		uint32 TotalChannelCount = 0;
	};

	bool bIsAggregateDeviceSupportEnabled = false;
	
	UE_API void GetHardwareInfo(TSet<FCacheEntry, FCacheKeyFuncs>& OutUniqueHardwareIds, TMap<FName, FDeviceChannelInfo>& OutDeviceChannelInfos, EDeviceEndpointType InType) const;

	static UE_API FAudioPlatformDeviceInfo CreateAggregateDeviceInfo(const FCacheEntry& InCacheEntry, const FDeviceChannelInfo& InDeviceChannelInfo);
	
	static UE_API int32 ExtractAggregateChannelNumber(const FString& InName);
};

}// namespace Audio

#undef UE_API