// =====================================================================================
//
//       Filename:  latex_table.cpp
//
//    Description:  generate latex table
//
//        Version:  1.0
//        Created:  2018年 02月 19日 星期一 16:42:17 CST
//       Revision:  none
//       Compiler:  g++
//
//         Author:  Jinkun Lin, jkunlin@gmail.com
//   Organization:  School of EECS, Peking University
//
// =====================================================================================
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <algorithm>
#include <limits>
using namespace std;

bool small = true;

string basename(string name) {
	size_t begin = name.find_last_of('/');
	return name.substr(begin + 1, name.size() - begin);
}

template<class T1, class T2>
bool better(T1 a, T2 b) {
	return small ? a < b : a > b;
}

int main(int argc, char const *argv[]) {
	int solver_count = argc - 1;

	// =====================================================================================
	//      read data from file
	// =====================================================================================
	vector<vector<int>> size_matrix (solver_count);
	vector<vector<double>> time_matrix (solver_count);
	vector<vector<char>> exact_matrix (solver_count);

	for (int i = 0; i < solver_count; ++i) {
		ifstream in_file(argv[i + 1]);
		if (!in_file) {
			std::cout << argv[i + 1] << '\t' <<  i + 1 <<  " file error" << std::endl;
			return 1;
		}
		int seed, size;
		double solver_time;
		char exact;
		while (in_file >> seed >> size >> solver_time >> exact) {
			size_matrix[i].push_back(size);
			time_matrix[i].push_back(solver_time);
			exact_matrix[i].push_back(exact);
		}
		in_file.close();
	}

	// =====================================================================================
	//       caculate data
	// =====================================================================================
	vector<int> best_size (solver_count);
	vector<double> avg_size (solver_count);
	vector<double> avg_time (solver_count);
	vector<int> is_exact (solver_count, 0);

	int g_best_size = small ? std::numeric_limits<int>::max() : 0;
	double g_avg_best_size = small ? std::numeric_limits<double>::max() : 0;
	double g_min_avg_t = std::numeric_limits<double>::max();

	for (int i = 0; i < solver_count; ++i) {
		int okay_count = 0;

		int best_s = size_matrix[i][0];
		double avg_s = size_matrix[i][0];
		double avg_t = time_matrix[i][0];

		if (size_matrix[i][0] != 0) {
			okay_count++;
		}

		for (size_t j = 1; j < size_matrix[i].size(); ++j) {
			if (better(size_matrix[i][j], best_s)) {
				best_s = size_matrix[i][j];
			}

			avg_s += size_matrix[i][j];

			avg_t += time_matrix[i][j];

			if (exact_matrix[i][j] == 'x') {
				is_exact[i] = 1;
			}

			if (size_matrix[i][j] != 0) {
				okay_count++;
			}
		}


		best_size[i] = best_s;
		if (okay_count != 0) {
			avg_size[i] = round(avg_s / okay_count * 100) / 100;
			avg_time[i] = round(avg_t / okay_count * 100) / 100;
		}
		else {
			avg_size[i] = 0;
			avg_time[i] = 0;
		}

		if (okay_count == 0) {
			continue;
		}

		if (better(best_size[i], g_best_size)) {
			g_best_size = best_size[i];
		}
		if (better(avg_size[i], g_avg_best_size)) {
			g_avg_best_size = avg_size[i];
		}
		if (g_min_avg_t > avg_time[i]) {
			g_min_avg_t = avg_time[i];
		}
	}

	// =====================================================================================
	//       generate latex table
	// =====================================================================================
	ofstream out_latex("bold_table.tex", ios::app);
	if (!out_latex) {
		std::cout << "out file error" << std::endl;
		return 1;
	}
	auto bf_write = [&](double d, bool is_bf) {
		if (is_bf) {
			out_latex << "\\textbf{" << d << "}";
		}
		else {
			out_latex << d;
		}
	};
	auto bf_write_time = [&](double d, bool is_bf) {
		if (is_bf) {
			if (d < 0.01) {
				out_latex << "\\boldmath{$<$}\\textbf{0.01}";
			}
			else {
				out_latex << "\\textbf{" << d << "}";
			}
		}
		else {
			if (d < 0.01) {
				out_latex << "$<$0.01";
			}
			else {
				out_latex << d;
			}
		}
	};

	out_latex << basename(argv[1]) << " & ";
	int s_win_count = 0;
	int avg_s_win_count = 0;
	int avg_t_win_count = 0;
	for (int i = 0; i < solver_count; ++i) {
		if (best_size[i] == g_best_size) {
			s_win_count++;
		}
		if (avg_size[i] == g_avg_best_size) {
			avg_s_win_count++;
		}
		if (avg_time[i] == g_min_avg_t) {
			avg_t_win_count++;
		}
	}

	for (int i = 0; i < solver_count; ++i) {
		if (best_size[i] == 0) {
			out_latex << "N/A" << " & " << "N/A";
			if (i == solver_count - 1) {
				out_latex << " \\\\" << std::endl;
			}
			else {
				out_latex << " & ";
			}
			continue;
		}
		// size
		if (best_size[i] != avg_size[i]) {  // max size dosen't equal to avg size
			if (s_win_count != solver_count) {
				bf_write(best_size[i], best_size[i] == g_best_size);
			}
			else {
				bf_write(best_size[i], false);
			}

			out_latex << "(";
			if (avg_s_win_count != solver_count) {
				bf_write(avg_size[i], avg_size[i] == g_avg_best_size);
			}
			else {
				bf_write(avg_size[i], false);
			}
			out_latex << ")";
		}
		else {
			if (s_win_count != solver_count || avg_s_win_count != solver_count) {
				bf_write(best_size[i], best_size[i] == g_best_size || avg_size[i] == g_avg_best_size);
			}
			else {
				bf_write(best_size[i], false);
			}
		}

		if (is_exact[i]) {
			out_latex << "$^*$";
		}

		out_latex << " & ";

		// time
		if (s_win_count == solver_count && avg_s_win_count == solver_count &&
				avg_t_win_count != solver_count) {
			bf_write_time(avg_time[i], avg_time[i] == g_min_avg_t);
		}
		else {
			bf_write_time(avg_time[i], false);
		}

		if (i == solver_count - 1) {
			out_latex << " \\\\" << std::endl;
		}
		else {
			out_latex << " & ";
		}
	}
	out_latex.close();

	// =====================================================================================
	//       generate compare file
	// =====================================================================================
	vector<bool> win (solver_count, false);
	// if (s_win_count != solver_count || avg_s_win_count != solver_count) {
		for (int i = 0; i < solver_count; ++i) {
			if (best_size[i] == g_best_size && avg_size[i] == g_avg_best_size) {
			// if (best_size[i] == g_best_size) {
				win[i] = true;
			}
		}
	// }
	ofstream out_arch("arch.result", ios::app);
	if (!out_arch) {
		std::cout << "arch file error" << std::endl;
		return 1;
	}

	// win
	out_arch << (win[0] ? 1 : 0);
	for (int i = 1; i < solver_count; ++i) {
		out_arch << '\t' << (win[i] ? 1 : 0);
	}
	out_arch << std::endl;

	// time
	out_arch << avg_time[0];
	for (int i = 1; i < solver_count; ++i) {
		out_arch << '\t' <<  avg_time[i];
	}
	out_arch << std::endl;

	// okay solver
	out_arch << (best_size[0] != 0 ? 1 : 0);
	for (int i = 1; i < solver_count; ++i) {
		out_arch << '\t' << (best_size[i] != 0 ? 1 : 0);
	}
	out_arch << endl;

	// exact
	out_arch << (is_exact[0] != 0 ? 1 : 0);
	for (int i = 1; i < solver_count; ++i) {
		out_arch << '\t' << (is_exact[i] != 0 ? 1 : 0);
	}
	out_arch << endl;


	out_arch.close();

	return 0;
}