#include "Core.hpp"

#include <iostream>
#include <fstream>

#define WNCK_I_KNOW_THIS_IS_UNSTABLE
#include <libwnck/libwnck.h>

#define GMENU_I_KNOW_THIS_IS_UNSTABLE
#include <gmenu-tree.h>

#include <dlfcn.h>

#include <lgi-1.0/message.hpp>
#include <lsf-1.0/filesystem.hpp>
#include <lsf-1.0/utils.hpp>

#define RSRC_PATH	"../rsrc/"

using namespace std;
using namespace net::lliurex::llxdo;
using namespace net::lliurex::lgi;

Core * Core::instance = nullptr;


Core::Core()
{
	quit_request=false;
	
	LoadRsrc(RSRC_PATH);
	//LoadRsrc("/usr/share/banners/lliurex/");
	//LoadPlugins();
}

Core::~Core()
{
	cout<<"* Saving changes:...";
	SaveSetup();
	cout<<"ok"<<endl;
	
	map<string,cairo_surface_t *>::iterator iter;
	
	cout<<"* Unloading resources:...";
	for(iter=surfaces.begin();iter!=surfaces.end();iter++)
	{
		cairo_surface_destroy(iter->second);
	}
	cout<<"ok"<<endl;
	
	cout<<"* Unloading plugins..."<<endl;
	
	for(pair<string,void *> it : plugins)
	{
		cout<<"-"<<it.first<<endl;
		dlclose(it.second);
	}
}


Core * Core::GetCore()
{
	if(Core::instance==nullptr)
	{
		Core::instance = new Core();
	}
	
	return Core::instance;
}


void Core::Free()
{
	if(Core::instance!=nullptr)
	{
		delete Core::instance;
		Core::instance=nullptr;
	}
}

void Core::LoadRsrc(string path)
{
	vector<string> files;
	
	files=filesystem::List(path+"/*.png");
	
	cout<<"* Loading resources:...";
	for(int n=0;n<files.size();n++)
	{
		string name = filesystem::BaseName(files[n]);
		name = name.substr(0,name.length()-4);
		surfaces[name]=cairo_image_surface_create_from_png(files[n].c_str());
	}
	cout<<"ok"<<endl;
}

void load_menu(Core * core,GMenuTreeIter * iter)
{
	GMenuTreeItemType item_type = gmenu_tree_iter_next(iter);
		
	while(item_type!=GMENU_TREE_ITEM_INVALID)
	{
		
		if(item_type==GMENU_TREE_ITEM_DIRECTORY)
		{
			GMenuTreeDirectory * dir = gmenu_tree_iter_get_directory(iter); 
			cout<<"* Dir name: "<<gmenu_tree_directory_get_name(dir)<<endl;
			load_menu(core,gmenu_tree_directory_iter(dir));
		}
		
		if(item_type==GMENU_TREE_ITEM_ENTRY)
		{
			GMenuTreeEntry * entry = gmenu_tree_iter_get_entry(iter);
			GDesktopAppInfo * info = gmenu_tree_entry_get_app_info(entry);
			
			core->menu[gmenu_tree_entry_get_desktop_file_id(entry)]=info;
			
			/*
			cout<<"--entry name:"<<g_app_info_get_name((GAppInfo*)info)<<endl;
			cout<<"--ID:"<<gmenu_tree_entry_get_desktop_file_id(entry)<<endl;
			
			if(core->slots.size()<32)
				core->slots.push_back(new SlotDesktop(info));
				 
			*/
			
		}
			
		item_type = gmenu_tree_iter_next(iter);
	}
}

void Core::LoadVintageSetup()
{
	string path = filesystem::Home() + "/.lliurex-do/setup.cfg";
	
	struct rule
	{
		const char * token[8];
		int p;
	};
	
	struct rule applications = {{"[setup]","applications","=","$APPLICATIONS"},0};
	
	if(filesystem::Exists(path))
	{
		ifstream file;
		string line;
		
		file.open(path.c_str());
		
		while(!file.eof())
		{
			file>>line;
			
			if(line!="" && line!=" ")
			{
				if(applications.p==3)
				{
					cout<<"* read:"<<line<<endl;
					applications.p=0;
					vector<string>items = utils::str::Split(line,',');
					
					for(int n=0;n<items.size();n++)
					{
						string fid = filesystem::BaseName(items[n]);
						
						if(menu.find(fid)!=menu.end())
						{
							slots.push_back(new SlotDesktop(menu[fid]));
						}
						else
						{
							cout<<"* Desktop not found:"<<fid<<endl;
						}
					}
				}
				
				if(applications.token[applications.p]==line)
				{
					cout<<"token:"<<line<<endl;
					applications.p++;
				}
				
			}
			else
			{
				cout<<"* ignoring whitespace"<<endl;
			}
			
			
		}
			
		file.close();
	}
}

void Core::LoadSetup()
{
	string path = filesystem::Home()+ "/.config/lliurex-do/setup.conf";
	string vintage_path = filesystem::Home() + "/.lliurex-do/setup.cfg";
	
	/* default setup file */
	if(filesystem::Exists(path))
	{
		ifstream file;
		file.open(path.c_str());
		
		
		
		file.close();
	}
	else
	{
		/* vintage setup file */
		if(filesystem::Exists(vintage_path))
		{
			LoadVintageSetup();
		}
		else
		{
			/* hardcoded default ? */
		}
	}

}

void Core::SaveSetup()
{
	string folder = filesystem::Home()	+ "/.config/lliurex-do";
	string path = folder+ "/setup.conf";
	
	if(!filesystem::Exists(folder))
	{
		filesystem::CreateDir(folder);
	}
	
	ofstream file;
		
	file.open(path.c_str());
	file<<"# LliureX Do setup file"<<endl;
	
	
	
	for(Slot * slot : slots)
	{
		file<<"slot"<<endl;
		file<<"{"<<endl;
		
		vector<string> slot_settings = slot->Serialize();
		
		
		for(string st : slot_settings)
		{
			file<<"\t"<<st<<";"<<endl;
		}
		
		
		
		file<<"}"<<endl;
	}
	
	file.close();
	
}

void Core::LoadMenu()
{
	GMenuTree * tree = gmenu_tree_new ("applications.menu", GMENU_TREE_FLAGS_NONE);
	GError * error = nullptr;
	
	if(gmenu_tree_load_sync(tree,&error))
	{
		GMenuTreeDirectory * dir = gmenu_tree_get_root_directory(tree);
		GMenuTreeIter * iter = gmenu_tree_directory_iter(dir);
		load_menu(this,iter);
	}
}


void Core::LoadPlugins()
{
	cout<<"* Loading plugins..."<<endl;
	vector<string> libs;
	  
	libs=filesystem::List("plugins/*.so");
	for(string file : libs)
	{
		cout<<"-- file:"<<file<<endl;
		
		void * lib;
		const char ** name;
		
		lib=dlopen(file.c_str(),RTLD_LAZY);
		if(lib==nullptr)
		{
			cerr<<"Failed to open shared object"<<endl;
			cerr<<dlerror()<<endl;
		}
		else
		{
			name=(const char **)dlsym(lib,"name");
			
			cout<<"-- name:"<<*name<<endl;
			
			plugins[*name]=lib;
			//dlclose(lib);	
		}
		
		
	}
}

void Core::Run()
{
	int screen_width;
	int screen_height;
	
	window = new lgi::X11Window(800,600,LGI_FLAG_NO_BORDER | LGI_FLAG_RESIZABLE);
	dash = new Dash();
	
	window->GetScreenSize(&screen_width,&screen_height);
	
	vector<string> dnd_targets;
	
	dnd_targets.push_back(string("text/uri-list"));
	window->SetDndTargets(dnd_targets);
	
	LoadMenu();
	LoadVintageSetup();
	
	
	
	/*
	* banner dimensions are 235x110 px
	* space between 20 px
	* |---10 px --| 235px |--10 px ---||---10 px --| 235px |--10 px ---|
	* 
	*/
	
	int tile_width=235+20;
	int tile_height=110+20;
		
	
	int w_tiles = screen_width/tile_width;
	int h_tiles = screen_height/tile_height;
	
	if(h_tiles>4)h_tiles=4;
	
	cout<<"* tiles: "<<w_tiles<<","<<h_tiles<<endl;
		  
	cout<<"* Screen dimensions: "<<screen_width<<"x"<<screen_height<<endl;
	
	int cx,cy;
	int width,height;
		
	
	width = w_tiles*tile_width;
	height = h_tiles*tile_height;
	
	
	cx = (screen_width/2) - (width/2);
	cy = (screen_height/2) - (height/2);
		
	wnck_screen_force_update(wnck_screen_get_default());
	
	WnckWindow *wid=wnck_window_get(window->GetXWindow());
	wnck_window_set_geometry(wid,WNCK_WINDOW_GRAVITY_STATIC,
	(WnckWindowMoveResizeMask)(WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y | WNCK_WINDOW_CHANGE_WIDTH | WNCK_WINDOW_CHANGE_HEIGHT),
	cx,cy,width,height);
	
		
	cout<<"* Computed position: "<<cx<<","<<cy<<endl;
	cout<<"* Computed size: "<<width<<"x"<<height<<endl;
	
	window->AddLayer(dash);
	
	for(pair<string,GDesktopAppInfo *> itm : menu)
	{
		slots.push_back(new SlotDesktop(itm.second));
	}
	
	
	int to_fill = slots.size() % h_tiles;
	
	for(int n=0;n<to_fill;n++)
	{
		slots.push_back(new EmptySlot());
	}
	
	//slots.push_back(GetPlugin("net.lliurex.llxdo.plugins.test"));
	
	for(int n=0;n<slots.size();n++)
	{
		dash->Add(slots[n]);
	}
	
	cout<<" XID:"<<window->GetXWindow()<<endl;
	
	while(!quit_request)
	{
		window->DispatchEvents(LGI_DISPATCH_EVENTS_WAIT);
		window->Flip();
	}
	
	window->Destroy();
	delete window;
	
}

void Core::Quit()
{
	quit_request=true;
}

Slot * Core::GetPlugin(string name)
{
	void * lib = plugins[name];
	
	if(lib==nullptr)
	{
		cout<<"Lib not found"<<endl;
	}
	
	Slot *(*get_instance)(void);
	
	get_instance = (Slot *(*)(void))dlsym(lib,"get_instance");
	
	if(get_instance==nullptr)
	{
		cout<<"Odd things may happen"<<endl;
		cout<<dlerror()<<endl;
	}
	
	return get_instance();
}

void Core::Update()
{
	Message * msg = new Message(MSG_PUSH_FRAME);
	
	window->SendMessage(nullptr,nullptr,msg);
}