#include "libs/http_client/curl_thread_pool_p.h"
#include "picodeparser.h"
#include "pidigest.h"
#include "pihttpclient.h"
#include "pip.h"
#include "pivaluetree_conversions.h"

using namespace PICoutManipulators;
using namespace PIHTTP;


struct SN {
	int _ii;
	complexf _co;
	PIIODevice::DeviceMode m;
};
struct S {
	bool _b;
	int _i;
	float _f;
	PIString str;
	// SN _sn;
	PIVector2D<bool> v2d;
	PIByteArray ba;
	PISystemTime st;
	PINetworkAddress na;
	PIPointd po;
	PILined li;
	PIRectd re;
};

template<>
PIJSON piSerializeJSON(const SN & v) {
	PIJSON ret;
	ret["_ii"] = piSerializeJSON(v._ii);
	ret["_co"] = piSerializeJSON(v._co);
	ret["m"]   = piSerializeJSON(v.m);
	return ret;
}
template<>
PIJSON piSerializeJSON(const S & v) {
	PIJSON ret;
	ret["_b"]  = piSerializeJSON(v._b);
	ret["_i"]  = piSerializeJSON(v._i);
	ret["_f"]  = piSerializeJSON(v._f);
	ret["str"] = piSerializeJSON(v.str);
	// ret["_sn"] = piSerializeJSON(v._sn);
	ret["v2d"] = piSerializeJSON(v.v2d);
	ret["ba"]  = piSerializeJSON(v.ba);
	ret["st"]  = piSerializeJSON(v.st);
	ret["na"]  = piSerializeJSON(v.na);
	ret["po"]  = piSerializeJSON(v.po);
	ret["li"]  = piSerializeJSON(v.li);
	ret["re"]  = piSerializeJSON(v.re);

	return ret;
}

template<>
void piDeserializeJSON(SN & v, const PIJSON & js) {
	v = {};
	piDeserializeJSON(v._ii, js["_ii"]);
	piDeserializeJSON(v._co, js["_co"]);
	piDeserializeJSON(v.m, js["m"]);
}
template<>
void piDeserializeJSON(S & v, const PIJSON & js) {
	v = {};
	piDeserializeJSON(v._b, js["_b"]);
	piDeserializeJSON(v._i, js["_i"]);
	piDeserializeJSON(v._f, js["_f"]);
	piDeserializeJSON(v.str, js["str"]);
	// piDeserializeJSON(v._sn, js["_sn"]);
	piDeserializeJSON(v.v2d, js["v2d"]);
	piDeserializeJSON(v.ba, js["ba"]);
	piDeserializeJSON(v.st, js["st"]);
	piDeserializeJSON(v.na, js["na"]);
	piDeserializeJSON(v.po, js["po"]);
	piDeserializeJSON(v.li, js["li"]);
	piDeserializeJSON(v.re, js["re"]);
}

int main(int argc, char * argv[]) {
	// PIRegularExpression pire("привет"_u8, PIRegularExpression::CaseInsensitive);
	// PIString subj = "the dog ПриВет sat on the cat"_u8;
	// PIRegularExpression pire("^(?<date>\\d\\d)/(?<month>\\d\\d)/(?<year>\\d\\d\\d\\d)$"_u8);
	// PIString subj = "08/12/1985"_u8;

	PIString pat             = "*.Exe";
	PIRegularExpression re_g = PIRegularExpression::fromGlob(pat, PIRegularExpression::CaseInsensitive);
	PIRegularExpression re_p = PIRegularExpression::fromPOSIX(pat, PIRegularExpression::CaseInsensitive);
	PIStringList files       = {
		"(Audio) 20250318-0852-16.8641941.m4a",
		"dxwebsetup.exe",
		"Firefox Installer.exe",
		"LTA8092XS8_R8.pdf",
		"SteamSetup.exe",
		"TBT_1.41.1325.0.exe",
	};
	piCout << "  src pat" << pat.quoted();
	piCout << " Glob pat" << re_g.pattern().quoted();
	piCout << "POSIX pat" << re_p.pattern().quoted();
	piCout << "\nG P File";
	for (auto f: files) {
		piCout << (re_g.match(f) ? 1 : 0) << (re_p.match(f) ? 1 : 0) << f;
	}
	// return 0;
	PIRegularExpression pire("(?:\\/\\/\\s*)?.*\\n?(?:\\bfunction\\b)\\s*(?<name>\\b\\w+\\b)\\s*(?:\\((?<args>[^;()]*?)\\))",
							 PIRegularExpression::Multiline);
	PIString subj = PIString::fromUTF8(PIFile::readAll("telegram.qs", false));

	piCout << "Pattern:" << pire.pattern();
	piCout << "Valid:" << pire.isValid();
	piCout << "Error at" << pire.errorPosition() << ":" << pire.errorString();
	piCout << "Groups count:" << pire.captureGroupsCount();
	piCout << "Named groups:" << pire.captureGroupNames();
	piCout << "";

	auto mr    = pire.matchIterator(subj);
	auto pire2 = pire;

	while (mr.next()) {
		// piCout << "Subject" << subj;
		piCout << "Matched:" << mr.hasMatch();

		piCout << "By number";
		for (int i = 0; i <= pire.captureGroupsCount(); ++i)
			piCout << i << "=" << mr.matchedString(i).trimmed();

		piCout << "By name";
		for (auto g: pire.captureGroupNames())
			piCout << g.quoted() << "=" << mr.matchedString(g);

		piCout << "";
	}

	piCout << "!!!!!!!!!!!!!!!!!";

	pire.match("vfsmndvbjbdlgdvb gdgf");
	pire.match(subj);

	{
		PIVector<complexf> vec;
		vec << complexf{0.1, 0.2} << complexf{-1, 0.5};
		auto js = PIJSON::serialize(vec);
		piCout << vec;
		piCout << js;
		piCout << PIJSON::deserialize<typeof(vec)>(js);
	}

	return 0;
	/*PICodeParser parser;
	parser.parseFile("c:/work/shstk/pip/test_header.h", false);

	for (const auto * e: parser.entities) {
		piCout << e->type << e->name << "{";
		for (const auto & m: e->members) {
			piCout << "   " << m.type << m.name;
		}
		piCout << "}";
	}

	return 0;*/

	// PIJSON j = piSerializeJSON(s);
	// piDeserializeJSON(s, j);
	PIVector<complexf> vec;
	vec << complexf{0.1, 0.2} << complexf{-1, 0.5};
	auto js = PIJSON::serialize(vec);
	piCout << vec;
	piCout << js;
	piCout << PIJSON::deserialize<typeof(vec)>(js);

	/*PIVector<S> s;
	s << S{false, 0, 0.1} << S{true, 1, -10.1};
	PIMap<int, S> m;
	m[1]     = S{false, 0, 0.15};
	m[2]     = S{true, 1, -10.1};
	// m[1]._sn._co = {3, 4};
	PIJSON j = piSerializeJSON(m);
	piCout << j;
	piDeserializeJSON(m, j);
	piCout << m[1]._f;*/
	// piCout << m[1]._sn._co;

	/*PIVector<int> v({-1, 0, 10, 200});
	PIMap<int, float> m({
		{-1,  -0.1 },
		{0,   0.1  },
		{100, 200.2}
	});

	piCout << v;
	piCout << piSerializeJSON(v);
	piDeserializeJSON(v, piSerializeJSON(v));
	piCout << v;
	piCout << m;
	piDeserializeJSON(m, piSerializeJSON(m));
	piCout << piSerializeJSON(m);*/

	return 0;

	/*auto src = PIByteArray::fromAscii("The quick brown fox jumps over the lazy dog");
	auto key = PIByteArray::fromAscii("key");

	PIStringList tnl;
	int max_size = 0;
	for (int t = 0; t < (int)PIDigest::Type::C ount; ++t) {
		tnl << PIDigest::typeName((PIDigest::Type)t);
		max_size = piMaxi(max_size, tnl.back().size_s());
	}
	PIByteArray hs;
	piCout << PIString::fromAscii(src);
	for (int t = 0; t < (int)PIDigest::Type::Count; ++t) {
		hs = PIDigest::calculate(src, (PIDigest::Type)t);
		piCout << tnl[t].expandLeftTo(max_size, ' ') << "->" << hs.toHex();
	}
	for (int t = 0; t < (int)PIDigest::Type::Count; ++t) {
		const int bench_count = 100000;
		PITimeMeasurer tm;
		piForTimes(bench_count) {
			hs = PIDigest::calculate(src, (PIDigest::Type)t);
		}
		auto el = tm.elapsed();
		piCout << tnl[t].expandLeftTo(max_size, ' ') << "time" << el.toMilliseconds();
	}

	// src.clear();
	// crypto_hash_sha512(sout.data(), src.data(), src.size());
	// piCout << "sod:" << sout.toHex();
	// piCout << "512:" << sha5xx(src, initial_512, 64).toHex();
	return 0;*/

	/*PIHTTPServer server;
	server.listen({"127.0.0.1:7777"});
	// server.setBasicAuthRealm("pip");
	// server.setBasicAuthEnabled(true);
	// server.setBasicAuthCallback([](const PIString & u, const PIString & p) -> bool {
	// 	piCout << "basic auth" << u << p;
	// 	return (u == "u" && p == "p");
	// });
	server.registerPath("sendMessage", Method::Post, [](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable {
		return MessageMutable().setCode(Code::Accepted);
	});
	server.registerUnhandled([](const PIHTTP::MessageConst & msg) -> PIHTTP::MessageMutable {
		PIHTTP::MessageMutable ret;
		piCout << "server rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path())
					  .arg(PIHTTP::methodName(msg.method()))
					  .arg(piStringify(msg.arguments()))
					  .arg(PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t  "))
					  .arg(PIString::fromUTF8(msg.body()));
		ret.setCode(PIHTTP::Code::BadRequest);
		ret.setBody(PIByteArray::fromAscii("hello client! 0123456789"));
		piSleep(5.);
		return ret;
	});
	kbd.waitForFinish();
	return 0;*/

	/*PIHTTP::MessageMutable req;
	req.setBody(PIByteArray::fromAscii("hello server!")).addArgument("a0", "val.0").addArgument("a~r1", "знач,1"_u8);
	auto * c = PIHTTPClient::create("http://u:p@127.0.0.1:7777/api", PIHTTP::Method::Get, req);
	c->onFinish([](PIHTTP::MessageConst msg) {
		 piCout << "client rec:\n\tpath: %1\n\tmethod: %2\n\targs: %3\n\theaders: %4\n\tbody: %5\n"_a.arg(msg.path())
					   .arg(PIHTTP::methodName(msg.method()))
					   .arg(piStringify(msg.arguments()))
					   .arg(
						   PIStringList(msg.headers().map<PIString>([](PIString k, PIString v) { return k + " = " + v; })).join("\n\t\t
	")) .arg(PIString::fromUTF8(msg.body()));
	 })
		->onError([c](PIHTTP::MessageConst r) {
			piCout << "error" << (int)r.code();
			piCout << "msg" << c->lastError();
		})
		->onAbort([c](PIHTTP::MessageConst r) {
			piCout << "abort" << (int)r.code();
			piCout << "msg" << c->lastError();
		})
		->start();*/
	auto * c = PIHTTPClient::create(
		PIString("127.0.0.1:7777/%1").arg("sendMessag"),
		Method::Post,
		MessageMutable().addHeader(Header::ContentType, "application/json").setBody(PIByteArray::fromAscii("{hello}")));
	c->onFinish([](const PIHTTP::MessageConst & msg) { piCout << "message finish" << (int)msg.code() << PIString::fromUTF8(msg.body()); })
		->onError([c](const PIHTTP::MessageConst & msg) { piCout << "message error" << c->lastError(); })
		->onAbort([c](const PIHTTP::MessageConst & msg) { piCout << "aborted"; })
		->start();

	piMSleep(1000);
	// CurlThreadPool::instance()->destroy();
	// kbd.enableExitCapture();
	// WAIT_FOR_EXIT
	// kbd.stopAndWait();

	// server.stop();
	c->abort();
	piMSleep(10);

	return 0;

	// piCout << PIString::readableSize(PISystemMonitor::usedRAM());

	/*PIVector<int> vi;
	piForTimes(10) {
		piSleep(2.);
		vi.enlarge(1000000);
		piCout << "now" << vi.size() << vi.capacity();
	}

	piSleep(5.);*/
	/*kbd.enableExitCapture();

	PIHTTPServer server;

	server.setFavicon(PIFile::readAll("logo.png", false));
	// server.setOption(MicrohttpdServer::Option::HTTPSEnabled, true);
	server.listen({"127.0.0.1", 7777});
	// server.listen({"192.168.1.10", 7778});

	server.registerPath("/", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply ret;
		ret.setBody(PIByteArray::fromAscii(pageTitle));
		return ret;
	});

	server.registerPath("/html", MicrohttpdServer::Method::Get, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply ret;
		ret.setBody("<!DOCTYPE html><html><body><p>arg=%1</p></body></html>"_a.arg(r.args.value("a0")).toUTF8());
		return ret;
	});

	server.registerPath("/api", MicrohttpdServer::Method::Put, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply ret;
		ret.setBody(PIByteArray::fromAscii("<!DOCTYPE html><html><body>API</body></html>"));
		return ret;
	});

	server.registerPath("/api/", MicrohttpdServer::Method::Post, [](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply ret;
		ret.setBody("<!DOCTYPE html><html><body>API etry %1</body></html>"_a.arg(r.path).toUTF8());
		ret.setCode(405);
		return ret;
	});

	server.registerUnhandled([](const MicrohttpdServer::Request & r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply ret;
		ret.setBody("<!DOCTYPE html><html><body>Unknown</body></html>"_a.arg(r.path).toUTF8());
		ret.setCode(404);
		return ret;
	});*/

	/*server.setRequestCallback([](MicrohttpdServer::Request r) -> MicrohttpdServer::Reply {
		MicrohttpdServer::Reply rep;
		piCout << "request" << r.path;
		piCout << "  header" << r.headers;
		piCout << "  args" << r.args;
		piCout << "  body" << r.body;
		piCout << "";
		rep.setBody(PIByteArray::fromAscii("[{\"value1\": true, \"value2\": \"ыекштп\"}]"));
		 return rep;
	});*/

	/*piCout << "start" << server.isListen();

	WAIT_FOR_EXIT

	server.stop();*/

	return 0;
}