/**
	This file is a part of rexy's matrix client
	Copyright (C) 2019 rexy712

	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU Affero General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU Affero General Public License for more details.

	You should have received a copy of the GNU Affero General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "matrix.hpp"

#include <FreeImagePlus.h>

#include "raii/curl_llist.hpp"
#include "raii/static_string.hpp"
#include "raii/filerd.hpp"
#include "fat_strings.hpp"
#include "raii/util.hpp"

#include "libav/frame.hpp"
#include "libav/codec/context.hpp"
#include "libav/fmt/context.hpp"
#include "libav/packet.hpp"

extern "C"{
#  include <libswscale/swscale.h> //sws_scale
#  include <libavutil/imgutils.h> //av_image_alloc
}

#include "common.hpp"

#define THUMB_SIZE 500

namespace matrix{

	auth_data parse_auth_data(RJP_value* root){
		static const char* fields[] = {"username", "password", "homeserver", "access_token"};

		RJP_search_res details[4];
		rjp_search_members(root, 4, fields, details, 0);
		if(!rjp_value_string_length(details[3].value)){
			return auth_data{details[0].value,
			                 details[1].value,
			                 details[2].value,
			                 raii::rjp_string{}};
		}
		return auth_data{details[0].value,
		                 details[1].value,
		                 details[2].value,
		                 details[3].value};
	}

	client::client(const auth_data& a, const raii::string_base& useragent):
		m_curl(),
		m_useragent(useragent),
		m_homeserver(a.homeserver)
	{
		_acquire_access_token(a);
	}
	client::client(const auth_data& a, raii::string&& useragent):
		m_curl(),
		m_useragent(std::move(useragent)),
		m_homeserver(a.homeserver)
	{
		_acquire_access_token(a);
	}

	const raii::rjp_string& client::access_token(void)const{
		return m_access_token;
	}
	const raii::rjp_string& client::userid(void)const{
		return m_userid;
	}
	const raii::string& client::useragent(void)const{
		return m_useragent;
	}
	void client::set_useragent(const raii::string_base& useragent){
		m_useragent = useragent;
	}
	void client::set_useragent(raii::string&& useragent){
		m_useragent = std::move(useragent);
	}

	void client::set_display_name(const raii::string_base& newname){
		raii::string reply = _put_curl(raii::string("{\"displayname\":\"" + newname + "\"}"), m_urls.displayname(), raii::curl_llist());
	}
	void client::set_profile_picture(const raii::string_base& media_url){
		raii::string reply = _put_curl(raii::string("{\"avatar_url\":\"" + media_url + "\"}"), m_urls.profile_picture(), raii::curl_llist());
	}

	raii::rjp_string client::get_display_name(void)const{
		return _get_and_find(m_urls.displayname(), "displayname"_ss);
	}
	raii::rjp_string client::get_profile_picture(void)const{
		return _get_and_find(m_urls.profile_picture(), "avatar_url"_ss);
	}
	raii::rjp_string client::room_alias_to_id(const raii::string_base& alias)const{
		auto tmp = m_curl.encode(alias, alias.length());
		return _get_and_find(raii::string(m_urls.alias_lookup() + tmp), "room_id"_ss);
	}
	std::vector<raii::rjp_string> client::list_rooms(void)const{
		std::vector<raii::rjp_string> ret;
		raii::string reply = _get_curl(m_urls.room_list());
		if(!reply)
			return ret;

		raii::rjp_ptr root(rjp_parse(reply));
		if(!root)
			return ret;

		RJP_search_res res = rjp_search_member(root.get(), "joined_rooms", 0);
		if(!res.value)
			return ret;

		for(RJP_value* v = rjp_get_element(res.value);v;v = rjp_next_element(v)){
			ret.emplace_back(v);
		}
		return ret;
	}

	raii::string client::create_room(const raii::string_base& name, const raii::string_base& alias)const{
		raii::string postdata;
		if(alias)
			postdata = "{\"name\": \"" + raii::json_escape(name) + "\",\"room_alias_name\": \"" + raii::json_escape(alias) + "\"}";
		else
			postdata = "{\"name\": \"" + raii::json_escape(name) + "\"}";

		return _post_curl(postdata, m_urls.create_room(), raii::curl_llist());
	}
	bool client::join_room(const raii::string_base& roomid)const{
		return _post_curl(raii::string(), m_urls.join_room(m_homeserver, m_access_token, m_curl.encode(roomid)), raii::curl_llist());
	}
	bool client::leave_room(const raii::string_base& roomid)const{
		return _post_curl(raii::string(), m_urls.leave_room(m_homeserver, m_access_token, m_curl.encode(roomid)), raii::curl_llist());
	}
	bool client::accept_invite(const membership_info& invite)const{
		return join_room(invite.roomid);
	}
	bool client::reject_invite(const membership_info& invite)const{
		return leave_room(invite.roomid);
	}
	file_info client::upload_file(const raii::string_base& filename)const{
		return upload_file(filename, raii::static_string());
	}
	file_info client::upload_file(const raii::string_base& filename, const raii::string_base& alias)const{
		raii::filerd fd(filename);
		if(!fd) return {};

		return file_info{_upload_file(fd, raii::curl_llist{}), alias ? alias : filename, {}, fd.length()};
	}
	image_info client::upload_image(const raii::string_base& filename)const{
		return upload_image(filename, raii::static_string());
	}
#ifdef HAS_FREEIMAGE
	static std::vector<char> _create_image_thumbnail(fipImage& image, FREE_IMAGE_FORMAT type, size_t target_size){
		image.makeThumbnail(target_size);
		FreeImageIO fileout;
		std::vector<char> buffer;
		fileout.write_proc = [](void* ptr, unsigned int size, unsigned int nmemb, void* fp) -> unsigned int{
			std::vector<char>& buffer = *reinterpret_cast<std::vector<char>*>(fp);
			buffer.insert(buffer.end(), (char*)ptr, ((char*)ptr)+size*nmemb);
			return size*nmemb;
		};
		switch(type){
		case FIF_JPEG:
			return image.saveToHandle(type, &fileout, &buffer, JPEG_QUALITYGOOD | JPEG_SUBSAMPLING_411) ? buffer : std::vector<char>();
		case FIF_PNG:
			return image.saveToHandle(type, &fileout, &buffer, PNG_Z_BEST_COMPRESSION) ? buffer : std::vector<char>();
		default:
			return image.saveToHandle(type, &fileout, &buffer) ? buffer : std::vector<char>();
		};
	}
	static std::vector<char> _load_image_thumbnail_info(fipImage& image, image_info& info, FREE_IMAGE_FORMAT type){
		//create and upload thumbnail
		if(info.width >  THUMB_SIZE || info.height > THUMB_SIZE){
			std::vector<char> thumb_data = _create_image_thumbnail(image, type, THUMB_SIZE);
			if(!thumb_data.size()){
				info.thumb_width = info.width;
				info.thumb_height = info.height;
				info.thumbsize = info.filesize;
			}else{
				info.thumb_width = image.getWidth();
				info.thumb_height = image.getHeight();
				info.thumbsize = thumb_data.size();
				return thumb_data;
			}
		}else{
			info.thumb_width = info.width;
			info.thumb_height = info.height;
			info.thumbsize = info.filesize;
		}
		return {};
	}
	image_info client::upload_image(const raii::string_base& filename, const raii::string_base& alias)const{
		image_info ret;
		FREE_IMAGE_FORMAT type = fipImage::identifyFIF(filename.get());
		ret.mimetype = FreeImage_GetFIFMimeType(type);
		raii::curl_llist header(raii::string("Content-Type: " + ret.mimetype));

		{
			raii::filerd fd(filename, "rb");
			if(!fd)
				return ret;

			ret.filesize = fd.length();
			ret.fileurl  = _upload_file(fd, header);
		}
		fipImage image;
		image.load(filename.get());
		if(!image.isValid())
			return {};
		ret.width    = image.getWidth();
		ret.height   = image.getHeight();
		ret.filename = alias ? alias : filename;
		std::vector<char> thumb_data = _load_image_thumbnail_info(image, ret, type);

		if(thumb_data.size())
			ret.thumburl = _post_and_find(raii::static_string(thumb_data.data(), thumb_data.size()), m_urls.file_upload(), header, "content_uri"_ss);

		return ret;
	}

#else //HAS_FREEIMAGE
	image_info client::upload_image(const raii::string_base& filename, const raii::string_base& alias)const{
		image_info ret = {};
		ret = upload_file(filename, alias);
		return ret;
	}
#endif //HAS_FREEIMAGE
	video_info client::upload_video(const raii::string_base& filename)const{
		return upload_video(filename, raii::static_string());
	}
	audio_info client::upload_audio(const raii::string_base& filename)const{
		return upload_audio(filename, raii::static_string());
	}
#ifdef HAS_FFMPEG
	static libavcodec::context _get_libav_jpg_context(AVRational src, size_t w, size_t h){
		AVCodec* jpg_codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
		libavcodec::context jctx(jpg_codec);
		jctx->pix_fmt = AV_PIX_FMT_YUVJ420P;
		jctx->width = w;
		jctx->height = h;
		jctx->codec_id = AV_CODEC_ID_MJPEG;
		jctx->codec_type = AVMEDIA_TYPE_VIDEO;
		if(src.num == 0 || src.den == 0)
			jctx->time_base = AVRational{1, 30};
		else
			jctx->time_base = src;
		jctx.open();
		return jctx;
	}

	[[maybe_unused]]
	static void _change_color_range(SwsContext* sws_ctx){
		int dummy[4];
		int src_range, dest_range;
		int br, con, sat;
		sws_getColorspaceDetails(sws_ctx, (int**)&dummy, &src_range, (int**)&dummy, &dest_range, &br, &con, &sat);
		const int* coefs = sws_getCoefficients(SWS_CS_DEFAULT);
		src_range = 2;
		sws_setColorspaceDetails(sws_ctx, coefs, src_range, coefs, dest_range, br, con, sat);
	}
	static void _calc_video_thumbnail_dims(size_t target, size_t src_w, size_t src_h, size_t* w, size_t* h){
		size_t target_width = src_w;
		size_t target_height = src_h;
		if(target_width > target_height){
			if(target_width > target){
				target_height = target_height * ((float)target / target_width);
				target_width = target;
			}
		}else{
			if(target_height > target){
				target_width = target_width * ((float)target / target_height);
				target_height = target;
			}
		}
		*w = target_width;
		*h = target_height;
	}
	static libav::packet _create_video_thumbnail(libavfmt::input_context& src, libavcodec::context& src_ctx, int index, size_t targw, size_t targh){
		libavcodec::context jpg_context = _get_libav_jpg_context(src_ctx->time_base, targw, targh);
		libav::frame src_frame(src_ctx->width, src_ctx->height, src_ctx->pix_fmt);
		libav::frame jpg_frame(src_ctx->width, src_ctx->height, jpg_context->pix_fmt);

		libav::packet packet;

		SwsContext* sws_ctx = sws_getContext(src_ctx->width, src_ctx->height, src_ctx->pix_fmt,
		                                     targw, targh, AV_PIX_FMT_YUV420P,
		                                     SWS_BILINEAR, NULL, NULL, NULL);
		//_change_color_range(sws_ctx);

		av_image_alloc(jpg_frame->data, jpg_frame->linesize, targw, targh, jpg_context->pix_fmt, 32);
		jpg_frame.set_freep();
		while(av_read_frame(src, packet) >= 0){
			if(packet->stream_index == index){
				avcodec_send_packet(src_ctx, packet);
				if(avcodec_receive_frame(src_ctx, src_frame) >= 0)
					break;
			}
			av_packet_unref(packet);
		}
		sws_scale(sws_ctx, src_frame->data, src_frame->linesize, 0, src_ctx->height, jpg_frame->data, jpg_frame->linesize);

		sws_freeContext(sws_ctx);

		if(avcodec_send_frame(jpg_context, jpg_frame) < 0){
			return libav::packet(nullptr);
		}
		if(avcodec_receive_packet(jpg_context, packet) < 0){
			return libav::packet(nullptr);
		}
		return packet;
	}
	static raii::string get_libav_mimetype(const libav::fmt::input_context& ctx){
		const char* first = strstr(ctx->iformat->name, ",");
		if(first)
			return raii::string("video/" + raii::static_string(ctx->iformat->name, first - ctx->iformat->name));
		return raii::string("video/" + raii::static_string(ctx->iformat->name));
	}
	video_info client::upload_video(const raii::string_base& filename, const raii::string_base& alias)const{
		video_info ret = {};

		libav::fmt::input_context in(filename);
		if(!in) return {};

		int stream_index = -1;
		for(size_t i = 0;i < in->nb_streams;++i){
			if(in->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO){
				stream_index = i;
				break;
			}
		}
		if(stream_index == -1) return {};

		libavcodec::context src_ctx(in, stream_index);
		if(!src_ctx) return {};

		src_ctx.open();
		if(!src_ctx.is_open()) return {};

		size_t thumbw, thumbh;
		_calc_video_thumbnail_dims(THUMB_SIZE, src_ctx->width, src_ctx->height, &thumbw, &thumbh);
		libav::packet packet = _create_video_thumbnail(in, src_ctx, stream_index, thumbw, thumbh);

		if(packet){
			raii::curl_llist header("Content-Type: image/jpeg");
			ret.thumb_width = thumbw;
			ret.thumb_height = thumbh;
			ret.thumbsize = packet->size;
			ret.thumburl = _post_and_find(raii::static_string((char*)packet->data, packet->size), m_urls.file_upload(), header, "content_uri"_ss);
			packet.reset();
		}

		ret.width = src_ctx->width;
		ret.height = src_ctx->height;
		ret.mimetype = get_libav_mimetype(in);
		src_ctx.reset();
		in.reset();

		raii::curl_llist header(raii::string("Content-Type:" + ret.mimetype));
		header += "Transfer-Encoding: chunked";
		raii::filerd fd(filename);
		if(!fd) return {};
		ret.filesize = fd.length();
		ret.fileurl = _upload_file(fd, header);
		ret.filename = alias ? alias : filename;
		return ret;
	}
	audio_info client::upload_audio(const raii::string_base& filename, const raii::string_base& alias)const{
		audio_info ret = {};

		libav::fmt::input_context in(filename);
		ret.mimetype = get_libav_mimetype(in);
		in.reset();

		raii::curl_llist header(raii::string("Content-Type:" + ret.mimetype));
		raii::filerd fd(filename);
		if(!fd) return {};
		ret.filesize = fd.length();
		ret.fileurl = _upload_file(fd, header);
		ret.filename = alias ? alias : filename;

		return ret;
	}
#else //HAS_FFMPEG
	video_info client::upload_video(const raii::string_base& filename, const raii::string_base& alias)const{
		video_info ret = {};
		ret = upload_file(filename, alias);
		return ret;
	}
	audio_info client::upload_audio(const raii::string_base& filename, const raii::string_base& alias)const{
		audio_info ret = {};
		ret = upload_file(filename, alias);
		return ret;
	}
#endif //HAS_FFMPEG

	raii::rjp_string client::send_file(const raii::string_base& room, const file_info& file)const{
		return _send_message(room, detail::_file_body(file));
	}
	raii::rjp_string client::send_image(const raii::string_base& room, const image_info& image)const{
		return _send_message(room, detail::_image_body(image));
	}
	raii::rjp_string client::send_video(const raii::string_base& room, const video_info& video)const{
		return _send_message(room, detail::_video_body(video));
	}
	raii::rjp_string client::send_audio(const raii::string_base& room, const audio_info& audio)const{
		return _send_message(room, detail::_audio_body(audio));
	}
	raii::rjp_string client::send_message(const raii::string_base& room, const raii::string_base& text)const{
		return _send_message(room, detail::_message_body(text));
	}
	void client::send_typing(const raii::string_base& room, bool active, int timeout)const{
		if(active)
			_put_curl(raii::string("{\"timeout\":" + raii::itostr(timeout) + ",\"typing\":true}"), m_urls.typing(m_homeserver, m_access_token, m_curl.encode(room), m_curl.encode(m_userid)), raii::curl_llist());
		else
			_put_curl("{\"typing\":false}"_ss, m_urls.typing(m_homeserver, m_access_token, m_curl.encode(room), m_curl.encode(m_userid)), raii::curl_llist());
	}

	raii::rjp_string client::redact_event(const raii::string_base& roomid, const raii::string_base& eventid, const raii::string_base& reason)const{
		auto ret = _put_curl(raii::string("{\"reason\":\"" + reason + "\"}"), m_urls.redact(m_homeserver, m_access_token, m_curl.encode(roomid), m_curl.encode(eventid)), raii::curl_llist());
		if(!ret) return {};
		raii::rjp_ptr root(rjp_parse(ret.get()));
		if(!root) return {};

		RJP_search_res res = rjp_search_member(root.get(), "event_id", 0);
		if(!res.value) return {};
		return raii::rjp_string(res.value);
	}
	raii::rjp_string client::redact_event(const raii::string_base& roomid, const raii::string_base& eventid)const{
		return redact_event(roomid, eventid, ""_ss);
	}

	void client::logout(void){
		_get_curl(m_urls.logout(m_homeserver, m_access_token));
		m_urls.invalidate_accesstoken();
	}
	raii::string client::sync(size_t timeout){
		raii::string reply = _get_curl(m_urls.sync(m_homeserver, m_access_token, m_next_batch, raii::itostr(timeout)));

		if(!reply)
			return {};
		raii::rjp_ptr root(rjp_parse(reply));
		if(!root)
			return reply;

		RJP_search_res res = rjp_search_member(root.get(), "next_batch", 0);
		if(!res.value)
			return reply;
		m_next_batch = res.value;

		if(m_raw_callback != nullptr){
			m_raw_callback(*this, root);
		}
		res = rjp_search_member(root.get(), "rooms", 0);
		if(res.value){
			if(m_message_callback != nullptr)
				_handle_messages(res.value);
			if(m_membership_callback != nullptr)
				_handle_membership_events(res.value);
	}
		return reply;
	}


/*******************************
	     Internal functions
********************************/

	void client::_handle_membership_events(RJP_value* rooms){
		RJP_search_res res = rjp_search_member(rooms, "invite", 0);
		if(res.value)
			_handle_invites(res.value);
		res = rjp_search_member(rooms, "join", 0);
		if(res.value)
			_handle_other_membership(res.value);
	}
	static membership_info _membership_info_from_json(RJP_value* event, RJP_value* roomid){
		static constexpr const char* search_terms[] = {"event_id", "sender", "state_key", "unsigned", "type", "origin_server_ts"};
		static constexpr size_t num_searches = sizeof(search_terms)/sizeof(search_terms[0]);
		RJP_search_res results[num_searches] = {};
		rjp_search_members(event, num_searches, search_terms, results, 0);
		for(size_t i = 0;i < num_searches;++i){
			if(!results[i].value)
				return {};
		}
		RJP_search_res age = rjp_search_member(results[3].value, "age", 0);
		if(!age.value) return {};

		raii::rjp_string room_str = rjp_member_name(roomid);
		raii::rjp_string sender_str = results[1].value;
		raii::rjp_string event_str = results[0].value;
		raii::rjp_string eventtype_str = results[4].value;
		raii::rjp_string rec_str = results[2].value;

		return membership_info{std::move(room_str), std::move(sender_str),
		                       std::move(event_str), std::move(eventtype_str),
		                       rjp_value_integer(results[5].value), rjp_value_integer(age.value),
		                       std::move(rec_str)};
	}
	static msg_info _message_info_from_json(RJP_value* event, RJP_value* roomid){
		static constexpr const char* searches[] = {"sender", "content", "event_id", "unsigned", "type", "origin_server_ts"};
		static constexpr size_t num_searches = sizeof(searches)/sizeof(searches[0]);
		RJP_search_res results[num_searches] = {};
		rjp_search_members(event, num_searches, searches, results, 0);
		for(size_t i = 0;i < num_searches;++i){
			if(!results[i].value)
				return msg_info{};
		}
		RJP_search_res msg = rjp_search_member(results[1].value, "msgtype", 0);
		if(!msg.value) return {};
		RJP_search_res body = rjp_search_member(results[1].value, "body", 0);
		if(!body.value) return {};
		RJP_search_res age = rjp_search_member(results[3].value, "age", 0);
		if(!age.value) return msg_info{};
		raii::rjp_string room_str = rjp_member_name(roomid);
		raii::rjp_string sender_str = results[0].value;
		raii::rjp_string eventid_str = results[2].value;
		raii::rjp_string eventtype_str = results[3].value;
		raii::rjp_string msgbody_str = body.value;
		return msg_info{std::move(room_str), std::move(sender_str),
		                std::move(eventid_str), std::move(eventtype_str),
		                rjp_value_integer(results[5].value), rjp_value_integer(age.value),
		                msg::from_str(rjp_value_string(msg.value)), std::move(msgbody_str)};
	}
	void client::_handle_other_membership(RJP_value* join){
		for(RJP_value* roomid = rjp_get_member(join);roomid;roomid = rjp_next_member(roomid)){
			RJP_search_res res = rjp_search_member(roomid, "timeline", 0);
			if(!res.value) continue;
			res = rjp_search_member(res.value, "events", 0);
			if(!res.value) continue;
			for(RJP_value* event = rjp_get_element(res.value);event;event = rjp_next_element(event)){
				membership_info minfo = _membership_info_from_json(event, roomid);
				if(!minfo.roomid) continue;
				if(minfo.eventtype != "m.room.member"_ss) continue;

				m_membership_callback(*this, minfo);
			}
		}
	}
	void client::_handle_invites(RJP_value* invites){
		for(RJP_value* roomid = rjp_get_member(invites);roomid;roomid = rjp_next_member(roomid)){
			RJP_search_res res = rjp_search_member(roomid, "invite_state", 0);
			if(!res.value) continue;
			res = rjp_search_member(res.value, "events", 0);
			if(!res.value) continue;
			for(RJP_value* event = rjp_get_element(res.value);event;event = rjp_next_element(event)){
				membership_info minfo = _membership_info_from_json(event, roomid);
				if(!minfo.roomid) continue;
				m_membership_callback(*this, minfo);
			}
		}
	}
	void client::_handle_messages(RJP_value* messages){
		RJP_search_res res = rjp_search_member(messages, "join", 0);
		if(!res.value) return;
		for(RJP_value* roomid = rjp_get_member(res.value);roomid;roomid = rjp_next_member(roomid)){
			res = rjp_search_member(roomid, "timeline", 0);
			if(!res.value) continue;
			res = rjp_search_member(res.value, "events", 0);
			if(!res.value) continue;
			for(RJP_value* event = rjp_get_element(res.value);event;event = rjp_next_element(event)){
				msg_info minfo = _message_info_from_json(event, roomid);
				m_message_callback(*this, minfo);
			}
		}
	}

	void client::_send_read_receipt(const raii::string_base& roomid, const raii::string_base& eventid)const{
		_post_curl(""_ss, m_urls.read_receipt(m_homeserver, m_access_token, m_curl.encode(roomid), m_curl.encode(eventid)), raii::curl_llist());
	}
	raii::rjp_string client::_upload_file(raii::filerd& fp, const raii::curl_llist& header)const{
		raii::string fileurl;
		m_curl.postreq();
		m_curl.setopt(CURLOPT_POSTFIELDS, NULL);
		m_curl.setopt(CURLOPT_READDATA, (void*)fp.get());
		m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)fp.length());
		m_curl.setopt(CURLOPT_INFILESIZE_LARGE, (curl_off_t)fp.length());
		m_curl.seturl(m_urls.file_upload());
		m_curl.setheader(header);
		m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
		m_curl.setopt(CURLOPT_WRITEDATA, &fileurl);
		CURLcode cres = m_curl.perform();
		m_curl.setopt(CURLOPT_READDATA, NULL);
		if(cres != CURLE_OK)
			return {};

		if(!fileurl)
			return {};

		raii::rjp_ptr root(rjp_parse(fileurl));
		if(!root)
			return {};
		RJP_search_res res = rjp_search_member(root.get(), "content_uri", 0);

		return res.value;
	}
	raii::rjp_string client::_send_message(const raii::string_base& room, const raii::string_base& msg)const{
		raii::rjp_string reply = _post_and_find(
			msg,
			m_urls.send(m_homeserver, m_access_token, m_curl.encode(room)),
			raii::curl_llist(),
			"event_id"_ss);
		return reply;
	}
	size_t client::_post_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
		raii::string* data = reinterpret_cast<raii::string*>(userdata);
		(*data) += ptr;
		return size*nmemb;
	}

	raii::string client::_get_curl(const raii::string_base& url)const{
		raii::string reply;
		m_curl.getreq();
		m_curl.seturl(url);
		m_curl.setheader(raii::curl_llist{});
		m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
		m_curl.setopt(CURLOPT_WRITEDATA, &reply);
		CURLcode res = m_curl.perform();
		if(res != CURLE_OK)
			return {};
		return reply;
	}
	raii::string client::_post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const{
		raii::string reply;
		m_curl.postreq();
		m_curl.setopt(CURLOPT_POSTFIELDS, postdata.get());
		m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)postdata.length());
		m_curl.seturl(url);
		m_curl.setheader(header);
		m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
		m_curl.setopt(CURLOPT_WRITEDATA, &reply);
		CURLcode res = m_curl.perform();
		if(res != CURLE_OK)
			return {};
		return reply;
	}
	struct put_data{
		const char* data;
		size_t len;
	};
	static size_t _put_read_curl_callback(char* buffer, size_t size, size_t nmemb, void* userdata){
		put_data* src = reinterpret_cast<put_data*>(userdata);
		size_t curl_size = size*nmemb;
		size_t to_copy = std::min(curl_size, src->len);
		memcpy(buffer, src->data, to_copy);
		src->len -= to_copy;
		src->data += to_copy;
		return to_copy;
	}
	raii::string client::_put_curl(const raii::string_base& putdata, const raii::string_base& url, const raii::curl_llist& header)const{
		raii::string reply;
		put_data data{putdata.get(), putdata.length()};
		m_curl.putreq();
		m_curl.setopt(CURLOPT_POSTFIELDS, putdata.get());
		m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)putdata.length());
		m_curl.seturl(url);
		m_curl.setheader(header);
		m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
		m_curl.setopt(CURLOPT_WRITEDATA, &reply);
		m_curl.setopt(CURLOPT_READFUNCTION, _put_read_curl_callback);
		m_curl.setopt(CURLOPT_READDATA, &data);
		m_curl.setopt(CURLOPT_INFILESIZE, (curl_off_t)data.len);
		CURLcode res = m_curl.perform();
		m_curl.setopt(CURLOPT_READDATA, NULL);
		m_curl.setopt(CURLOPT_READFUNCTION, NULL);
		if(res != CURLE_OK)
			return {};
		return reply;
	}
	raii::rjp_string client::_post_and_find(const raii::string_base& data, const raii::string_base& url,
	                                     const raii::curl_llist& header, const raii::string_base& target)const
	{
		raii::string reply = _post_curl(data, url, header);
		if(!reply)
			return {};
		return _curl_reply_search(reply, target);
	}
	raii::rjp_string client::_get_and_find(const raii::string_base& url, const raii::string_base& target)const{
		raii::string reply = _get_curl(url);
		if(!reply)
			return {};
		return _curl_reply_search(reply, target);
	}
	raii::rjp_string client::_curl_reply_search(const raii::string_base& reply, const raii::string_base& target)const{
		raii::rjp_ptr root(rjp_parse(reply));
		if(!root)
			return {};
		RJP_search_res res = rjp_search_member(root.get(), target.get(), 0);
		if(rjp_value_type(res.value) != json_string)
			return {};
		return raii::rjp_string(res.value);
	}
	void client::_set_curl_defaults(void)const{
		m_curl.setopt(CURLOPT_BUFFERSIZE, 102400L);
		m_curl.setopt(CURLOPT_NOPROGRESS, 1L);
		m_curl.setuseragent(m_useragent);
		m_curl.setopt(CURLOPT_MAXREDIRS, 50L);
		m_curl.setopt(CURLOPT_FOLLOWLOCATION, 1L);
		m_curl.forcessl(CURL_SSLVERSION_TLSv1_2);
		m_curl.setopt(CURLOPT_TCP_KEEPALIVE, 1L);
		m_curl.setopt(CURLOPT_FAILONERROR, 1L);
	}
	raii::string client::_request_access_token(const auth_data& a)const{
		CURLcode result;
		raii::string postdata("{\"type\":\"m.login.password\", \"user\":\"" + raii::json_escape(a.name) + "\", \"password\":\"" + raii::json_escape(a.pass) + "\"}");
		raii::string reply;

		m_curl.seturl(m_urls.login());
		m_curl.setpostdata(postdata);
		m_curl.postreq();
		m_curl.setopt(CURLOPT_WRITEFUNCTION, _post_reply_curl_callback);
		m_curl.setopt(CURLOPT_WRITEDATA, &reply);

		result = m_curl.perform();

		if(result != CURLE_OK)
			return {};

		return reply;
	}
	void client::_get_new_access_token(const auth_data& a){
			m_urls = mat_url_list(m_homeserver);
			raii::string reply = _request_access_token(a);
			if(!reply)
				return;
			raii::rjp_ptr root(rjp_parse(reply));
			if(!root)
				return;
			RJP_search_res token = rjp_search_member(root.get(), "access_token", 0);
			m_access_token = raii::rjp_string{token.value};
			token = rjp_search_member(root.get(), "user_id", 0);
			m_userid = raii::rjp_string{token.value};
			m_urls.repopulate_accesstoken(m_homeserver, m_access_token);
			m_urls.repopulate_userid(m_homeserver, m_access_token, m_curl.encode(m_userid));
	}
	void client::_acquire_access_token(const auth_data& a){
		_set_curl_defaults();
		if(a.access_token){
			m_access_token = a.access_token;
			raii::string reply;
			m_urls.repopulate_accesstoken(m_homeserver, m_access_token);
			reply = _get_curl(m_urls.whoami());

			if(!reply){
				DEBUG_PRINT("Given access token is invalid! Getting new token\n");
				_get_new_access_token(a);
				return;
			}
			raii::rjp_ptr root(rjp_parse(reply));
			if(!root)
				return;
			RJP_search_res id = rjp_search_member(root.get(), "user_id", 0);
			m_userid = raii::rjp_string(id.value);
			m_urls.repopulate_userid(m_homeserver, m_access_token, m_curl.encode(m_userid));
		}else{
			_get_new_access_token(a);
		}
	}


	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	client::mat_url_list::mat_url_list(const raii::string_base& homeserver){
		_initial_populate(homeserver);
	}
	client::mat_url_list::mat_url_list(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid){
		repopulate(homeserver, access_token, userid);
	}
	void client::mat_url_list::repopulate_accesstoken(const raii::string_base& homeserver, const raii::string_base& access_token){
		m_create_room = s_proto + homeserver + "/_matrix/client/r0/createRoom?access_token=" + access_token;
		m_file_upload = s_proto + homeserver + "/_matrix/media/r0/upload?access_token=" + access_token;
		m_room_list = s_proto + homeserver + "/_matrix/client/r0/joined_rooms?access_token=" + access_token;
		m_whoami = s_proto + homeserver + "/_matrix/client/r0/account/whoami?access_token=" + access_token;
	}
	void client::mat_url_list::repopulate_userid(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid){
		m_displayname = s_proto + homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + access_token;
		m_profile_picture = s_proto + homeserver + "/_matrix/client/r0/profile/" + userid + "/avatar_url?access_token=" + access_token;
	}
	void client::mat_url_list::repopulate(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid){
		_initial_populate(homeserver);
		repopulate_accesstoken(homeserver, access_token);
		repopulate_userid(homeserver, access_token, userid);
	}
	void client::mat_url_list::invalidate_accesstoken(void){
		m_create_room.reset();
		m_file_upload.reset();
		m_room_list.reset();
		m_whoami.reset();
		m_displayname.reset();
		m_profile_picture.reset();
	}
	const raii::string& client::mat_url_list::create_room(void)const{
		return m_create_room;
	}
	const raii::string& client::mat_url_list::file_upload(void)const{
		return m_file_upload;
	}
	const raii::string& client::mat_url_list::room_list(void)const{
		return m_room_list;
	}
	const raii::string& client::mat_url_list::login(void)const{
		return m_login;
	}
	const raii::string& client::mat_url_list::alias_lookup(void)const{
		return m_alias_lookup;
	}
	const raii::string& client::mat_url_list::whoami(void)const{
		return m_whoami;
	}
	const raii::string& client::mat_url_list::displayname(void)const{
		return m_displayname;
	}
	const raii::string& client::mat_url_list::profile_picture(void)const{
		return m_profile_picture;
	}
	raii::string client::mat_url_list::logout(const raii::string_base& homeserver, const raii::string_base& access_token)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/logout?access_token=" + access_token);
	}
	raii::string client::mat_url_list::join_room(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + access_token);
	}
	raii::string client::mat_url_list::leave_room(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + access_token);
	}
	raii::string client::mat_url_list::sync(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& next_batch, const raii::string_base& timeout)const{
		if(!next_batch)
			return raii::string(s_proto + homeserver + "/_matrix/client/r0/sync?access_token=" + access_token + "&timeout=" + timeout);
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/sync?access_token=" + access_token + "&timeout=" + timeout + "&since=" + next_batch);
	}
	raii::string client::mat_url_list::read_receipt(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + access_token);
	}
	raii::string client::mat_url_list::send(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/m.room.message?access_token=" + access_token);
	}
	raii::string client::mat_url_list::redact(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& eventid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + access_token);
	}
	raii::string client::mat_url_list::power_level(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + access_token);
	}
	raii::string client::mat_url_list::presence(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& userid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + access_token);
	}
	raii::string client::mat_url_list::typing(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid, const raii::string_base& userid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + userid + "?access_token=" + access_token);
	}
	raii::string client::mat_url_list::kick(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + access_token);
	}
	raii::string client::mat_url_list::ban(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + access_token);
	}
	raii::string client::mat_url_list::unban(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + access_token);
	}
	raii::string client::mat_url_list::invite(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + access_token);
	}
	raii::string client::mat_url_list::room_members(const raii::string_base& homeserver, const raii::string_base& access_token, const raii::string_base& roomid)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/rooms/" + roomid + "/members?access_token=" + access_token);
	}
	raii::string client::mat_url_list::password(const raii::string_base& homeserver, const raii::string_base& access_token)const{
		return raii::string(s_proto + homeserver + "/_matrix/client/r0/account/password?access_token=" + access_token);
	}
	void client::mat_url_list::_initial_populate(const raii::string_base& homeserver){
		m_alias_lookup = s_proto + homeserver + "/_matrix/client/r0/directory/room/";
		m_login = s_proto + homeserver + "/_matrix/client/r0/login";
	}

}