#include "crow.h"
#include "crow/http_response.h"
#include "crow/middlewares/cookie_parser.h"
#include "crow/middlewares/session.h"
#include "crow/multipart_view.h"
#include "crow/mustache.h"
#include <pqxx/pqxx>
#include "bcrypt/BCrypt.hpp"

#include <vector>
#include <fstream>
#include <cstdlib>
#include <filesystem>
#include <time.h>

namespace utils
{
	// Katso onko kirjautumistiedot oikein
	bool logged_in(const std::string& name, const std::string& password) {
		const std::string salt = "whatsapp"; // Good enough
		try
		{
			pqxx::connection cx("dbname = postgres user = postgres password = 1234 \
		  hostaddr = 127.0.0.1 port = 5432");
			if (not cx.is_open())
			{
				CROW_LOG_CRITICAL << "Can't open database";
				return false;
			}
			// Connection established
			CROW_LOG_INFO << "Opened database successfully: " << cx.dbname();
			// Etsi kayttajan tiedot
			pqxx::work tx(cx);
			pqxx::result r = tx.exec(
				"SELECT * FROM kayttajat_table "
				"WHERE nimi='" + tx.esc(name) + "'"
				); // pqxx:params too difficult
			tx.commit();
			if (r.size() != 1) {
				CROW_LOG_ERROR << "Unexpected SQL query results";
				return false;
			}
			// Tarkista tiedot
			std::string dbPassword = r[0][2].as<std::string>();
			return BCrypt::validatePassword(password + salt, dbPassword);
		}
		catch (const std::exception &e)
		{
			CROW_LOG_ERROR << e.what();
			return false;
		}
		return true;
	}

	// Generoi satunnainen tiedosto nimi
	std::string fileName(const std::string& fileExtension) {
		const char allowed[] = "abcedfghijklmnopqrstuvwxyz1234567890";
		srand(time(NULL));
		std::string r;
		for (int i = 0; i < 20; ++i) {
			r += allowed[rand() % ((sizeof(allowed) / sizeof(*allowed) - 1) )];
		}
		r += fileExtension;
		return r;
	}
}

struct Asunto {
	const std::string osoite;
	const std::string kuvaPolku;
};

int main()
{
	// Typedef
	using Session = crow::SessionMiddleware<crow::FileStore>;

	// Crow App
	crow::App<crow::CookieParser, Session> app{Session{
		crow::FileStore{"./sessions"}}};
	// Asunnot lista
	std::vector<Asunto> asunnot;
	// "Tietoa meistä"
	std::string info;

	CROW_ROUTE(app, "/")
		.methods("GET"_method, "POST"_method)([&app, &asunnot, &info](const crow::request& req){
		auto& session = app.get_context<Session>(req);

		auto page = crow::mustache::load("index.html");
		crow::json::wvalue asunnotJson;
		for (int i = 0; i < asunnot.size(); ++i) {
			asunnotJson[i]["osoite"] = asunnot.at(i).osoite;
			asunnotJson[i]["kuva"] = asunnot.at(i).kuvaPolku;
		}
		crow::mustache::context ctx({{"asunnot", asunnotJson}, {"tieto", info}});
		// Login homma
		if (session.get("name","_NO_") == "_NO_") {
			ctx["link-text"] = "Kirjaudu";
			ctx["link-link"] = "login";
		} else {
			ctx["link-text"] = "Admin";
			ctx["link-link"] = "admin";
		}
		return page.render(ctx);
	});

	CROW_ROUTE(app, "/login")
		.methods("GET"_method, "POST"_method)([&app](const crow::request& req, crow::response& res){
		auto& session = app.get_context<Session>(req);

		if (req.method == "POST"_method) { // Jos POST request
			if (req.get_body_params().get("name") == nullptr or req.get_body_params().get("pass") == nullptr) {
				CROW_LOG_ERROR << "Incorrect parameters supplied to post request";
				res.redirect("/");
				res.end();
				return;
			}
			// Hanki params
			std::string reqName = req.get_body_params().get("name");
			std::string reqPass = req.get_body_params().get("pass");
			// Tarkista kirjautuminen
			if (utils::logged_in(reqName, reqPass)) {
				CROW_LOG_INFO << "Account: " << reqName << " logged in";
				// Aseta session muuttujat
				session.set("name", reqName);
				// Kun POST request ohi, redirect admin sivulle
				res.redirect("/");
				res.end();
				return;
			}
			else { // Kirjautuminen ei onnistunut
				CROW_LOG_INFO << "Account " << reqName <<  " failed login";
			}
		}
		crow::mustache::context ctx;
		auto page = crow::mustache::load("login.html");
		if (session.contains("name")) { // Näytä kirjautumistiedot jos kirjautunut
			ctx["name"] = session.get("name", "_HELP_");
		}
		res.body = page.render(ctx).body_;
		res.end();
	});

	CROW_ROUTE(app, "/admin")
		.methods("GET"_method, "POST"_method)([&app, &info](const crow::request& req, crow::response& res){
		auto& session = app.get_context<Session>(req);

		if (session.get("name","_NO_") == "_NO_") {
			// Jos ei kirjauduttu sisään, potki pois
			res.redirect("/");
			res.end();
			return;
		}
		// Jatka jos kirjautunut sisään
		if (req.method == "POST"_method) { // Jos POST request
			// Muuta "Tietoa meistä"
			info = req.get_body_params().get("info");
			// Kirjoita tieto info.txt tiedostoon
			std::ofstream infoTxt("info.txt", std::ios::out | std::ios::trunc);
			if (not infoTxt.is_open()) {
				CROW_LOG_ERROR << "Cannot open info.txt";
				res.redirect("/");
				res.code = 500;
				res.end();
				return;
			}
			// Kirjoita
			infoTxt << info + "\n";
			infoTxt.close();
			// Valmista ollaan
			res.redirect("/");
			res.end();
			return;
		}
		// Renderöi sivu
		auto page = crow::mustache::load("admin.html");
		crow::mustache::context ctx({{"info", info}});
		res.body = page.render(ctx).body_;
		res.end();
	});

	CROW_ROUTE(app, "/asunto")
		.methods("GET"_method, "POST"_method)([&app, &asunnot](const crow::request& req, crow::response& res){
		auto& session = app.get_context<Session>(req);

		if (session.get("name","_NO_") == "_NO_") {
			// Jos ei kirjauduttu sisään, potki pois
			res.code = 401;
			res.redirect("/");
			res.end();
			return;
		}
		// Jatka jos kirjautunut sisään
		std::string asuntoOsoite;
		std::string asuntoKuva;
		// Uusi asuntola
		crow::multipart::message_view file_message(req);
		// File upload
		for (const auto& part : file_message.part_map) {
			const auto& part_name = part.first;
			const auto& part_value = part.second;
			CROW_LOG_DEBUG << "Part: " << part_name;
			// Jos teksti
			if (part_name != "image") {
				CROW_LOG_DEBUG << "Value: " << part_value.body; // debug
				asuntoOsoite = part_value.body;
				continue;
			}
			// Jos kuva

			// Extract the file name
			auto headers_it = part_value.headers.find("Content-Disposition");
			if (headers_it == part_value.headers.end()) {
				CROW_LOG_ERROR << "No Content-Disposition found";
				res.code = 400;
				res.redirect("/");
				res.end();
				return;
			}
			auto params_it = headers_it->second.params.find("filename");
			if (params_it == headers_it->second.params.end()) {
				CROW_LOG_ERROR << "Part with name \"image\" should have a file";
				res.code = 400;
				res.redirect("/");
				res.end();
				return;
			}
			const std::filesystem::path reqFile = params_it->second;
			const std::string outfileName = utils::fileName(reqFile.extension());
			const std::filesystem::path outfilePath = "static/images/" + outfileName;
			// Debug info
			for (const auto& part_header : part_value.headers)	{
				const auto& part_header_name = part_header.first;
				const auto& part_header_val = part_header.second;
				CROW_LOG_DEBUG << "Header: " << part_header_name << '=' << part_header_val.value;

				for (const auto& param : part_header_val.params)
				{
					const auto& param_key = param.first;
					const auto& param_val = param.second;
					CROW_LOG_DEBUG << " Param: " << param_key << ',' << param_val;
				}
			}
			// Write file to hard drive
			std::ofstream file(outfilePath);
			if (not file.is_open()) {
				CROW_LOG_ERROR << "Cannot write file";
				res.code = 500;
				res.redirect("/");
				res.end();
				return;
			}
			file << part_value.body;
			file.close();
			CROW_LOG_INFO << "File written to " << outfilePath;
			// Tietokantaa varten
			asuntoKuva = outfileName;
		}
		// Tarkistus
		if (asuntoOsoite.empty() or asuntoKuva.empty()) {
			res.code = 400;
			res.redirect("/");
			res.end();
			return;
		}
		// Lisää SQL tietokantaan
		try
		{
			pqxx::connection cx("dbname = postgres user = postgres password = 1234 \
		  hostaddr = 127.0.0.1 port = 5432");
			if (not cx.is_open())
			{
				CROW_LOG_CRITICAL << "Can't open database";
				res.code = 500;
				res.redirect("/");
				res.end();
				return;
			}
			// Connection established
			CROW_LOG_INFO << "Opened database successfully: " << cx.dbname();
			// Do work
			pqxx::work tx(cx);

			pqxx::result r = tx.exec(
					"INSERT INTO public.asuntolat_table (osoite,kuva)"
					"VALUES ('" + tx.esc(asuntoOsoite) + "','" + tx.esc(asuntoKuva) + "');");
			CROW_LOG_INFO << "Record added to database";
			// Valmista ollaan, nyt vaan päivitetään ramissa olevaa listaa
			const struct Asunto asunto(asuntoOsoite, asuntoKuva);
			asunnot.push_back(asunto);
			tx.commit();
		}
		catch (const std::exception &e)
		{
			CROW_LOG_ERROR << e.what();
			res.code = 500;
			res.redirect("/");
			res.end();
			return;
		}
		// Valmis
		res.code = 200;
		res.redirect("/");
		res.end();
		return;
	});

	// Lue tietokannasta asunnot
	try
	{
		pqxx::connection cx("dbname = postgres user = postgres password = 1234 \
	  hostaddr = 127.0.0.1 port = 5432");
		if (not cx.is_open())
		{
			CROW_LOG_CRITICAL << "Can't open database";
			return EXIT_FAILURE;
		}
		// Connection established
		CROW_LOG_INFO << "Opened database successfully: " << cx.dbname();
		// Do work
		pqxx::work tx(cx);

		pqxx::result r = tx.exec("SELECT * FROM asuntolat_table");

		tx.commit();

		for (auto s : r) {
			const struct Asunto asunto(
				s[0].as<std::string>(),
				s[2].as<std::string>());
			//CROW_LOG_INFO << asunto.osoite << ":" << asunto.kuvaPolku << "\n";
			asunnot.push_back( asunto );
		}
	}
	catch (const std::exception &e)
	{
		CROW_LOG_ERROR << e.what();
		return EXIT_FAILURE;
	}
	// Lue tiedostosta "Tietoa meistä"
	std::ifstream infoTxt("info.txt", std::ios::in);
	if (not infoTxt.is_open()) {
		CROW_LOG_ERROR << "Unable to open info.txt";
		return EXIT_FAILURE;
	}
	std::string line;
	while (getline(infoTxt, line)) {
		info += line += "\n";
	}
	infoTxt.close();

	// :D
	//app.loglevel(crow::LogLevel::Debug);
	app.port(18080).multithreaded().run();
	return EXIT_SUCCESS;
}