#include <fstream>
#include <stdio.h>
#include <string.h>
#include <sstream>
#include <stdlib.h>

#include <lavidlib/io/FileIO.h>

#include <recognize.h>

#define FREQUENCY_PATTERN 22050
#define INPUT_PATTERN 1 /* 1 = Raw file, 2 = Mic */
#define BLOCS_PATTERN 10
#define SIZE_BUFFER 256

#define PATH_AUDIO_ORIGIN "/home/gtaaas/gtaaas/recognize/src/audio/origin/audio_origin.wav"
#define PATH_AUDIO_PARTS "/home/gtaaas/gtaaas/recognize/src/audio/parts/"
#define FILENAME_RECOGNIZED_OUT "/home/gtaaas/gtaaas/recognize/src/audio/recognized.out"
#define FILENAME_AUDIOPART "audio00"
#define FILENAME_AUDIOLIST "/home/gtaaas/gtaaas/recognize/src/audio/audiolist"
#define FILENAME_FILTEROUT "/home/gtaaas/gtaaas/recognize/src/audio/filter"
#define PROGRAM "ffmpeg" // ffmpeg
#define FIND_SENTENCE "\"pass1_best:\""
#define PTS_PATTERN 1000


using namespace std;


Recognize::Recognize(char* _pathVideo) {
	
	listeners = new list<RecognizeListener*>();
	pathVideo = _pathVideo;
	inputType = INPUT_PATTERN;
	frequency = FREQUENCY_PATTERN;
	sizeBlocs = BLOCS_PATTERN;
    DPRINTF("Done!\n");


}


Recognize::Recognize(char* _pathVideo, int _inputType) {

	listeners = new list<RecognizeListener*>();
	pathVideo = _pathVideo;
	inputType = _inputType;
	frequency = FREQUENCY_PATTERN;
	sizeBlocs = BLOCS_PATTERN;
    DPRINTF("Done!\n");


}


Recognize::~Recognize() {

}


void Recognize::initializeRecognition() {
	
	DDPRINTF("Recognizing...\n");
	/**printf("*** Initialized Recognition ***\n\nVideo: %s\nType [1-File; 2-Mic]: %d\nFrequency: %d\n\n", 
		this->pathVideo, this->inputType, this->frequency);**/
	
	
	finished = false;

	extractAudioFromVideo();
	
	breakVideoParts(getTimeMediaSec());
	
	executeJuliusEngine();

	std::list<char*> *list_sentences;
	list_sentences = filterOutputJulius();
	
	std::list<char*>::iterator it;
	for (it = list_sentences->begin(); it != list_sentences->end(); it++)
		notifyListeners((*it));
	
	//printf("\n\nFINALIZANDO RECONHECIMENTO... \nRecognize::initializeRecognition()\n\n");	
	finished = true;
	cleanFiles();
    DDDPRINTF("Recognize finalized!\n");

	

}


void Recognize::setFrequency(int freq) {
	frequency = freq;
}


void Recognize::setSizeAudioBlocs(int sec) {
	sizeBlocs = sec;
}


char* Recognize::extractAudioFromVideo() {

	string command = PROGRAM;
	command.append(" -i ").
	append((string) pathVideo).
	append(" -ar ");
	
	string strFreq;
	std::stringstream sstr;
	sstr << frequency;
	strFreq = sstr.str();

	//command.append(strFreq).append(" -ac 1 -f wav ").append(PATH_AUDIO_ORIGIN).append(" &");
	command.append(strFreq).
	append(" -ac 1 -f wav ").
	append(PATH_AUDIO_ORIGIN).
	append(" -v quiet");

	/*string tmp = "echo ";
	tmp.append(PATH_AUDIO_ORIGIN).append(" >> ").append(FILENAME_AUDIOLIST);
	system(tmp.c_str());*/

	system(command.c_str());

}


int Recognize::getTimeMediaSec() {
	
	string command = PROGRAM;
	command.append(" -i ").append(PATH_AUDIO_ORIGIN);
	command.append(" 2>&1 | grep Duration >> outfile");
	system(command.c_str());
	
	ifstream in("outfile");
	if (!in) return -1;
	std::string line;
	in >> line >> line;

	char* timetok;
	timetok = strtok((char*)line.c_str(), " :,.");
	int seconds = 0;
	
	seconds += (atoi(timetok) * 60 * 60); // hora
	timetok = strtok(NULL, " :,.");	
	seconds += (atoi(timetok) * 60); // min
	timetok = strtok(NULL, " :,.");
	seconds += atoi(timetok); // seg
	system("rm outfile");
	
	return seconds;

}

void Recognize::breakVideoParts(int timeTotal) {

	string ss_str, t_str, command, aplist;
	int count = 1;
	int ss = 0;
	int t = 0;
	bool consume = true;

	string filename = FILENAME_AUDIOPART;
	char tmp [filename.length()];
	sprintf(tmp, "%i", ss);
	ss_str = tmp;

	sprintf(tmp, "%i", sizeBlocs);
	t_str = tmp;

	if (timeTotal < sizeBlocs)
		sizeBlocs = timeTotal;

	do {
		ss = t;
		if(timeTotal >= sizeBlocs && (timeTotal - sizeBlocs) > (sizeBlocs/2)) {			
			t += sizeBlocs;
			timeTotal -= sizeBlocs;
		} else {
			t += timeTotal;
			timeTotal = 0;
			consume = false;
			sprintf(tmp, "%i", t);
			t_str = tmp;
		}
		sprintf(tmp, "%i", ss);
		ss_str = tmp;

		command = "sox ";
		command.append(PATH_AUDIO_ORIGIN).append(" ").append(PATH_AUDIO_PARTS);
		sprintf(tmp, "%i", count++);
		filename.append(tmp).append(".wav");
		command.append(filename).append(" trim ").append(ss_str).append(" ").append(t_str);

		//printf("command: %s\n", command.c_str());
		system(command.c_str());

		string apcomm = "echo ";
		apcomm.append(PATH_AUDIO_PARTS).append(filename).append(" >> ").append(FILENAME_AUDIOLIST);
		system(apcomm.c_str());		

		filename = FILENAME_AUDIOPART;
		aplist = "";

	} while (consume);

}


void Recognize::executeJuliusEngine() {	

	string command, type, freqStr;
	char cfreq[10];

	command = "julius -C ~/gtaaas/recognize/src/julius.jconf -input ";
	if (inputType == 1) {
		type = "rawfile";
		command.append(type).append(" -filelist ").append(FILENAME_AUDIOLIST);
	} else { 
		type = "mic";
	}	
	sprintf(cfreq, "%i", frequency);
	command.append(" -smpFreq ").
	append(cfreq).
	append(" -1pass -nolog -quiet >> ").
	append(FILENAME_RECOGNIZED_OUT);

	//printf("\n\nCommand for executeJuliusEngine: %s\n", command.c_str());
	//printf("Recognizing...\n");
	system(command.c_str());	

}


std::list<char*>* Recognize::filterOutputJulius() {

	std::list<char*> *sentences;
	sentences = new std::list<char*>();
	
	string command = "cat ";
	command.append(FILENAME_RECOGNIZED_OUT).append(" | grep ").
			append(FIND_SENTENCE).append(" >> ").append(FILENAME_FILTEROUT);

	system(command.c_str());
	//printf("\n\n---> command: %s\n\n", command.c_str());

	int count_lines = 0;

	ifstream in(FILENAME_FILTEROUT);	
	string strFilter;

	if (!in) {
		perror("Error: ");
	} else {		
		string line;
		int sizeLine;
		char* sentence_ptr;
		do {
			getline(in, line);
			if (line.length() > 0) {
				sizeLine = (int)line.length();
				strFilter = line.substr(strlen(FIND_SENTENCE), sizeLine);
				sentence_ptr = new char[strFilter.length()+1];
				strcpy(sentence_ptr, (char*) strFilter.c_str());
				sentences->push_back(sentence_ptr);
			}
		} while (!in.eof());
		in.close();
	}

	/*char* ptr_strFilter;
	ptr_strFilter = (char*) malloc (strFilter.length()+1);	
	strcpy(ptr_strFilter, (char*) strFilter.c_str());*/

	return sentences;

}


void Recognize::notifyListeners(char* text) {

	int64_t pts = PTS_PATTERN;
	for(list<RecognizeListener*>::iterator it = listeners->begin(); it != listeners->end(); it++){
		//printf("\nRecognized: notifyTextRecognized... %s\n", text);		
		(*it)->notifyTextRecognized((unsigned char*) text, pts);
	}

}


void Recognize::addListener(RecognizeListener* listener) {
	//printf("\nRecognize::addListener\n");
	listeners->push_back(listener);
}


bool Recognize::isFinished() {
	return finished;
}


void Recognize::cleanFiles() {

	string command = "rm ";
    command.append(PATH_AUDIO_ORIGIN).append(" ").
	append(FILENAME_AUDIOLIST).append(" ").
	append(FILENAME_FILTEROUT).append(" ").
	append(PATH_AUDIO_PARTS).append("* ").
	append(FILENAME_RECOGNIZED_OUT);
    system(command.c_str());

}