#include <iostream>
#include <gtkmm.h>
#include <glibmm.h>
#include <dlfcn.h>
#include <libintl.h>
 #include <locale.h>

#include <mrpdi/Core.h>
#include <mrpdi/Input.h>


#define T(String) gettext(String)


using namespace std;
using namespace net::lliurex::mrpdi;

/**
 * Application class
 */
class Application
{
	public:
	
	Gtk::Window * window;
	Gtk::Window * dlgClose;
	
	Gtk::TreeView * treeview;
	Core * core;
	input::InputHandler * handler;
	Glib::RefPtr <Gdk::Pixbuf> pix_tablet,pix_whiteboard;
	Glib::RefPtr<Gtk::ListStore> store;
	Glib::RefPtr<Gtk::StatusIcon> statusIcon;
	
	/**
	 * Constructor
	 */ 
	Application()
	{
		cout<<"[Constructor]"<<endl;
		
		Glib::RefPtr<Gtk::Builder> glade;
		glade=Gtk::Builder::create_from_file("/usr/share/mrpdi/gui/interface.glade");
		glade->get_widget("winManager",window);	
		
		Gtk::Button * button;
		glade->get_widget("btnRefresh",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btnrefresh_clicked));
		
		glade->get_widget("btnRun",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btnrun_clicked));
		
		glade->get_widget("btnStop",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btnstop_clicked));
		
		glade->get_widget("btnDebug",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btndebug_clicked));
				
		glade->get_widget("btnCalibrate",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btncalibrate_clicked));
		
		glade->get_widget("btnClose",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_btnclose_clicked));
		
		glade->get_widget("dlgClose",dlgClose);
		glade->get_widget("dlgbtnCancel",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_dlg_cancel));
		
		glade->get_widget("dlgbtnAccept",button);
		button->signal_clicked().connect(sigc::mem_fun(*this,&Application::on_dlg_accept));
				
		window->signal_window_state_event().connect(sigc::mem_fun(*this,&Application::on_window_state_changed));
		window->signal_delete_event().connect(sigc::mem_fun(*this,&Application::on_window_destroy));
		
		glade->get_widget("treeDevices",treeview);
		
		
		pix_tablet = Gdk::Pixbuf::create_from_file("/usr/share/mrpdi/gui/tablet.svg");
		pix_whiteboard = Gdk::Pixbuf::create_from_file("/usr/share/mrpdi/gui/whiteboard.svg");

		Gtk::TreeModelColumn<Glib::RefPtr<Gdk::Pixbuf> >pixbuf_col;		
		Gtk::TreeModelColumn<unsigned int> id_col;
		Gtk::TreeModelColumn<unsigned int> address_col;
		Gtk::TreeModelColumn<string> name_col; 
		Gtk::TreeModelColumn<string> status_col; 
		 
		Gtk::TreeModel::ColumnRecord cr;
		cr.add(pixbuf_col);
		cr.add(address_col);
		cr.add(id_col);
		cr.add(name_col);
		cr.add(status_col);
		
		
		store=Gtk::ListStore::create(cr);
		
		treeview->set_model(store);
		treeview->append_column(T("Type"),pixbuf_col);
		treeview->append_column_numeric(T("Id"),id_col,"%08x");
		treeview->append_column_numeric(T("Address"),address_col,"%08x");
		treeview->append_column(T("Name"),name_col);
		treeview->append_column(T("Status"),status_col);
		
        
        window->show_all();
        
        //status icon
        statusIcon =Gtk::StatusIcon::create("input-tablet");
        statusIcon->set_tooltip_text("MrPDI GUI");
        statusIcon->signal_button_press_event().connect(sigc::mem_fun(*this,&Application::on_statusicon_button_press));
        
        core = new Core();
        handler = new input::InputHandler();
        core->init();
        core->set_input_handler(handler);
        
        
        refresh();
				
                   
       Glib::signal_timeout().connect(sigc::mem_fun(*this,&Application::on_timer), 1000);
		
	}
	
	
	/**
	 * Destructor
	 * things should be closed here
	 */ 
	~Application()
	{
		cout<<"[Destructor]"<<endl;
		core->shutdown();
		delete handler;
        delete core;
		
	}
	
	/**
	 * Refresh device table
	 */ 
	void refresh()
	{
		vector<Gtk::TreeModel::Path> selection; 
		vector<connected_device_info> list;
        
        core->update_devices(&list);
        
        selection=treeview->get_selection()->get_selected_rows();
        store->clear();
        
        for(int n=0;n<list.size();n++)
        {
			/*
			cout<<"device:"<<list[n].name<<endl;
			cout<<"status:"<<list[n].status<<endl;
			*/
			Gtk::TreeModel::Row row= *(store->append());
			if(list[n].type==0)row.set_value<Glib::RefPtr<Gdk::Pixbuf> >(0,pix_tablet);
				else row.set_value<Glib::RefPtr<Gdk::Pixbuf> >(0,pix_whiteboard);
				
			row.set_value<unsigned int>(1,list[n].address);
			row.set_value<unsigned int>(2,list[n].id);
			row.set_value<string>(3,list[n].name);
			
			if(list[n].status==1)row.set_value<string>(4,T("Running"));
				else row.set_value<string>(4,T("Stop"));
			
			vector<string> parameters;
			core->get_parameter_list(list[n].id,&parameters);
			/*
			for(int m=0;m<parameters.size();m++)
			{
				cout<<"param >> "<<parameters[m]<<endl;
			}
			*/
		}
		
		if(selection.size()>0)
			treeview->get_selection()->select(selection[0]);
	}
	
	/**
	 * Window state hook
	 */  
	bool on_window_state_changed(GdkEventWindowState* event)
	{
		cout<<"State:"<<event->new_window_state<<endl;
		
		if( (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) == GDK_WINDOW_STATE_ICONIFIED)
		{
			cout<<"Minimize!"<<endl;
			window->hide();
		}
		return false;
	}
	
	/**
	 * Notify Area Icon hook
	 */ 
	bool on_statusicon_button_press(GdkEventButton* event)
	{
		if(event->button==1)
		{
			cout<<"Maximize!"<<endl;
			//window->maximize();
			
			window->deiconify();
			window->show_all();
		}
		
		return false;
	}
	
	
	/**
	 * Timer handler
	 */ 
	int on_timer()
	{
		//cout<<"tic tac!!!"<<endl;
		refresh();
	}
	
	/**
	* Dialog cancel
	*/
	void on_dlg_cancel()
	{
		dlgClose->hide();
	}
	
	/**
	* Dialog accept
	*/
	void on_dlg_accept()
	{
		core->shutdown();
		Gtk::Main::quit();
	}
	
	
	/**
	* Close button
	*/
	void on_btnclose_clicked()
	{
		dlgClose->show_all();	
	}
	
	/**
	 * Calibrate
	 */  
	 void on_btncalibrate_clicked()
	 {
		Glib::RefPtr<Gtk::TreeSelection> selection;
		Gtk::TreeModel::iterator iter;
		unsigned int id,address,value;
		
		cout<<"[Calibrate]"<<endl;
		selection = treeview->get_selection();
		iter=selection->get_selected();
		if(iter)
		{
			Gtk::TreeModel::Row row = *iter;
			row.get_value(2,id);
			row.get_value(1,address);
			cout<<"Debugging "<<hex<<address<<endl;
			
			handler->calibrate(address);
						
			
		}
	 }
	
	/**
	 * Debug mode
	 */ 
	void on_btndebug_clicked()
	{
		Glib::RefPtr<Gtk::TreeSelection> selection;
		Gtk::TreeModel::iterator iter;
		unsigned int id,address,value;
		
		cout<<"[Debug]"<<endl;
		selection = treeview->get_selection();
		iter=selection->get_selected();
		if(iter)
		{
			Gtk::TreeModel::Row row = *iter;
			row.get_value(2,id);
			row.get_value(1,address);
			cout<<"Debugging "<<hex<<address<<endl;
			
			core->get_parameter(id,"common.debug",&value);
			core->set_parameter(id,"common.debug",(~value) & 1);
			
		}
		
	}
	
	/**
	 * Refresh button click signal
	 */ 
	void on_btnrefresh_clicked()
	{
		cout<<"[Refresh]"<<endl;
		refresh();
	}
	/**
	 * Run button clicked
	 */ 
	void on_btnrun_clicked()
	{
		Glib::RefPtr<Gtk::TreeSelection> selection;
		Gtk::TreeModel::iterator iter;
		unsigned int id,address;
		
		cout<<"[Run]"<<endl;
		
		selection = treeview->get_selection();
		iter=selection->get_selected();
		if(iter)
		{
			Gtk::TreeModel::Row row = *iter;
			row.get_value(2,id);
			row.get_value(1,address);
			cout<<"Turning on "<<hex<<address<<endl;
			core->start(id,address);
			
		}
		
		
		
	}
	/**
	 * Stop button clicked
	 */ 
	void on_btnstop_clicked()
	{
		
		Glib::RefPtr<Gtk::TreeSelection> selection;
		Gtk::TreeModel::iterator iter;
		unsigned int id,address;
		
		cout<<"[Stop]"<<endl;
		
		selection = treeview->get_selection();
		iter=selection->get_selected();
		if(iter)
		{
			Gtk::TreeModel::Row row = *iter;
			row.get_value(2,id);
			row.get_value(1,address);
			cout<<"Shutting down"<<hex<<address<<endl;
			core->stop(id,address);
			
		}
	}
	
	/**
	 * Destroy window event
	 */ 
	bool on_window_destroy(GdkEventAny* event)
	{
		
		Gtk::Main::quit();
		return false;
	}
	
	
};


/**
 * Main
 */ 
int main(int argc,char * argv[])
{
	textdomain("mrpdi-gui");
	Gtk::Main kit(argc, argv);
    Application app; 
    Gtk::Main::run();
	
	return 0;
}