matrix_thing/include/matrix.hpp

/**
	This file is a part of rexy's matrix bot
	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/>.
*/

#ifndef MATRIX_HPP
#define MATRIX_HPP

#include "raii/curler.hpp"
#include "raii/string.hpp"
#include "raii/rjp_string.hpp"
#include "raii/filerd.hpp"

#include <vector>
#include <functional>

#define HAS_FREEIMAGE
#define HAS_FFMPEG

namespace matrix{
	struct auth_data{
		raii::rjp_string bot_name;
		raii::rjp_string bot_pass;
		raii::rjp_string homeserver;
		raii::rjp_string access_token;

		operator bool(void)const{
			return (bot_name && bot_pass && homeserver);
		}
	};

	struct file_info{
		raii::rjp_string fileurl;
		raii::string filename;
		raii::string mimetype;
		size_t filesize;
	};
	struct image_info : file_info{
		size_t width;
		size_t height;

		raii::rjp_string thumburl;
		size_t thumb_width;
		size_t thumb_height;
		size_t thumbsize;
	};
	struct video_info : public image_info{};
	struct audio_info : public file_info{};

	//enumerate message type but also give a string representation
	class msgtype{
	private:
		const char* m_str;
		const int m_num;
	public:
		constexpr msgtype(const char* s, int n):
			m_str(s), m_num(n){}
		constexpr msgtype(const msgtype&) = default;
		~msgtype(void) = default;
		constexpr msgtype& operator=(const msgtype&) = default;

		constexpr bool operator==(const msgtype& m){
			return m_num == m.m_num;
		}
		constexpr bool operator!=(const msgtype& m){
			return m_num != m.m_num;
		}
		constexpr const char* str(void)const{
			return m_str;
		}
		constexpr operator int(void)const{
			return m_num;
		}
	};
	//class enumeration
	struct msg{
	private:
		enum _types{
			_text, _audio, _video, _file, _image, _other
		};
	public:
		constexpr static msgtype text = msgtype("text", _text);
		constexpr static msgtype audio = msgtype("audio", _audio);
		constexpr static msgtype video = msgtype("video", _video);
		constexpr static msgtype file = msgtype("file", _file);
		constexpr static msgtype image = msgtype("image", _image);
		constexpr static msgtype other = msgtype("other", _other);

		constexpr static const msgtype& from_str(const char* str){
			if(!strcmp(str, "m.text")){
				return text;
			}else if(!strcmp(str, "m.audio")){
				return audio;
			}else if(!strcmp(str, "m.video")){
				return video;
			}else if(!strcmp(str, "m.file")){
				return file;
			}else if(!strcmp(str, "m.image")){
				return image;
			}else{
				return other;
			}
		}
	};

	struct msg_info
	{
		const raii::rjp_string roomid;
		const raii::rjp_string sender;
		const msgtype type;
		const raii::rjp_string body;
		const raii::rjp_string eventid;
	};

	class bot
	{
	private:
		struct mat_url_list{
			mat_url_list(void) = default;
			mat_url_list(const raii::string_base& homeserver, const raii::string_base& access_token);
			mat_url_list(const mat_url_list&) = default;
			mat_url_list(mat_url_list&&) = default;
			mat_url_list& operator=(const mat_url_list&) = default;
			mat_url_list& operator=(mat_url_list&&) = default;

			void repopulate_accesstoken(const raii::string_base& homeserver, const raii::string_base& access_token);
			void repopulate(const raii::string_base& homeserver, const raii::string_base& access_token);
			void invalidate_accesstoken(void);

			raii::string create_room;
			raii::string file_upload;
			raii::string room_list;
			raii::string login;
			raii::string alias_lookup;
			raii::string whoami;

		private:
			static constexpr const char* s_proto = "https://";
		};
	private:
		mutable raii::curler m_curl;     //https access
		raii::string m_useragent;        //useragent to identify our application
		raii::string m_homeserver;       //name of our homeserver
		raii::rjp_string m_access_token; //authentication
		raii::rjp_string m_userid;       //userid including homeserver
		mat_url_list m_urls;

		raii::rjp_string m_next_batch;   //string which tracks where we are in the server history

		std::function<void(const bot&,const msg_info&)> m_message_callback;

	public:
		bot(const auth_data& a, const raii::string_base& useragent);
		bot(const auth_data& a, raii::string&& useragent);
		bot(const bot& b) = default;
		bot(bot&& b) = default;
		~bot(void) = default;

		bot& operator=(const bot&) = default;
		bot& operator=(bot&&) = default;

		//local getter
		const raii::rjp_string& access_token(void)const;
		const raii::rjp_string& userid(void)const;
		const raii::string& useragent(void)const;

		//local setter
		void set_useragent(const raii::string_base&);
		void set_useragent(raii::string&&);

		//networked setter
		void set_display_name(const raii::string_base&);
		void set_profile_picture(const raii::string_base&);


		//networked getter
		raii::rjp_string room_alias_to_id(const raii::string_base& alias)const;
		std::vector<raii::rjp_string> list_rooms(void)const;

		//other networked operations
		raii::string create_room(const raii::string_base& name, const raii::string_base& alias)const;

		//upload media
		file_info upload_file(const raii::string_base& filename)const;
		file_info upload_file(const raii::string_base& filename, const raii::string_base& alias)const;
		image_info upload_image(const raii::string_base& filename)const;
		image_info upload_image(const raii::string_base& filename, const raii::string_base& alias)const;
		video_info upload_video(const raii::string_base& filename)const;
		video_info upload_video(const raii::string_base& filename, const raii::string_base& alias)const;
		audio_info upload_audio(const raii::string_base& filename)const;
		audio_info upload_audio(const raii::string_base& filename, const raii::string_base& alias)const;

		//send messages
		raii::rjp_string send_image(const raii::string_base& room, const image_info& image)const;
		raii::rjp_string send_video(const raii::string_base& room, const video_info& video)const;
		raii::rjp_string send_message(const raii::string_base& room, const raii::string_base& text)const;
		raii::rjp_string send_audio(const raii::string_base& room, const audio_info& audio)const;
		raii::rjp_string send_file(const raii::string_base& room, const file_info& file)const;

		template<class Func>
		void set_sync_callback(Func&& f){
			m_message_callback = std::forward<Func>(f);
		}
		raii::string sync(size_t timeout);
		void logout(void);

	protected:
		void _send_read_receipt(const raii::string_base& roomid, const raii::string_base& eventid)const;
		raii::rjp_string _upload_file(raii::filerd& fp, const raii::curl_llist& header)const;
		raii::rjp_string _send_message(const raii::string_base& room, const raii::string_base& msg)const;
		static size_t _post_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata);
		raii::string _get_curl(const raii::string_base& url)const;
		raii::string _post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const;
		raii::string _put_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const;
		raii::rjp_string _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::rjp_string _get_and_find(const raii::string_base& url, const raii::string_base& search)const;
		raii::rjp_string _curl_reply_search(const raii::string_base& reply, const raii::string_base& search)const;
		void _set_curl_defaults(void)const;
		raii::string _request_access_token(const auth_data& a)const;
		void _acquire_access_token(const auth_data& a);
	};


	auth_data parse_auth_data(RJP_value* root);
}

#endif