#include "ChannelInterface.h"
#include "AudioBuffer.h"
#include "ChannelNode.h"
#include "Singleton/MixerList.h"
#include "Mixer/MixerTrack.h"

FChannelInterface::FChannelInterface(int32 InputChannelNum, int32 OutputChannelNum)
{
	const int32 InputNodeNum = InputChannelNum / 2;
	const int32 OutputNodeNum = OutputChannelNum / 2;
	FNullChannelNode* NullNode = FNullChannelNode::Get();
	
	InputHeaders.AddZeroed(InputChannelNum);
	OutputHeaders.AddZeroed(OutputChannelNum);

	for (int i = 0; i < InputNodeNum; ++i)
	{
		InputChannelNodes.Add(NullNode);
		SetInputChannel(i, NullNode);
	}

	for (int i = 0; i < OutputNodeNum; ++i)
	{
		OutputChannelNodes.Add(NullNode);
		SetOutputChannel(i, NullNode);
	}
}

void FChannelInterface::SetInputChannel(int32 NodeIndex, FChannelNode* Node)
{
	if (!InputChannelNodes.IsValidIndex(NodeIndex))
		return;
	InputChannelNodes[NodeIndex] = Node;
	
	const TArray<float*>& NodeHeaders = Node->GetChannelHeaders();
	
	InputHeaders[NodeIndex * 2 + 0] = NodeHeaders[0];
	InputHeaders[NodeIndex * 2 + 1] = NodeHeaders[1];
	FMixerList::Get().RequestBuildProcessNode();
}

void FChannelInterface::SetOutputChannel(int32 NodeIndex, FChannelNode* Node)
{
	if (!OutputChannelNodes.IsValidIndex(NodeIndex))
		return;
	OutputChannelNodes[NodeIndex] = Node;

	const TArray<float*>& NodeHeaders = Node->GetChannelHeaders();
	OutputHeaders[NodeIndex * 2 + 0] = NodeHeaders[0];
	OutputHeaders[NodeIndex * 2 + 1] = NodeHeaders[1];
	FMixerList::Get().RequestBuildProcessNode();
}

void FChannelInterface::SetInputChannel(const TArray<FChannelNode*>& Nodes, int32 Offset)
{
	const int32 InputNum = FMath::Min(Nodes.Num() - Offset, InputChannelNodes.Num());
	for (int i = 0; i < InputNum; ++i)
	{
		SetInputChannel(i + Offset, Nodes[i]);
	}
}

void FChannelInterface::SetOutputChannel(const TArray<FChannelNode*>& Nodes, int32 Offset)
{
	const int32 OutputNum = FMath::Min(Nodes.Num() - Offset, OutputChannelNodes.Num());
	for (int i = 0; i < OutputNum; ++i)
	{
		SetOutputChannel(i + Offset, Nodes[i]);
	}
}

int32 FChannelInterface::GetInputNodeIndex(FChannelNode* Node)
{
	for (int32 i = 0; i < InputChannelNodes.Num(); ++i)
	{
		if (InputChannelNodes[i] == Node)
			return i;
	}
	return -1;
}

int32 FChannelInterface::GetOutputNodeIndex(FChannelNode* Node)
{
	for (int32 i = 0; i < OutputChannelNodes.Num(); ++i)
	{
		if (OutputChannelNodes[i] == Node)
			return i;
	}
	return -1;
}

void FChannelInterface::SetInputChannelNodeName(int32 NodeIndex, int32 Channel, FName Name)
{
	TMap<int32, FName>& Names = InputChannelNodeNames.FindOrAdd(NodeIndex);
	Names.Add(Channel, Name);
}

void FChannelInterface::SetOutputChannelNodeName(int32 NodeIndex, int32 Channel, FName Name)
{
	TMap<int32, FName>& Names = OutputChannelNodeNames.FindOrAdd(NodeIndex);
	Names.Add(Channel, Name);
}

TMap<int32, FName> FChannelInterface::GetInputChannelNodeName(int32 NodeIndex)
{
	const auto* Name = InputChannelNodeNames.Find(NodeIndex);
	if (!Name)
		return {};
	return *Name;
}

TMap<int32, FName> FChannelInterface::GetOutputChannelNodeName(int32 NodeIndex)
{
	const auto* Name = OutputChannelNodeNames.Find(NodeIndex);
	if (!Name)
		return {};
	return *Name;
}

TMap<int32, FName> FChannelInterface::GetInputChannelNodeName(FChannelNode* Node)
{
	return GetInputChannelNodeName(GetInputNodeIndex(Node));
}

TMap<int32, FName> FChannelInterface::GetOutputChannelNodeName(FChannelNode* Node)
{
	return GetOutputChannelNodeName(GetOutputNodeIndex(Node));
}

void FChannelInterface::RemoveTrack(FMixerTrack* Track)
{
	for (int32 i = 0; i < InputChannelNodes.Num(); ++i)
	{
		if (InputChannelNodes[i]->NodeType == EChannelNodeType::MixerNode)
		{
			FMixerChannelNode* MixerChannelNode = static_cast<FMixerChannelNode*>(InputChannelNodes[i]);
			if (MixerChannelNode->GetTrack() == Track)
			{
				SetInputChannel(i, FNullChannelNode::Get());
			}
		}
	}
	for (int32 i = 0; i < OutputChannelNodes.Num(); ++i)
	{
		if (OutputChannelNodes[i]->NodeType == EChannelNodeType::MixerNode)
		{
			FMixerChannelNode* MixerChannelNode = static_cast<FMixerChannelNode*>(OutputChannelNodes[i]);
			if (MixerChannelNode->GetTrack() == Track)
			{
				SetOutputChannel(i, FNullChannelNode::Get());
			}
		}
	}
}

FMixerChannelInterface::FMixerChannelInterface(FMixerTrack* InMixerTrack) : FChannelInterface(0, 2), MixerTrack(InMixerTrack)
{
	FMixerChannelNode* Node = new FMixerChannelNode(this, MixerTrack, 0);
	SetOutputChannel(0, Node);
}

FMixerChannelInterface::~FMixerChannelInterface()
{
	delete OutputChannelNodes[0];
}