///////////////////////////////////////////////////////////////////////////////
// Simple x264 Launcher
// Copyright (C) 2004-2014 LoRd_MuldeR <MuldeR2@GMX.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
// http://www.gnu.org/licenses/gpl-2.0.txt
///////////////////////////////////////////////////////////////////////////////

#include "thread_encode.h"

//Internal
#include "global.h"
#include "model_options.h"
#include "model_preferences.h"
#include "model_sysinfo.h"
#include "job_object.h"
#include "binaries.h"

//Encoders
#include "encoder_x264.h"
#include "encoder_x265.h"

//Source
#include "source_avisynth.h"
#include "source_vapoursynth.h"

//Qt Framework
#include <QDate>
#include <QTime>
#include <QDateTime>
#include <QFileInfo>
#include <QDir>
#include <QProcess>
#include <QMutex>
#include <QTextCodec>
#include <QLocale>
#include <QCryptographicHash>

/*
 * RAII execution state handler
 */
class ExecutionStateHandler
{
public:
	ExecutionStateHandler(void)
	{
		x264_set_thread_execution_state(true);
	}
	~ExecutionStateHandler(void)
	{
		x264_set_thread_execution_state(false);
	}
private:
	//Disable copy constructor and assignment
	ExecutionStateHandler(const ExecutionStateHandler &other) {}
	ExecutionStateHandler &operator=(const ExecutionStateHandler &) {}

	//Prevent object allocation on the heap
	void *operator new(size_t);   void *operator new[](size_t);
	void operator delete(void *); void operator delete[](void*);
};

/*
 * Macros
 */
#define CHECK_STATUS(ABORT_FLAG, OK_FLAG) do \
{ \
	if(ABORT_FLAG) \
	{ \
		log("\nPROCESS ABORTED BY USER !!!"); \
		setStatus(JobStatus_Aborted); \
		if(QFileInfo(m_outputFileName).exists() && (QFileInfo(m_outputFileName).size() == 0)) QFile::remove(m_outputFileName); \
		return; \
	} \
	else if(!(OK_FLAG)) \
	{ \
		setStatus(JobStatus_Failed); \
		if(QFileInfo(m_outputFileName).exists() && (QFileInfo(m_outputFileName).size() == 0)) QFile::remove(m_outputFileName); \
		return; \
	} \
} \
while(0)

#define CONNECT(OBJ) do \
{ \
	if((OBJ)) \
	{ \
		connect((OBJ), SIGNAL(statusChanged(JobStatus)),      this, SLOT(setStatus(JobStatus)),      Qt::DirectConnection); \
		connect((OBJ), SIGNAL(progressChanged(unsigned int)), this, SLOT(setProgress(unsigned int)), Qt::DirectConnection); \
		connect((OBJ), SIGNAL(detailsChanged(QString)),       this, SLOT(setDetails(QString)),       Qt::DirectConnection); \
		connect((OBJ), SIGNAL(messageLogged(QString)),        this, SLOT(log(QString)),              Qt::DirectConnection); \
	} \
} \
while(0)

/*
 * Input types
 */
typedef enum
{
	INPUT_NATIVE = 0,
	INPUT_AVISYN = 1,
	INPUT_VAPOUR = 2
};

/*
 * Static vars
 */
//static const char *VPS_TEST_FILE = "import vapoursynth as vs\ncore = vs.get_core()\nv = core.std.BlankClip()\nv.set_output()\n";

///////////////////////////////////////////////////////////////////////////////
// Constructor & Destructor
///////////////////////////////////////////////////////////////////////////////

EncodeThread::EncodeThread(const QString &sourceFileName, const QString &outputFileName, const OptionsModel *options, const SysinfoModel *const sysinfo, const PreferencesModel *const preferences)
:
	m_jobId(QUuid::createUuid()),
	m_sourceFileName(sourceFileName),
	m_outputFileName(outputFileName),
	m_options(new OptionsModel(*options)),
	m_sysinfo(sysinfo),
	m_preferences(preferences),
	m_jobObject(new JobObject),
	m_semaphorePaused(0),
	m_encoder(NULL),
	m_pipedSource(NULL)
{
	m_abort = false;
	m_pause = false;

	//Create encoder object
	switch(options->encType())
	{
	case OptionsModel::EncType_X264:
		m_encoder = new X264Encoder(m_jobObject, m_options, m_sysinfo, m_preferences, m_status, &m_abort, &m_pause, &m_semaphorePaused, m_sourceFileName, m_outputFileName);
		break;
	case OptionsModel::EncType_X265:
		m_encoder = new X265Encoder(m_jobObject, m_options, m_sysinfo, m_preferences, m_status, &m_abort, &m_pause, &m_semaphorePaused, m_sourceFileName, m_outputFileName);
		break;
	default:
		throw "Unknown encoder type encountered!";
	}

	//Create input handler object
	switch(getInputType(QFileInfo(m_sourceFileName).suffix()))
	{
	case INPUT_AVISYN:
		m_pipedSource = new AvisynthSource   (m_jobObject, m_options, m_sysinfo, m_preferences, m_status, &m_abort, &m_pause, &m_semaphorePaused, m_sourceFileName);
		break;
	case INPUT_VAPOUR:
		m_pipedSource = new VapoursynthSource(m_jobObject, m_options, m_sysinfo, m_preferences, m_status, &m_abort, &m_pause, &m_semaphorePaused, m_sourceFileName);
		break;
	}

	//Establish connections
	CONNECT(m_encoder);
	CONNECT(m_pipedSource);
}

EncodeThread::~EncodeThread(void)
{
	X264_DELETE(m_encoder);
	X264_DELETE(m_jobObject);
	X264_DELETE(m_options);
}

///////////////////////////////////////////////////////////////////////////////
// Thread entry point
///////////////////////////////////////////////////////////////////////////////

void EncodeThread::run(void)
{
#if !defined(_DEBUG)
	__try
	{
		checkedRun();
	}
	__except(1)
	{
		qWarning("STRUCTURED EXCEPTION ERROR IN ENCODE THREAD !!!");
	}
#else
	checkedRun();
#endif

	if(m_jobObject)
	{
		m_jobObject->terminateJob(42);
		X264_DELETE(m_jobObject);
	}
}

void EncodeThread::checkedRun(void)
{
	m_progress = 0;
	m_status = JobStatus_Starting;

	try
	{
		try
		{
			ExecutionStateHandler executionStateHandler;
			encode();
		}
		catch(char *msg)
		{
			log(tr("EXCEPTION ERROR IN THREAD: ").append(QString::fromLatin1(msg)));
			setStatus(JobStatus_Failed);
		}
		catch(...)
		{
			log(tr("UNHANDLED EXCEPTION ERROR IN THREAD !!!"));
			setStatus(JobStatus_Failed);
		}
	}
	catch(...)
	{
		x264_fatal_exit(L"Unhandeled exception error in encode thread!");
	}
}

void EncodeThread::start(Priority priority)
{
	qDebug("Thread starting...");

	m_abort = false;
	m_pause = false;

	while(m_semaphorePaused.tryAcquire(1, 0));
	QThread::start(priority);
}

///////////////////////////////////////////////////////////////////////////////
// Encode functions
///////////////////////////////////////////////////////////////////////////////

void EncodeThread::encode(void)
{
	QDateTime startTime = QDateTime::currentDateTime();

	// -----------------------------------------------------------------------------------
	// Print Information
	// -----------------------------------------------------------------------------------

	//Print some basic info
	log(tr("Simple x264 Launcher (Build #%1), built %2\n").arg(QString::number(x264_version_build()), x264_version_date().toString(Qt::ISODate)));
	log(tr("Job started at %1, %2.\n").arg(QDate::currentDate().toString(Qt::ISODate), QTime::currentTime().toString( Qt::ISODate)));
	log(tr("Source file: %1").arg(QDir::toNativeSeparators(m_sourceFileName)));
	log(tr("Output file: %1").arg(QDir::toNativeSeparators(m_outputFileName)));
	
	//Print system info
	log(tr("\n--- SYSTEMINFO ---\n"));
	log(tr("Binary Path: %1").arg(QDir::toNativeSeparators(m_sysinfo->getAppPath())));
	log(tr("Avisynth OK: %1").arg(m_sysinfo->hasAVSSupport() ? tr("Yes") : tr("No")));
	log(tr("VapourSynth: %1").arg(m_sysinfo->hasVPSSupport() ? QDir::toNativeSeparators(m_sysinfo->getVPSPath()) : tr("N/A")));

	//Print encoder settings
	log(tr("\n--- SETTINGS ---\n"));
	log(tr("RC Mode: %1").arg(OptionsModel::rcMode2String(m_options->rcMode())));
	log(tr("Preset:  %1").arg(m_options->preset()));
	log(tr("Tuning:  %1").arg(m_options->tune()));
	log(tr("Profile: %1").arg(m_options->profile()));
	log(tr("Custom:  %1").arg(m_options->customEncParams().isEmpty() ? tr("(None)") : m_options->customEncParams()));
	
	bool ok = false;
	unsigned int frames = 0;
	
	// -----------------------------------------------------------------------------------
	// Check Versions
	// -----------------------------------------------------------------------------------
	
	log(tr("\n--- CHECK VERSION ---\n"));

	//Check encoder version
	bool encoderModified = false;
	const unsigned int encoderRevision = m_encoder->checkVersion(encoderModified);
	CHECK_STATUS(m_abort, (ok = (encoderRevision != UINT_MAX)));
	
	//Print source versions
	m_encoder->printVersion(encoderRevision, encoderModified);

	//Is encoder version suppoprted?
	CHECK_STATUS(m_abort, (ok = m_encoder->isVersionSupported(encoderRevision, encoderModified)));

	if(m_pipedSource)
	{
		//Is source type available?
		CHECK_STATUS(m_abort, (ok = m_pipedSource->isSourceAvailable()));

		//Checking source version
		bool sourceModified = false;
		const unsigned int sourceRevision = m_pipedSource->checkVersion(sourceModified);
		CHECK_STATUS(m_abort, (ok = (sourceRevision != UINT_MAX)));

		//Print source versions
		m_pipedSource->printVersion(sourceRevision, sourceModified);

		//Is source version supported?
		CHECK_STATUS(m_abort, (ok = m_pipedSource->isVersionSupported(sourceRevision, sourceModified)));
	}

	// -----------------------------------------------------------------------------------
	// Detect Source Info
	// -----------------------------------------------------------------------------------

	//Detect source info
	if(m_pipedSource)
	{
		log(tr("\n--- GET SOURCE INFO ---\n"));
		ok = m_pipedSource->checkSourceProperties(frames);
		CHECK_STATUS(m_abort, ok);
	}

	// -----------------------------------------------------------------------------------
	// Encoding Passes
	// -----------------------------------------------------------------------------------

	//Run encoding passes
	if(m_options->rcMode() == OptionsModel::RCMode_2Pass)
	{
		const QString passLogFile = getPasslogFile(m_outputFileName);
		
		log(tr("\n--- ENCODING PASS #1 ---\n"));
		ok = m_encoder->runEncodingPass(m_pipedSource, m_outputFileName, frames, 1, passLogFile);
		CHECK_STATUS(m_abort, ok);

		log(tr("\n--- ENCODING PASS #2 ---\n"));
		ok = m_encoder->runEncodingPass(m_pipedSource, m_outputFileName, frames, 2, passLogFile);
		CHECK_STATUS(m_abort, ok);
	}
	else
	{
		log(tr("\n--- ENCODING VIDEO ---\n"));
		ok = m_encoder->runEncodingPass(m_pipedSource, m_outputFileName, frames);
		CHECK_STATUS(m_abort, ok);
	}

	// -----------------------------------------------------------------------------------
	// Encoding complete
	// -----------------------------------------------------------------------------------

	log(tr("\n--- COMPLETED ---\n"));

	int timePassed = startTime.secsTo(QDateTime::currentDateTime());
	log(tr("Job finished at %1, %2. Process took %3 minutes, %4 seconds.").arg(QDate::currentDate().toString(Qt::ISODate), QTime::currentTime().toString(Qt::ISODate), QString::number(timePassed / 60), QString::number(timePassed % 60)));
	setStatus(JobStatus_Completed);
}

///////////////////////////////////////////////////////////////////////////////
// Misc functions
///////////////////////////////////////////////////////////////////////////////

void EncodeThread::log(const QString &text)
{
	emit messageLogged(m_jobId, text);
}

void EncodeThread::setStatus(const JobStatus &newStatus)
{
	if(m_status != newStatus)
	{
		if((newStatus != JobStatus_Completed) && (newStatus != JobStatus_Failed) && (newStatus != JobStatus_Aborted) && (newStatus != JobStatus_Paused))
		{
			if(m_status != JobStatus_Paused) setProgress(0);
		}
		if(newStatus == JobStatus_Failed)
		{
			setDetails("The job has failed. See log for details!");
		}
		if(newStatus == JobStatus_Aborted)
		{
			setDetails("The job was aborted by the user!");
		}
		m_status = newStatus;
		emit statusChanged(m_jobId, newStatus);
	}
}

void EncodeThread::setProgress(const unsigned int &newProgress)
{
	if(m_progress != newProgress)
	{
		m_progress = newProgress;
		emit progressChanged(m_jobId, m_progress);
	}
}

void EncodeThread::setDetails(const QString &text)
{
	if((!text.isEmpty()) && (m_details.compare(text) != 0))
	{
		emit detailsChanged(m_jobId, text);
		m_details = text;
	}
}

int EncodeThread::getInputType(const QString &fileExt)
{
	int type = INPUT_NATIVE;

	if(fileExt.compare("avs",  Qt::CaseInsensitive) == 0) type = INPUT_AVISYN;
	if(fileExt.compare("avsi", Qt::CaseInsensitive) == 0) type = INPUT_AVISYN;
	if(fileExt.compare("vpy",  Qt::CaseInsensitive) == 0) type = INPUT_VAPOUR;
	if(fileExt.compare("py",   Qt::CaseInsensitive) == 0) type = INPUT_VAPOUR;

	return type;
}

QString EncodeThread::getPasslogFile(const QString &outputFile)
{
	QFileInfo info(outputFile);
	QString passLogFile = QString("%1/%2.stats").arg(info.absolutePath(), info.completeBaseName());
	int counter = 1;

	while(QFileInfo(passLogFile).exists())
	{
		passLogFile = QString("%1/%2_%3.stats").arg(info.absolutePath(), info.completeBaseName(), QString::number(++counter));
	}

	return passLogFile;
}