//
// libtgvoip is free and unencumbered public domain software.
// For more information, see http://unlicense.org or the UNLICENSE file
// you should have received with this source code distribution.
//

#ifndef TGVOIP_NO_DSP
#include "webrtc_dsp/modules/audio_processing/include/audio_processing.h"
#include "webrtc_dsp/api/audio/audio_frame.h"
#endif

#include "controller/audio/EchoCanceller.h"
#include "audio/AudioOutput.h"
#include "audio/AudioInput.h"
#include "tools/logging.h"
#include "VoIPServerConfig.h"
#include <string.h>
#include <stdio.h>
#include <math.h>

using namespace tgvoip;

EchoCanceller::EchoCanceller(bool enableAEC, bool enableNS, bool enableAGC)
{
#ifndef TGVOIP_NO_DSP
	this->enableAEC = enableAEC;
	this->enableAGC = enableAGC;
	this->enableNS = enableNS;
	isOn = true;

	webrtc::Config extraConfig;
#ifdef TGVOIP_USE_DESKTOP_DSP
	extraConfig.Set(new webrtc::DelayAgnostic(true));
#endif

	apm = webrtc::AudioProcessingBuilder().Create(extraConfig);

	webrtc::AudioProcessing::Config config;
	config.echo_canceller.enabled = enableAEC;
#ifndef TGVOIP_USE_DESKTOP_DSP
	config.echo_canceller.mobile_mode = true;
#else
	config.echo_canceller.mobile_mode = false;
#endif
	config.high_pass_filter.enabled = enableAEC;
	config.gain_controller2.enabled = enableAGC;
	apm->ApplyConfig(config);

	webrtc::NoiseSuppression::Level nsLevel;
#ifdef __APPLE__
	switch (ServerConfig::GetSharedInstance()->GetInt("webrtc_ns_level_vpio", 0))
	{
#else
	switch (ServerConfig::GetSharedInstance()->GetInt("webrtc_ns_level", 2))
	{
#endif
	case 0:
		nsLevel = webrtc::NoiseSuppression::Level::kLow;
		break;
	case 1:
		nsLevel = webrtc::NoiseSuppression::Level::kModerate;
		break;
	case 3:
		nsLevel = webrtc::NoiseSuppression::Level::kVeryHigh;
		break;
	case 2:
	default:
		nsLevel = webrtc::NoiseSuppression::Level::kHigh;
		break;
	}
	apm->noise_suppression()->set_level(nsLevel);
	apm->noise_suppression()->Enable(enableNS);
	if (enableAGC)
	{
		apm->gain_control()->set_mode(webrtc::GainControl::Mode::kAdaptiveDigital);
		apm->gain_control()->set_target_level_dbfs(ServerConfig::GetSharedInstance()->GetInt("webrtc_agc_target_level", 9));
		apm->gain_control()->enable_limiter(ServerConfig::GetSharedInstance()->GetBoolean("webrtc_agc_enable_limiter", true));
		apm->gain_control()->set_compression_gain_db(ServerConfig::GetSharedInstance()->GetInt("webrtc_agc_compression_gain", 20));
	}
	apm->voice_detection()->set_likelihood(webrtc::VoiceDetection::Likelihood::kVeryLowLikelihood);

	audioFrame = new webrtc::AudioFrame();
	audioFrame->samples_per_channel_ = 480;
	audioFrame->sample_rate_hz_ = 48000;
	audioFrame->num_channels_ = 1;

	farendQueue = new BlockingQueue<Buffer>(11);
	running = true;
	bufferFarendThread = new Thread(std::bind(&EchoCanceller::RunBufferFarendThread, this));
	bufferFarendThread->SetName("VoipECBufferFarEnd");
	bufferFarendThread->Start();

#else
	this->enableAEC = this->enableAGC = enableAGC = this->enableNS = enableNS = false;
	isOn = true;
#endif
}

EchoCanceller::~EchoCanceller()
{
#ifndef TGVOIP_NO_DSP
	delete apm;
	delete audioFrame;
	farendQueue->Put(Buffer());
	bufferFarendThread->Join();
	delete bufferFarendThread;
#endif
}

void EchoCanceller::Start()
{
}

void EchoCanceller::Stop()
{
}

void EchoCanceller::SpeakerOutCallback(unsigned char *data, size_t len)
{
	if (len != 960 * 2 || !enableAEC || !isOn)
		return;
#ifndef TGVOIP_NO_DSP
	try
	{
		Buffer buf = farendBufferPool.Get();
		buf.CopyFrom(data, 0, 960 * 2);
		farendQueue->Put(std::move(buf));
	}
	catch (std::bad_alloc &x)
	{
		LOGW("Echo canceller can't keep up with real time");
	}
#endif
}

#ifndef TGVOIP_NO_DSP
void EchoCanceller::RunBufferFarendThread()
{
	webrtc::AudioFrame frame;
	frame.num_channels_ = 1;
	frame.sample_rate_hz_ = 48000;
	frame.samples_per_channel_ = 480;
	while (running)
	{
		Buffer buf = farendQueue->GetBlocking();
		if (buf.IsEmpty())
		{
			LOGI("Echo canceller buffer farend thread exiting");
			return;
		}
		int16_t *samplesIn = (int16_t *)*buf;
		memcpy(frame.mutable_data(), samplesIn, 480 * 2);
		apm->ProcessReverseStream(&frame);
		memcpy(frame.mutable_data(), samplesIn + 480, 480 * 2);
		apm->ProcessReverseStream(&frame);
		didBufferFarend = true;
	}
}
#endif

void EchoCanceller::Enable(bool enabled)
{
	isOn = enabled;
}

void EchoCanceller::ProcessInput(int16_t *inOut, size_t numSamples, bool &hasVoice)
{
#ifndef TGVOIP_NO_DSP
	if (!isOn || (!enableAEC && !enableAGC && !enableNS))
	{
		return;
	}
	int delay = audio::AudioInput::GetEstimatedDelay() + audio::AudioOutput::GetEstimatedDelay();
	assert(numSamples == 960);

	memcpy(audioFrame->mutable_data(), inOut, 480 * 2);
	if (enableAEC)
		apm->set_stream_delay_ms(delay);
	apm->ProcessStream(audioFrame);
	if (enableVAD)
		hasVoice = apm->voice_detection()->stream_has_voice();
	memcpy(inOut, audioFrame->data(), 480 * 2);
	memcpy(audioFrame->mutable_data(), inOut + 480, 480 * 2);
	if (enableAEC)
		apm->set_stream_delay_ms(delay);
	apm->ProcessStream(audioFrame);
	if (enableVAD)
	{
		hasVoice = hasVoice || apm->voice_detection()->stream_has_voice();
	}
	memcpy(inOut + 480, audioFrame->data(), 480 * 2);
#endif
}

void EchoCanceller::SetAECStrength(int strength)
{
#ifndef TGVOIP_NO_DSP
	/*if(aec){
#ifndef TGVOIP_USE_DESKTOP_DSP
		AecmConfig cfg;
		cfg.cngMode=AecmFalse;
		cfg.echoMode=(int16_t) strength;
		WebRtcAecm_set_config(aec, cfg);
#endif
	}*/
#endif
}

void EchoCanceller::SetVoiceDetectionEnabled(bool enabled)
{
	enableVAD = enabled;
#ifndef TGVOIP_NO_DSP
	apm->voice_detection()->Enable(enabled);
#endif
}

using namespace tgvoip::effects;

AudioEffect::~AudioEffect()
{
}

void AudioEffect::SetPassThrough(bool passThrough)
{
	this->passThrough = passThrough;
}

Volume::Volume()
{
}

Volume::~Volume()
{
}

void Volume::Process(int16_t *inOut, size_t numSamples)
{
	if (level == 1.0f || passThrough)
	{
		return;
	}
	for (size_t i = 0; i < numSamples; i++)
	{
		float sample = (float)inOut[i] * multiplier;
		if (sample > 32767.0f)
			inOut[i] = INT16_MAX;
		else if (sample < -32768.0f)
			inOut[i] = INT16_MIN;
		else
			inOut[i] = (int16_t)sample;
	}
}

void Volume::SetLevel(float level)
{
	this->level = level;
	float db;
	if (level < 1.0f)
		db = -50.0f * (1.0f - level);
	else if (level > 1.0f && level <= 2.0f)
		db = 10.0f * (level - 1.0f);
	else
		db = 0.0f;
	multiplier = expf(db / 20.0f * logf(10.0f));
}

float Volume::GetLevel()
{
	return level;
}