#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <string.h>


bool only_print = false;
bool keep_tmp_files = false;
using   namespace  std;

class fileinfo {
public:
	float start_time;
	float end_time;
	string start_time_str;
	string end_time_str;
	string name;
};

enum media_type{
	type_audio = 0,
	type_video = 1,
};
vector<fileinfo>  media_files[2];

void run_shell_cmd(const char * cmd)
{
	printf("run command:%s\n", cmd);

	if (!only_print){
		system(cmd);
	}
}

#ifdef WIN32
#include <Windows.h>

char exe_path[MAX_PATH] = { 0 };

int GetExePath()
{
	char path_buffer[MAX_PATH] = "";
	char drive[32] = "";
	char dir[256] = "";
	char fname[64] = "";
	char ext[32] = "";

	GetModuleFileNameA(NULL, path_buffer, 256);
	_splitpath(path_buffer, drive, dir, fname, ext);

	strcpy(exe_path, drive);
	strcat(exe_path, dir);
	return 0;
}
#endif

char cfg_path[1024];

void get_config_path(){
#ifdef WIN32
	GetExePath();
	strcpy(cfg_path, exe_path);
#else
	strcpy(cfg_path, getenv("HOME"));
	strcat(cfg_path, "/merge_av/");
#endif
}

const char * default_vcodec_param = "-vcodec libx264 -level 3.1 -preset veryfast -g 40 -r 20";
const char * default_acodec_param = "-acodec copy";

char vcodec_param[1024];
char acodec_param[1024];

bool first_time_set = false;
float start_time = 0.0f;

void addinfo(string t, string name, bool bstart){
	media_type mtype = name.substr(name.length() - 4, name.length()) == ".aac" ? type_audio : type_video;
	if (bstart) {
		fileinfo f;
		f.start_time = atof(t.c_str());
		f.end_time = f.start_time;
		f.start_time_str = t;
		f.end_time_str = t;
		f.name = name;

		if (!first_time_set) {
			first_time_set = true;
			start_time = f.start_time;
		}

		f.start_time -= start_time;

		media_files[mtype].push_back(f);
	}
	else {
		vector<fileinfo>  & files = media_files[mtype];
		int i;
		for (i = 0; i < files.size(); i++) {
			if (files[i].name == name) {
				files[i].end_time = atof(t.c_str());
				files[i].end_time_str = t;
				files[i].end_time -= start_time;
				break;
			}
		}

		if (i == files.size())
		{
			cout << "\nerror ,file : " << name << "  close but not started!";
		}
	}
}

void split(string str, string separator, vector<string> &result, bool includeEmptyItem = false) {
	result.clear();
	string::size_type position = str.find(separator);
	string::size_type lastPosition = 0;
	int separatorLength = separator.length();

	while (position != str.npos) {
		string s = str.substr(lastPosition, position - lastPosition);
		if (!s.empty() || includeEmptyItem)
			result.push_back(s);
		lastPosition = position + separatorLength;
		position = str.find(separator, lastPosition);
	}
	result.push_back(str.substr(lastPosition, string::npos));
}

void split_audio(fileinfo audio, float audio_start, float duration, char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -i %s -ss %.3f -t %.3f %s %s", audio.name.c_str(), audio_start, duration, acodec_param, destfile);
	run_shell_cmd(buf);
}

void get_video_first_frame_jpeg(fileinfo video, char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -i %s -vframes 1 -ss 0 -f mjpeg -an %s", video.name.c_str(), destfile);
	run_shell_cmd(buf);
}

void merge_audio_pic(fileinfo audio, int nf, fileinfo video, const char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -loop 1 -i %s.jpg -i %d_%s -loop 0 -shortest %s %s %s", video.name.c_str(), nf, audio.name.c_str(), acodec_param, vcodec_param, destfile);
	run_shell_cmd(buf);
}

void merge_audio_pic(fileinfo audio, int nf, const char * picfile, const char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -loop 1 -i %s -i %d_%s -loop 0 -shortest %s %s %s", picfile, nf, audio.name.c_str(), acodec_param, vcodec_param, destfile);
	run_shell_cmd(buf);
}

void merge_audio_pic(fileinfo audio, const char * picfile, const char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -loop 1 -i %s -i %s -loop 0 -shortest %s %s %s", picfile, audio.name.c_str(), acodec_param, vcodec_param, destfile);
	run_shell_cmd(buf);
}

void megre_audio_video(fileinfo audio, int nf, fileinfo video, const char * destfile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -i %d_%s -i %s %s %s %s", nf, audio.name.c_str(), video.name.c_str(), acodec_param, vcodec_param, destfile);
	run_shell_cmd(buf);
}

void concate_files(vector<string > merged_files, const char * destfile)
{
	char buf[2048];
#ifdef WIN32
	sprintf(buf, "copy /B %s ", merged_files[0].c_str());

	for (int i = 1; i < merged_files.size(); i++) {
		strcat(buf, " + /B ");
		strcat(buf, merged_files[i].c_str());
	}
	strcat(buf, " ");
#else
	strcpy(buf, "cat  ");

	for (int i = 0; i < merged_files.size(); i++) {
		strcat(buf, " ");
		strcat(buf, merged_files[i].c_str());
	}
	strcat(buf, "> ");
#endif // WIN32
	strcat(buf, destfile);
	run_shell_cmd(buf);
}

void adjust_dest_timecode(const char * src, const char * dest)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -i %s -acodec copy -vcodec copy %s", src, dest);
	run_shell_cmd(buf);
}

#ifndef WIN32
#include <unistd.h>
#endif


void remove_file(const char * file)
{
#ifdef WIN32
	_unlink(file);
#else
	unlink(file);
#endif
}

void removefiles(vector<string> files)
{
	for (int i = 0; i < files.size(); i++) {
		remove_file(files[i].c_str());
	}
}

float get_video_duration(const char *videofile)
{
	char buf[2048];
	sprintf(buf, "ffmpeg -y -i %s -vcodec copy -an %s.mkv", videofile, videofile);
	run_shell_cmd(buf);
#ifdef WIN32
	sprintf(buf, "ffmpeg -i %s.mkv > %s.txt 2>&1", videofile, videofile);
#else
	sprintf(buf, "ffmpeg -i %s.mkv &> %s.txt", videofile, videofile);
#endif

	run_shell_cmd(buf);

	if (!keep_tmp_files) {
		char buf[2048];
		sprintf(buf, "%s.mkv", videofile);
		remove_file(buf);
	}

	sprintf(buf, "%s.txt", videofile);

	FILE * fp = fopen(buf, "rb");
	if (!fp) {
		printf("\nOpen %s error\n", buf);
		return -1.0;
	}
	fseek(fp, 0l, SEEK_END);
	long file_len = ftell(fp);
	fseek(fp, 0l, SEEK_SET);

	char * content = new char[file_len + 1];
	fread(content, 1, file_len, fp);
	fclose(fp);

	content[file_len] = 0;

	if (!keep_tmp_files) {
		char buf[2048];
		sprintf(buf, "%s.txt", videofile);
		remove_file(buf);
	}

	char * pDuration = strstr(content, "Duration:");
	if (!pDuration){
		printf("\ncan't find 'Duration:' in %s\n", buf);
		delete content;
		return -1.0;
	}

	char * pComma = strstr(pDuration, ",");
	if (!pDuration){
		printf("\ncan't find ',' after 'Duration:' in %s\n", buf);
		delete content;
		return -1.0;
	}
	int len = pComma - pDuration - 10;
	strncpy(content, pDuration + 10, len);
	content[len] = 0;
	vector <string > hms;
	split(content, ":", hms);

	delete content;

	if (hms.size() != 3) {
		printf("\nerro parsing duration  in %s, the duration string is:%s\n", buf, content);
		delete content;
		return -1.0;
	}

	int hour = atoi(hms[0].c_str());
	int minute = atoi(hms[1].c_str());
	float sec = atof(hms[2].c_str());
    
	return hour * 3600 + minute * 60 + sec;
}

void get_duration_from_video_file()
{
	vector<fileinfo>  & filesvideo = media_files[type_video];
	vector<string>  tmp_files;

	bool tmp = only_print;
	only_print = false;


	for (int i = 0; i < filesvideo.size(); i++){ 
		float duration = get_video_duration(filesvideo[i].name.c_str());
		if (duration >= 0.10) {
			printf("file:%s , duration in recording file: %.3f, duration parsed from file: %.3f\n", filesvideo[i].name.c_str(), filesvideo[i].end_time - filesvideo[i].start_time, duration);
			filesvideo[i].end_time = filesvideo[i].start_time + duration;
		}
	}

	only_print = tmp;
}

int process_files(const char * output_dest_file)
{
	vector<fileinfo>  & filesaudio = media_files[type_audio];
	vector<fileinfo>  & filesvideo = media_files[type_video];
	vector<string > merged_files;
	vector<string>  tmp_files;
	int nv = 0;
	int nf = 0;
	char destfile[1024];
	char blank_pic_file[1024];

	strcpy(blank_pic_file, cfg_path);
	strcat(blank_pic_file, "blank.jpg");

	get_duration_from_video_file();

	if (filesvideo.size()) {//has video files
		for (int i = 0; i < filesaudio.size(); i++){  //
			fileinfo audio = filesaudio[i];
			float audio_start = 0;

			for (; nv < filesvideo.size(); nv++) {
				fileinfo video = filesvideo[nv];

				if (video.start_time - audio_start > 0.100) {

					sprintf(destfile, "%d_%s", nf, audio.name.c_str());
					split_audio(audio, audio_start, video.start_time - audio_start, destfile);
					tmp_files.push_back(destfile);

					audio_start = video.start_time;

					sprintf(destfile, "%s.jpg", video.name.c_str());
					get_video_first_frame_jpeg(video, destfile);
					tmp_files.push_back(destfile);

					sprintf(destfile, "%d.ts", nf);
					merge_audio_pic(audio, nf, video, destfile);
					merged_files.push_back(destfile);
					nf++;
				}
				if (nv != filesvideo.size() - 1) {// not the last one
					sprintf(destfile, "%d_%s", nf, audio.name.c_str());
					split_audio(audio, video.start_time, video.end_time - video.start_time, destfile);
					tmp_files.push_back(destfile);

					audio_start = video.end_time;
					sprintf(destfile, "%d.ts", nf);
					megre_audio_video(audio, nf, video, destfile);
					merged_files.push_back(destfile);
					nf++;
				}
				else {
					
					sprintf(destfile, "%d_%s", nf, audio.name.c_str());

					if (audio.end_time - video.end_time < 1.0) {
						split_audio(audio, video.start_time, audio.end_time - video.start_time, destfile);
						tmp_files.push_back(destfile);

						audio_start = video.end_time;

						sprintf(destfile, "%d.ts", nf);
						megre_audio_video(audio, nf, video, destfile);
						merged_files.push_back(destfile);
						nf++;
					}
					else{
						split_audio(audio, video.start_time, video.end_time - video.start_time, destfile);
						tmp_files.push_back(destfile);

						audio_start = video.end_time;

						sprintf(destfile, "%d.ts", nf);
						megre_audio_video(audio, nf, video, destfile);
						merged_files.push_back(destfile);
						nf++;

						sprintf(destfile, "%d_%s", nf, audio.name.c_str());
						split_audio(audio, video.end_time, audio.end_time - video.end_time, destfile);
						tmp_files.push_back(destfile);

						sprintf(destfile, "%d.ts", nf);
						merge_audio_pic(audio, nf, blank_pic_file, destfile);
						merged_files.push_back(destfile);
						nf++;
					}
				}
			}
		}
	}
	else {//only audio

		if (filesaudio.size() == 1){
			fileinfo audio = filesaudio[0];
			merge_audio_pic(audio, blank_pic_file, "dest.ts");
			return 0;
		}

		for (int i = 0; i < filesaudio.size(); i++){
			fileinfo audio = filesaudio[i];
			sprintf(destfile, "%d.ts", nf);
			merge_audio_pic(audio, blank_pic_file, destfile);
			merged_files.push_back(destfile);
			nf++;
		}
	}

	concate_files(merged_files, "m.ts");
	tmp_files.push_back("m.ts");

	adjust_dest_timecode("m.ts", output_dest_file);


	if (!keep_tmp_files) {
		removefiles(tmp_files);
		removefiles(merged_files);
	}

	return 0;
}


int readfile(char * filename)
{
	ifstream fin(filename);
	if (!fin) {
		return -1;
	}
	const int  LINE_LENGTH = 1000;
	char  str[LINE_LENGTH];
	while (fin.getline(str, LINE_LENGTH))
	{
		vector < string > res;
		split(str, " ", res);
		if (res.size() >= 3) {
			if (res[2] == "create"){
				addinfo(res[0], res[1], true);
			}
			else if (res[2] == "close") {
				addinfo(res[0], res[1], false);
			}
		}
	}
	return 0;
}


void load_codec_param()
{
	strcpy(acodec_param, default_acodec_param);
	strcpy(vcodec_param, default_vcodec_param);

	char cfgfile[1024];

	strcpy(cfgfile, cfg_path);
	strcat(cfgfile, "merge_av.cfg");

	ifstream fin(cfgfile);
	if (!fin) {
		return;
	}
	const int  LINE_LENGTH = 1000;
	char  str[LINE_LENGTH];
	str[0] = 0;
	if (fin.getline(str, LINE_LENGTH))
	{
		printf("\nload video codec from %s: %s\n", cfgfile, str);
		strcpy(vcodec_param, str);
	}
	str[0] = 0;
	if (fin.getline(str, LINE_LENGTH))
	{
		printf("load audio codec from %s: %s\n", cfgfile, str);
		strcpy(acodec_param, str);
	}
}

int main(int argc, char * argv[])
{
	if (argc < 2) {
		printf("   merge_av 1.0.0\n");
		printf("   run ffmpeg to merge audio and video files according to the record info file,\nusage:");
		printf("\n   %s record_info_filename [-p] [-k]", argv[0]);
		printf("\n   -p :only print the command,don't run ffmpeg");
		printf("\n   -k :keep the temp files\n");
		return -1;
	}

	if (readfile(argv[1]) < 0) {
		printf("open file: %s error", argv[1]);
		return -2;
	}

	for (int i = 2; i < argc; i++){
		if (!strcmp(argv[i], "-p")){
			only_print = true;
		}
		else if (!strcmp(argv[i], "-k")){
			keep_tmp_files = true;
		}
	}

	get_config_path();

	load_codec_param();

	process_files("dest.ts");

	return 0;
}