#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <string>
using namespace std::string_literals;
#include <locale>
#include <functional>
#include <cmath>

#include <chrono>
using namespace std::chrono;
using centiseconds = duration<long long, std::centi>;
using deciseconds = duration<long long, std::deci>;
using decaseconds = duration<long long, std::deca>;
#include <ctime>

#define FRC_NO_ICU 1
#include "FRC.h"
#include "path.h"
#include "keyboard.h"
#include "file.h"
#include "rnn.h"
#include "gens.h"

#include "version.h"

/**********************************************************
 * DESIGN:

 * PRIMARY GOALS:

 * Simulate a 2D screen keyboard by a grid representing keys. CHECK
 * Define algorithms to mutate and breed keymaps. CHECK
 * Simulate a trace by drawing lines between keys.
 * Train another evolutionary algorithm to recognize words
   given traces.
 * Use difficulty of training that algorithm as cost function.
 * Use evolutionary algorithm to produce the best keymap.
 * Define a compact human-readable text format to
	represent keymaps.
 * 
 * 
 * 

 * SECONDARY GOALS:

 * Display current best keymap graphically in the terminal
	(using ncurses) dynamically.
 - OR -
 * Display current best keymap graphically using a simple
	graphics library.
**********************************************************/

std::string keymapAdaptor(std::string k, const std::string& ins = "\n")
{
	if (k.length() != 30) {
		std::cerr<<k.length();
		throw std::logic_error("keymaps have 30 keys");
	}
	k.insert(20, ins);
	k.insert(10, ins);
	return k;
}

std::string printKeymap(std::string title, sKeymap k)
{
	std::stringstream buf;
	buf<<title<<": (sp="<<+k.genome.first<<")\n"
		<<keymapAdaptor(keymap(k.exportKeys()))<<std::endl;
	return buf.str();
}

std::string logKeymap(int num, const generations::kInd& k)
{
	std::stringstream buf;
	buf<<"\\smap "<<num+14
		<<" ev_"<<std::setw(2)<<std::setfill('0')<<num+7
		<<"\n    '"<<keymapAdaptor(keymap(k.ind.exportKeys()), "'\n    '")
		<<"' h="<<k.fitness<<std::endl;
	return buf.str();
}

void doNullSamples(
		const std::vector<std::pair<std::string, long long>>& words,
		const sKeymap& k,
		long long weight_bias,
		pcg32_k64& rng)
{
	// decltype(words) words2(words.begin(), words.begin()+WORD_COUNT);
	// std::shuffle(words2.begin(), words2.begin()+WORD_COUNT, rng);
	// words2.resize(SAMPLE_SIZE);
	auto k_s = path::keymapToSpace(k);
	const generations::rnnTestData& nullTestData = std::make_tuple(
		words, weight_bias, k_s.get()
	);
	std::cout<<"Null test scores: "
		<<generations::nullTest<0,1>(nullTestData, rng)<<" - "<<std::flush
		<<generations::nullTest<1,1>(nullTestData, rng)<<" - "<<std::flush
		<<generations::nullTest<1,0>(nullTestData, rng)<<std::endl;
}

int main(int argc, char** argv)
{
	//Test:
	std::string qwerty = "qwertyuiopasdfghjkl  zxcvbnm  ",
		dvorak =          "  pyfgcrl aoeuidhtns qjkxbmwvz",
		alphabetic =      "abcdefghijklmnopqrst  uvwxyz  ",
		inverse =         "  zyxwvu  tsrqponmlkjihgfedcba",
		colemak =         "qwfpgjluy arstdhneio zxcvbkm  ",
		workman =         "qdrwbjfup ashtgyneoi zxmcvkl  ",
		homerow =         "zqfmcuwgjxsiaetonhr  ypdlbkv  ",
		zvud =            "zvudjtncb   pgiqeoxw mklarsfhy",
		deunkja =         "xhwtgloifqdeunkja    bvsycpmrz";
	pcg32_k64 rng{pcg_extras::seed_seq_from<std::random_device>{}};
	sKeymap
		k_qwerty{keymap(qwerty)},
		k_dvorak{keymap(dvorak)},
		k_alpha{keymap(alphabetic)},
		k_inverse{keymap(inverse)},
		k_colemak{keymap(colemak)},
		k_workman{keymap(workman)},
		k_homerow{keymap(homerow)},
		k_zvud{keymap(zvud)},
		k_deunkja{keymap(deunkja)},
		k_random{rng};
	
	assert(argc > 2);
	std::cout<<std::string(argv[1])<<std::endl;
	auto wordsFile = get_file_contents(std::string(argv[1]));
	auto words = files::readWords(wordsFile);
	// std::clog<<"read "<<wordsFile.length()<<" bytes, "<<words.size()<<" words"<<std::endl;
	// for (int i = 0; i < 10 && i < words.size(); ++i) {
		// std::clog<<words[i].first<<": "<<words[i].second<<std::endl;
	// }
	std::ofstream kbLog(argv[2], std::ios_base::out|std::ios_base::app);
	// kbLog<<"# test"<<std::endl;
	// std::clog<<logKeymap(0, {k_random, 0});
	if (argc > 3) {
		generations::maxThreads = fromStr<int>(argv[3]);
	} else {
		generations::maxThreads = std::thread::hardware_concurrency();
	}
	if (generations::maxThreads <= 0) {
		generations::maxThreads = 1;
	}
#if 0
	sKeymap axz = breed(k_alpha, k_inverse),
		axq = breed(k_alpha, k_qwerty),
		axd = breed(k_alpha, k_dvorak),
		qxd = breed(k_qwerty, k_dvorak),
		qxqxd = breed(k_qwerty, qxd),
		axqxd = breed(k_alpha, qxd),
		qxr = breed(k_qwerty, k_random),
		dxr = breed(k_dvorak, k_random);
	sKeymap
		k_q_1 = k_qwerty.mutate(1),
		k_q_4 = k_q_1.mutate(3),
		k_q_8 = k_q_4.mutate(4),
		k_q_16 = k_q_8.mutate(8),
		k_q_52 = k_q_16.mutate(36);
	std::cout
		<<printKeymap("QWERTY",k_qwerty)
		// <<printKeymap("mutate_slow(10)",k_qwerty.mutate_slow(10))
		// <<printKeymap("mutate_fast(10)",k_qwerty.mutate_fast(10))
		// <<printKeymap("mutate(1)",k_q_1)
		// <<printKeymap("mutate(4)",k_q_4)
		// <<printKeymap("mutate(8)",k_q_8)
		// <<printKeymap("mutate(16)",k_q_16)
		// <<printKeymap("mutate(52)",k_q_52)
		// <<printKeymap("mutate(8,8)",k_qwerty.mutate(8).mutate(8))
		<<printKeymap("Dvorak",k_dvorak)
		// <<printKeymap("QWERTY",k_qwerty)
		<<printKeymap("Alpha",k_alpha)
		<<printKeymap("Zyxw",k_inverse)
		<<printKeymap("Alpha × Zyxvw",axz)
		<<printKeymap("Alpha × QWERTY",axq)
		<<printKeymap("Alpha × Dvorak",axd)
		<<printKeymap("QWERTY × Dvorak",qxd)
		<<printKeymap("QWERTY × (QWERTY × Dvorak)",qxqxd)
		<<printKeymap("Alpha × (QWERTY × Dvorak)",axqxd)
		<<printKeymap("Random",k_random)
		<<printKeymap("QWERTY × Random",qxr)
		<<printKeymap("Dvorak × Random",dxr)
		// <<printKeymap("Random × Random",breed(k_random, sKeymap{rng}))
		// <<"Finish"<<std::endl
		;
	std::cout
		<<"dist(QWERTY, Dvorak) = "<<editDistance(qwerty, dvorak)<<std::endl
		<<"dist(Alpha, Zyxw) = "<<editDistance(alphabetic, inverse)<<std::endl
		<<"dist(QWERTY, QWERTY.mutate(4)) = "<<editDistance(qwerty, keymap(k_q_4.exportKeys()))<<std::endl
		;
#endif
#if 0
	//Test
	phenotype p_simple = k_inverse.exportKeys();
	std::string e_simple = keymap(p_simple);
	chromosome g_simple = genomeFromKeys(p_simple);
	phenotype ep_simple = keysFromGenome(g_simple);
	std::string eg_simple = keymap(ep_simple);
	for (int i = 0; i < 30; ++i) {
		std::clog
			<<std::setw(2)<<i<<": "
			<<std::setw(3)<<+p_simple[i]<<" "
			<<e_simple[i]<<" ";
		if (i == 0) {
			std::clog<<std::setw(3)<<+g_simple.first<<" ";
		} else if (i < 4) {
			std::clog<<"    ";
		} else {
			std::clog<<std::setw(3)<<+g_simple.second[i-4]<<" ";
		}
		std::clog<<std::setw(3)<<+ep_simple[i]<<" ";
		if (eg_simple[i] == e_simple[i]) {
			std::clog<<eg_simple[i];
		} else {
			std::clog<<std::toupper(eg_simple[i], std::locale());
		}
		std::clog<<" "<<std::endl;
	}
#endif
	
	//Seed with 8 predetermined and 17 random
	generations::kgen_array cgen = {{
		{k_qwerty, 49100}, {k_dvorak, 61096},
		{k_colemak, 51806}, {k_workman, 67566},
		{k_inverse, 68281}, {k_homerow, 51243},
		{k_zvud, 47837}, {k_deunkja, 39566},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
		{sKeymap{rng}, 0}, {sKeymap{rng}, 0}, {sKeymap{rng}, 0},
	}};
	// for (int i = 0; i < static_cast<signed>(cgen.size()); ++i) {
		// std::cout<<printKeymap(toStr(i), cgen[i]);
	// }
	auto put_time = [](const std::tm* tmb, const char* fmt)
	{
		auto tmp = build<std::array<char, 256>>(std::numeric_limits<unsigned>::lowest);
		std::strftime(tmp.begin(), 256, fmt, tmb);
		return std::string(tmp.begin());
	};
	auto printTime = [&put_time](){
		std::time_t now_c = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
		return " ----------------- "s
			+put_time(std::localtime(&now_c), "%T")
			+" -----------------\n"s;
	};
	std::cout<<printTime()<<std::flush;
	const int WORD_COUNT = 2000,
		SAMPLE_SIZE = 1200,
		rnnGens = 20,
		weight_bias=static_cast<int>(sqrt(words.back().second));
	int r_times = 8;
	int r_gens = rnnGens;
	doNullSamples(buildsample(
			decltype(words){words.begin(), words.begin()+WORD_COUNT},
			SAMPLE_SIZE,
			rng
		), k_random, weight_bias, rng);
	std::cout<<printTime()<<std::flush;
	if (r_times) {
		while (r_times--){
			generations::kInd i_test{k_random};
			decltype(words) words2(words.begin(), words.begin()+WORD_COUNT);
			i_test.test(std::make_tuple(
				r_gens, weight_bias, words2, SAMPLE_SIZE
			), rng);
			std::cout<<printTime()<<std::flush;
		}
		return 0;
	}
	generations::kgen k_gen{std::move(cgen), &rng};
	auto last = high_resolution_clock::now();
	for (int counter = 1; true; ++counter) {
		decltype(words) words2(words.begin(), words.begin()+WORD_COUNT);
		if (counter == 1) {
			k_gen.test<true>(std::make_tuple(
				rnnGens, weight_bias, words2, SAMPLE_SIZE
			));
		} else {
			k_gen.test<true>(std::make_tuple(
				rnnGens, weight_bias, words2, SAMPLE_SIZE
			));
		}
		auto& is = k_gen.exportInds();
		//std::clog<<logKeymap(counter+12, is[0]);
		auto now = high_resolution_clock::now();
		std::cout
			<<printTime()
			<<printKeymap("Best keymap"s, is[0].ind)
			<<"["<<std::setw(2)<<counter<<"]: "
			<<std::setw(4)<<is.front().fitness<<" - "
			<<std::setw(4)<<is.back().fitness<<" (r = "
			<<std::fixed<<std::setprecision(3)<<double(is.back().fitness)/is.front().fitness
			<<") (dt = "<<duration_cast<seconds>(now - last).count()<<"s)"<<std::endl;
		doNullSamples(buildsample(
				words2, SAMPLE_SIZE, rng
			), is[0].ind, weight_bias, rng);
		std::cout<<printTime()<<"Advancing..."<<std::endl;
		last = now;
		k_gen = k_gen.advance(16-counter%16+1);
		std::cout<<printTime()<<std::flush;
	}
}