#include <iostream>
#include <fstream>
#include <string>
#include <stdexcept>
#include <sstream>

#include <giomm.h>
#include <glibmm.h>

using namespace std;



int main(int argc,char * argv[])
{

	if(argc<3)
	{
		throw runtime_error("No enough parameters");
	}
	
	string source(argv[1]);
	string destination(argv[2]);
	


	Glib::init();
	Gio::init();

	Glib::RefPtr<Gio::DBus::Connection> connection = Gio::DBus::Connection::get_sync(Gio::DBus::BUS_TYPE_SYSTEM);
	
	if(!connection)
	{
		throw runtime_error("Failed to connect to system bus");
	}
	
	Glib::RefPtr<Gio::DBus::Proxy> proxy;
	
	proxy = Gio::DBus::Proxy::create_sync(connection, "org.freedesktop.PolicyKit1",
"/org/freedesktop/PolicyKit1/Authority", "org.freedesktop.PolicyKit1.Authority");


	try
	{
		//parameters
		vector<Glib::VariantBase>  parameters;
		
		//subject
		vector<Glib::VariantBase>  subject;
		
		
		Glib::Variant<Glib::ustring> kind=Glib::Variant<Glib::ustring>::create("unix-process");
		map<Glib::ustring,Glib::VariantBase> kind_details;
		
		kind_details["pid"]=Glib::Variant<guint32>::create(getppid()); //parent process id
		kind_details["start-time"]=Glib::Variant<guint64>::create(0);
		
		subject.push_back(kind);
		subject.push_back(Glib::Variant<map<Glib::ustring,Glib::VariantBase>>::create(kind_details));
		
		
		parameters.push_back(Glib::VariantContainerBase::create_tuple(subject));		
		
		
		//action id
		Glib::Variant<Glib::ustring> action_id=Glib::Variant<Glib::ustring>::create("net.lliurex.apt.write-sources-list");
		
		parameters.push_back(action_id);
		
		//details
		map<Glib::ustring,Glib::ustring> details;

		parameters.push_back(Glib::Variant<map<Glib::ustring,Glib::ustring>>::create(details));
		
		//flags
		Glib::Variant<guint32 > flags=Glib::Variant<guint32 >::create(1);
		
		parameters.push_back(flags);

		//cancellation_id
		Glib::Variant<Glib::ustring > cancellation_id=Glib::Variant<Glib::ustring>::create("");
		
		parameters.push_back(cancellation_id);
		
				
		Glib::VariantContainerBase param_container = Glib::VariantContainerBase::create_tuple(parameters);
		
		//sync call, 60 seconds timeout
		
		Glib::VariantContainerBase ret_base=proxy->call_sync("CheckAuthorization",param_container,60000);
		Glib::VariantContainerBase ret;

		
		ret_base.get_child(ret,0);

		
		Glib::Variant<bool> is_authorized;
		Glib::Variant<bool> is_challenged;

		ret.get_child(is_authorized,0);
		ret.get_child(is_challenged,1);
			
		
		if(is_authorized.get())
		{
			cout<<"Authorization success!"<<endl;
			
			Glib::RefPtr<Gio::File> fsource;
			Glib::RefPtr<Gio::File> fdestination;
			
			fsource=Gio::File::create_for_path(source);
			fdestination=Gio::File::create_for_path(destination);
			
			fsource->copy(fdestination,Gio::FILE_COPY_OVERWRITE);
			
		}
		else
		{
			throw runtime_error("Authorization failed");
		}
		
		
	}
	catch(Gio::DBus::Error e)
	{
		cerr<<"Dbus Error: "<<e.code()<<endl;
		cerr<<e.what()<<endl;
		std::exit(1);
	}
	catch(Gio::Error e)
	{
		cerr<<"Error: "<<e.code()<<endl;
		cerr<<e.what()<<endl;
		std::exit(1);
	}
	catch(runtime_error e)
	{
		cerr<<"Error: "<<endl;
		cerr<<e.what()<<endl;
		std::exit(1);
	}
	
	return 0;
}