#include "serviceWindowGenerationFromText.h"

ServiceWindowGenerationFromText::ServiceWindowGenerationFromText(char* pathFile, int transp, char* id, char* client) {
	this->path_input = pathFile;
	this->transparency = transp;
	this->user_id = id;
	client_type = client;
	running = true;
	finish = false;
	numero_legendas = INT_MAX;
    legendas_enviadas = 0;
	vetor_pts = new vector<int64_t >();
	tradutor = new TradutorPortGlosa();
	extrator_factory = new ExtratorFactory();
    setPathContents();
    running = true;
    finish = false;
	DPRINTF("Done!\n");
}

ServiceWindowGenerationFromText::~ServiceWindowGenerationFromText() {
	free(vetor_pts);
	if (tradutor) delete tradutor;
	if (sincronizador) delete sincronizador;
	if (extratorTXT)delete extratorTXT;
	if (extrator_factory) delete extrator_factory;
    DDDPRINTF("Service Text finalized!\n");
}

void ServiceWindowGenerationFromText::setPathContents() {
   if(strcmp(client_type,DEVELOPER) == 0){
        this->path_contents = PATH_DEVEL;
        this->path_uploads = PATH_DEVEL_UPLOADS;
    }else if(strcmp(client_type, PRODUCTION) == 0){
        ifstream conf_file(PATH_CONF_FILE, ifstream::binary);
        parsingSuccessful = reader.parse(conf_file, root);
        if(!parsingSuccessful){
            throw ServiceException("Fail to parsing param.json");
        }
        string attr = root.get("storage", PATH_VBOX_UPLOADS).asString();
        this->path_contents = new char[MAX_SIZE_PATH];
        strcpy(this->path_contents, attr.c_str());
        this->path_uploads = PATH_VBOX_UPLOADS;
    }else{
        throw ServiceException("Invalid client!");
    }
}

void ServiceWindowGenerationFromText::setPathLibras() {
	char* final_path = new char[MAX_SIZE_PATH];
    strcpy(final_path, this->path_uploads);
    strcat(final_path, this->user_id);
    strcat(final_path, "/video_libras.ts");

    this->path_libras = final_path;
}

void ServiceWindowGenerationFromText::setBackground() {
	if(this->transparency == 0) { //pega dicionario com BackGround opaco
    	sincronizador = new Synchronizer(BASEDIR, EXTENSAO_DICIONARIO, 
         this->path_libras, this->transparency);
    } else { 
    	if(this->transparency == 1) { //pega dicionario com BackGround transparente
    	   sincronizador = new Synchronizer(BASEDIRTRANSP, EXTENSAO_DICIONARIO,
            this->path_libras, this->transparency);
    	}
    }
}

void ServiceWindowGenerationFromText::setSizeOfSubtitles(int sub_size) {
	numero_legendas = sub_size;
    if (legendas_enviadas >= numero_legendas)
    	sincronizador->stop();
}

void ServiceWindowGenerationFromText::notifyTranslator(unsigned char* text) {
    tradutor->traduz(text);   
}

void ServiceWindowGenerationFromText::notifyLine(unsigned char* line) {
   notifyTranslator(line);
}

void ServiceWindowGenerationFromText::notifyEndOfSynchronization() {
    transcodeVideoToMp4();
    this->running = false;
}

void ServiceWindowGenerationFromText::notifyTranslation(vector<string> * glosas) {
    for (int i = 0; i < glosas->size(); i++) {
        locale loc;
        string glosa_lower = "";
        for (int k = 0; k < glosas->at(i).length(); k++){
            glosa_lower += std::tolower(glosas->at(i).at(k), loc);
        }
        sincronizador->recebeglosa(glosa_lower, 1000);
    }
    sincronizador->stop();
    legendas_enviadas++;        
}


void ServiceWindowGenerationFromText::notifyEnd(int line_size) {
    DPRINTF("Service Text recebeu: %d linhas.\n", line_size);
    setSizeOfSubtitles(line_size);
}

bool ServiceWindowGenerationFromText::isRunning() {
	return this->running;
}

bool ServiceWindowGenerationFromText::isFinished() {
	return this->finish;
}

void ServiceWindowGenerationFromText::initialize() {
	DPRINTF("Service Text Initialize.\n");
    extratorTXT = (ExtratorTXT*) extrator_factory->getExtrator(Extrator::TXT);	    
    extratorTXT->addListener(this);
    extratorTXT->setFilePath(path_input);

    setPathLibras();

    tradutor->addListener(this);

    setBackground();

    uint64_t pcr_base = (uint64_t) 1000; //FIXME: macro
    sincronizador->setPCRBase(pcr_base);
    sincronizador->addListener(this);
    sincronizador->Start();

    try{
  	    extratorTXT->initialize();            
    }catch(ExtratorException ex){
        throw ServiceException(ex.getMessage());
    }
    this->Start();
}

void ServiceWindowGenerationFromText::transcodeVideoToMp4(){
	DPRINTF("[AGUARDE] Transcodificando o vídeo de Libras...\n");
    string command = "ffmpeg -i ";
    command.append(path_libras)
    .append(" -qscale 0 -strict experimental -vcodec libx264 -preset fast -r 30 ").append(" -v quiet ")
	.append(path_contents).append(user_id).append(".mp4");
    //printf("[INFO]: Transcodification command -> %s\n", command.c_str());
    system(command.c_str());
}

void ServiceWindowGenerationFromText::Run(){
	while(isRunning()){
		usleep(200000);
	}
	finish = true;
}