#include "toonz/txshsoundlevel.h"
#include "tsound_io.h"
#include "toonz/toonzscene.h"
#include "toonz/sceneproperties.h"
#include "toonz/txshleveltypes.h"

#include "tstream.h"
#include "toutputproperties.h"
#include "tconvert.h"

//-----------------------------------------------------------------------------

DEFINE_CLASS_CODE(TXshSoundLevel, 53)

PERSIST_IDENTIFIER(TXshSoundLevel, "soundLevel")

//=============================================================================

TXshSoundLevel::TXshSoundLevel(std::wstring name, int startOffset, int endOffset)
	: TXshLevel(m_classCode, name), m_soundTrack(0), m_duration(0), m_samplePerFrame(0), m_frameSoundCount(0), m_fps(12), m_path()
{
}

//-----------------------------------------------------------------------------

TXshSoundLevel::~TXshSoundLevel()
{
}

//-----------------------------------------------------------------------------

TXshSoundLevel *TXshSoundLevel::clone() const
{
	TXshSoundLevel *sound = new TXshSoundLevel();
	sound->setSoundTrack(m_soundTrack->clone());
	sound->m_duration = m_duration;
	sound->m_path = m_path;
	sound->m_samplePerFrame = m_samplePerFrame;
	sound->m_frameSoundCount = m_frameSoundCount;
	sound->m_fps = m_fps;
	return sound;
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::setScene(ToonzScene *scene)
{
	assert(scene);
	TXshLevel::setScene(scene);
	TOutputProperties *properties = scene->getProperties()->getOutputProperties();
	assert(properties);
	setFrameRate(properties->getFrameRate());
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::loadSoundTrack()
{
	assert(getScene());

	TSceneProperties *properties = getScene()->getProperties();
	if (properties) {
		TOutputProperties *outputProperties = properties->getOutputProperties();
		if (outputProperties)
			m_fps = outputProperties->getFrameRate();
	}
	TFilePath path = getScene()->decodeFilePath(m_path);
	try {
		loadSoundTrack(path);
	} catch (TException &e) {
		throw TException(e.getMessage());
	}
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::loadSoundTrack(const TFilePath &fileName)
{
	try {
		TSoundTrackP st;
		TFilePath path(fileName);
		bool ret = TSoundTrackReader::load(path, st);
		if (ret) {
			m_duration = st->getDuration();
			setName(fileName.getWideName());
			setSoundTrack(st);
		}
	} catch (TException &) {
		return;
	}
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::load()
{
	loadSoundTrack();
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::save()
{
	save(m_path);
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::save(const TFilePath &path)
{
	TSoundTrackWriter::save(path, m_soundTrack);
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::loadData(TIStream &is)
{
	is >> m_name;
	setName(m_name);

	std::string tagName;
	bool flag = false;

	int type = UNKNOWN_XSHLEVEL;

	for (;;) {
		if (is.matchTag(tagName)) {
			if (tagName == "path") {
				is >> m_path;
				is.matchEndTag();
			} else if (tagName == "type") {
				std::string v;
				is >> v;
				if (v == "sound")
					type = SND_XSHLEVEL;
				is.matchEndTag();
			} else
				throw TException("unexpected tag " + tagName);
		} else
			break;
	}
	setType(type);
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::saveData(TOStream &os)
{
	os << m_name;

	std::map<std::string, std::string> attr;
	os.child("type") << L"sound";
	os.child("path") << m_path;
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::computeValues(int frameHeight)
{
	if (frameHeight == 0)
		frameHeight = 1;
	m_values.clear();
	if (!m_soundTrack) {
		m_frameSoundCount = 0;
		m_samplePerFrame = 0;
		return;
	}

	m_samplePerFrame = m_soundTrack->getSampleRate() / m_fps;
	double samplePerPixel = m_samplePerFrame / frameHeight;

	int sampleCount = m_soundTrack->getSampleCount();
	if (sampleCount <= 0) // This was if(!sampleCount)  :(
		return;			  //

	m_frameSoundCount = tceil(sampleCount / m_samplePerFrame);

	double maxPressure = 0.0;
	double minPressure = 0.0;

	m_soundTrack->getMinMaxPressure(
		TINT32(0), (TINT32)sampleCount, TSound::LEFT, minPressure, maxPressure);

	double absMaxPressure = std::max(fabs(minPressure), fabs(maxPressure));

	if (absMaxPressure <= 0)
		return;

	// Adjusting using a fixed scaleFactor
	double weightA = 20.0 / absMaxPressure;

	long i = 0, j;
	long p = 0; //se p parte da zero notazione per pixel,
				//se parte da 1 notazione per frame
	while (i < m_frameSoundCount) {
		for (j = 0; j < frameHeight - 1; ++j) {
			double min = 0.0;
			double max = 0.0;
			m_soundTrack->getMinMaxPressure(
				(TINT32)(i * m_samplePerFrame + j * samplePerPixel),
				(TINT32)(i * m_samplePerFrame + (j + 1) * samplePerPixel - 1),
				TSound::MONO, min, max);
			m_values.insert(std::pair<int, std::pair<double, double>>(p + j, std::pair<double, double>(min * weightA, max * weightA)));
		}

		double min = 0.0;
		double max = 0.0;
		m_soundTrack->getMinMaxPressure(
			(TINT32)(i * m_samplePerFrame + j * samplePerPixel),
			(TINT32)((i + 1) * m_samplePerFrame - 1),
			TSound::MONO, min, max);
		m_values.insert(std::pair<int, std::pair<double, double>>(p + j, std::pair<double, double>(min * weightA, max * weightA)));

		++i;
		p += frameHeight;
	}
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::getValueAtPixel(int pixel, DoublePair &values) const
{
	std::map<int, DoublePair>::const_iterator it = m_values.find(pixel);
	if (it != m_values.end())
		values = it->second;
}

//-----------------------------------------------------------------------------

void TXshSoundLevel::setFrameRate(double fps)
{
	if (m_fps != fps) {
		m_fps = fps;
		computeValues();
	}
}

//-----------------------------------------------------------------------------

int TXshSoundLevel::getFrameCount() const
{
	int frameCount = m_duration * m_fps;
	return (frameCount == 0) ? 1 : frameCount;
}

//-----------------------------------------------------------------------------
//Implementato per utilita'
void TXshSoundLevel::getFids(std::vector<TFrameId> &fids) const
{
	int i;
	for (i = 0; i < getFrameCount(); i++)
		fids.push_back(TFrameId(i));
}