/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*-  */
/*
 * resource-tab.cc
 * Copyright (C) 2017 Unknown <francois@gautrais.eu>
 *
 * histodexc is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * histodexc 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "resource-tab.h"

#include <fstream>

static ResourceTab* gr = NULL;

const char* typetostring(int i)
{
	if(i==0) return "3D";
	if(i==1) return "Image"; 
	if(i==2) return "Audio";
	return "Video" ;
}

int stringtotype(const std::string & a)
{
	if(a=="3D") return 0;
	if(a=="Image") return 1; 
	if(a=="Audio") return 2;
	return  3;
}

static void on_save_clicked (GtkApplication* app, gpointer user_data)
{
	CallbackArg* r = (CallbackArg*) user_data;
	((ResourceTab*)r->tab)->on_save_clicked ();
}


static void  on_type_changed (GtkToggleButton *togglebutton, gpointer user_data)
{
	CallbackArg* r = (CallbackArg*) user_data;
	printf("%d\n", r->data);
	((ResourceTab*)r->tab)->on_type_changed ((long)r->data);
}


static void  on_add (GtkApplication* app, gpointer user_data)
{
	CallbackArg* r = (CallbackArg*) user_data;
	((ResourceTab*)r->tab)->on_add ();
}

static void  on_remove (GtkApplication* app, gpointer user_data)
{
	CallbackArg* r = (CallbackArg*) user_data;
	((ResourceTab*)r->tab)->on_remove ();
}

static void  on_select (GtkTreeView* app, gpointer user_data)
{
	CallbackArg* r = (CallbackArg*) user_data;
	((ResourceTab*)r->tab)->on_select ();
}



ResourceTab::ResourceTab(GtkWidget *window, GtkBuilder *builder) 
	: Tab (window, builder)
{
	gr=this;
	m_isLoading=false;
	m_name=GTK_ENTRY(gtk_builder_get_object(m_builder, "entry_res_name"));
	m_stage=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_stage"));
	
	CONNECT(m_stage, "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_stage, "changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_name, "changed", ::on_save_clicked, new CallbackArg(this));
	
	m_type[0]=GTK_RADIO_BUTTON(gtk_builder_get_object(m_builder, "radio_res_3d"));
	m_type[1]=GTK_RADIO_BUTTON(gtk_builder_get_object(m_builder, "radio_res_image"));
	m_type[2]=GTK_RADIO_BUTTON(gtk_builder_get_object(m_builder, "radio_res_audio"));
	m_type[3]=GTK_RADIO_BUTTON(gtk_builder_get_object(m_builder, "radio_res_video"));
	for(int i=0; i<4; i++)
			CONNECT(m_type[i], "toggled", ::on_type_changed,
			        (gpointer*)new CallbackArg(this,(gpointer*)i));

		

		
	m_comments=GTK_TEXT_VIEW(gtk_builder_get_object(m_builder, "textview_res_comments"));
	m_title=GTK_ENTRY(gtk_builder_get_object(m_builder, "entry_res_title"));

	CONNECT(m_title, "changed", ::on_save_clicked, new CallbackArg(this));
		
	m_position[0]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_posiiton_x"));
	m_position[1]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_posiiton_y"));
	m_position[2]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_posiiton_z"));

		
	CONNECT(m_position[0], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_position[1], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_position[2], "value-changed", ::on_save_clicked, new CallbackArg(this));

		
	m_rotation[0]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_rotation_x"));
	m_rotation[1]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_rotation_y"));
	m_rotation[2]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_rotation_z"));

	
	CONNECT(m_rotation[0], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_rotation[1], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_rotation[2], "value-changed", ::on_save_clicked, new CallbackArg(this));
		
		
	m_scale[0]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_scale_x"));
	m_scale[1]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_scale_y"));
	m_scale[2]=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "spin_res_scale_z"));

		
	CONNECT(m_scale[0], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_scale[1], "value-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_scale[2], "value-changed", ::on_save_clicked, new CallbackArg(this));
		

	m_add=GTK_BUTTON(gtk_builder_get_object(m_builder, "button_res_add"));
	CONNECT(m_add, "clicked", ::on_add, new CallbackArg(this));

	m_delete=GTK_BUTTON(gtk_builder_get_object(m_builder, "button_res_del"));
	CONNECT(m_delete, "clicked", ::on_remove, new CallbackArg(this));

	
	m_files[0]=GTK_FILE_CHOOSER_BUTTON(gtk_builder_get_object(m_builder, "fcb_res_3d"));
	m_files[1]=GTK_FILE_CHOOSER_BUTTON(gtk_builder_get_object(m_builder, "fcb_res_image"));
	m_files[2]=GTK_FILE_CHOOSER_BUTTON(gtk_builder_get_object(m_builder, "fcb_res_audio"));
	m_files[3]=GTK_FILE_CHOOSER_BUTTON(gtk_builder_get_object(m_builder, "fcb_res_video"));
	
	CONNECT(m_files[0], "selection-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_files[1], "selection-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_files[2], "selection-changed", ::on_save_clicked, new CallbackArg(this));
	CONNECT(m_files[3], "selection-changed", ::on_save_clicked, new CallbackArg(this));
		
	m_layout[0]=GTK_GRID(gtk_builder_get_object(m_builder, "box_res_root_0"));
	m_layout[1]=GTK_GRID(gtk_builder_get_object(m_builder, "box_res_root_1"));
	m_layout[2]=GTK_GRID(gtk_builder_get_object(m_builder, "box_res_root_2"));
	m_layout[3]=GTK_GRID(gtk_builder_get_object(m_builder, "box_res_root_3"));
		
	m_root=GTK_BOX(gtk_builder_get_object(m_builder, "box_res_root"));
	m_list=GTK_TREE_VIEW(gtk_builder_get_object(m_builder, "treeview_res"));
	m_listStore=GTK_LIST_STORE(gtk_builder_get_object(m_builder, "ls_res"));
	//Gtk::TreeModel::iterator it = m_listStore->append();
	//m_listStore->insert(it);
		
	//m_listStore->insert(0, "C");
	CONNECT(m_list, "cursor-changed", ::on_select, new CallbackArg(this));

	m_activeTab=0;
	//open(val);
	//gtk_widget_hide (GTK_WIDGET(m_root));
		
	printf("Init %p\n", (void*)this);
}

ResourceTab::~ResourceTab()
{
}

void			ResourceTab::write(const std::string& file)
{
	std::ofstream out(file);
	Json::Value v(Json::objectValue);
	v["resources"] = getJson();
	out << v;
}

Json::Value		ResourceTab::getJson(bool genFinal)
{
	Json::Value r(Json::arrayValue);
	for(int i=0; i<m_resources.size(); i++)
	{
		r[i] = m_resources[i].getJson();
	}
	return r;
}

Json::Value		ResourceTab::getJsonOrphelin()
{
	Json::Value r(Json::arrayValue);
	int j=0;
	for(int i=0; i<m_resources.size(); i++)
	{
		if(!m_resources[i].getStage ())
			r[j++] = m_resources[i].getName ();
			
	}
	return r;
}


void			ResourceTab::on_save_clicked()
{
	std::string old;
	bool selected, b;
	if(m_isLoading) return;
	
	old = gtk_tree_view_get_str_selected(m_list, &selected);
	
	Resource* m = findResource (old);
	Resource r = Resource::cast(getTab(b));
	if(b)
	{
		insert(r.getName(),&r);
	}
	else if(m)
	{
		*m=r;
	}
}




Data& ResourceTab::getTab(bool& insert)
{
	static Resource t;
	GtkTextBuffer * buffer=NULL;
	std::string old = gtk_entry_get_text(m_name);
	bool exists;
	gtk_tree_view_get_str_selected (m_list, &exists);
	if(exists)
	{
		gtk_tree_view_set_str_selected(m_list,  gtk_entry_get_text(m_name));
		old=gtk_entry_get_text(m_name);
		insert=false;
	}else if(findResource (gtk_entry_get_text(m_name))==0)
	{
		insert=true;
	}
	t.setComments (gtk_text_view_get_text (m_comments));
	t.setName (gtk_entry_get_text(m_name));
	t.setType (typetostring (m_activeTab));
	t.setTitle (gtk_entry_get_text(m_title));
	t.setPosition (Number3d(
	                        gtk_spin_button_get_value(m_position[0]),
	                        gtk_spin_button_get_value(m_position[1]),
	                        gtk_spin_button_get_value(m_position[2])
	                        ));
	
	t.setRotation (Number3d(
	                        gtk_spin_button_get_value(m_rotation[0]),
	                        gtk_spin_button_get_value(m_rotation[1]),
	                        gtk_spin_button_get_value(m_rotation[2])
	                        ));
	
	t.setScale (Number3d(
	                        gtk_spin_button_get_value(m_scale[0]),
	                        gtk_spin_button_get_value(m_scale[1]),
	                        gtk_spin_button_get_value(m_scale[2])
	                        ));
	std::cout << "Rotation " << t.getRotation ().toString() << std::endl;
	//std::cout << "Rotation ui (" << m_rotation[0]->get_value() << ", " << m_rotation[1]->get_value() << ", "
	//						<< m_rotation[2]->get_value() << ")" << std::endl;
	std::cout <<  std::endl;
	t.setStage ( gtk_spin_button_get_value(m_stage));
	char * x = gtk_file_chooser_get_filename (
	                             GTK_FILE_CHOOSER(m_files[m_activeTab]));
	std::string file="";
	if(x) file=x; 
	t.setFile (file); 
	
    return t;	
}
void ResourceTab::setupTab(Data& _a)
{
	Resource& r = Resource::cast(_a);
	m_isLoading=true;
	gtk_text_view_set_text(m_comments, r.getComments ().c_str());
	gtk_entry_set_text(m_name, r.getName ().c_str());
	gtk_entry_set_text(m_title, r.getTitle ().c_str());
	m_activeTab = stringtotype (r.getType ());
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(m_type[m_activeTab]), TRUE);

	gtk_spin_button_set_value (m_position[0], r.getPosition ().m_x);
	gtk_spin_button_set_value (m_position[1], r.getPosition ().m_y);
	gtk_spin_button_set_value (m_position[2], r.getPosition ().m_z);
	
	gtk_spin_button_set_value (m_rotation[0], r.getRotation ().m_x);
	gtk_spin_button_set_value (m_rotation[1], r.getRotation ().m_y);
	gtk_spin_button_set_value (m_rotation[2], r.getRotation ().m_z);
	
	gtk_spin_button_set_value (m_scale[0], r.getScale ().m_x);
	gtk_spin_button_set_value (m_scale[1], r.getScale ().m_y);
	gtk_spin_button_set_value (m_scale[2], r.getScale ().m_z);

	
	gtk_spin_button_set_value (m_stage, r.getStage ());
	gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(m_files[m_activeTab]),
	                               r.getFile ().c_str());
	m_isLoading=false;
}


Resource*  ResourceTab::findResource(const std::string& name)
{
	for(int i=0; i<m_resources.size(); i++)
	{

		if(m_resources[i].getName() == name)
		{
			return &m_resources[i];
		}
	}
	return 0;
}



void ResourceTab::on_type_changed(int i)
{   
	
	if(gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(m_type[i])))
	{
		set_layout(i);
	}
	on_save_clicked();
}

void ResourceTab::on_select()
{
	bool exists;
	std::string name;
	name=gtk_tree_view_get_str_selected(m_list, &exists);

	if(exists)
	{
		//name = iter->get_value(m_Columns.m_col_name);
		Resource * r = findResource (name);
	
		setupTab(*r);
		gtk_widget_show_all (GTK_WIDGET(m_root));
		set_layout();
	}
	else
	{
		gtk_widget_hide(GTK_WIDGET(m_root));
	}
}



void ResourceTab::remove(std::string name)
{
	GtkTreeIter child;
	gchar *cname = NULL;
	bool hasChild;
	int nchild = gtk_tree_model_iter_n_children (GTK_TREE_MODEL(m_listStore), NULL);
	for(int i=0;  i<nchild; i++)
	{
		gtk_tree_model_iter_nth_child (GTK_TREE_MODEL(m_listStore), 
		                           	 &child,
		                             NULL,
		                               i);
		gtk_tree_model_get(GTK_TREE_MODEL(m_listStore), 
		                   &child, 0, &cname, -1);
		printf("'%s' == '%s'\n", cname, name.c_str());
		if(cname && name == cname)
		{
			gtk_list_store_remove (m_listStore, &child);
			break;
		}
	}
}


void ResourceTab::on_remove()
{
	bool exists;
	std::string name;
	name=gtk_tree_view_get_str_selected(m_list, &exists);
	
	if(exists) //If anything is selected
	{
	  for(int i= 0; i<m_resources.size(); i++)
			if(m_resources[i].getName() == name)
			{
				m_resources.erase(m_resources.begin()+i);
				break;
			}
	  remove(name);
	}
}

void ResourceTab::on_add()
{
	insert("");
}



void ResourceTab::open(Json::Value& val)
{
	m_isModified=false;
	
	gtk_list_store_clear (m_listStore);
	m_resources.clear();
	gtk_widget_hide (GTK_WIDGET(m_root));
	for (Json::Value::iterator it = val.begin(); it != val.end(); ++it) {
            Json::Value v = (*it);
		//std::cout << "Open " << v << std::endl;
		Resource r(v);
        insert(v["name"].asString(), &r);    
    }
		
	gtk_widget_hide (GTK_WIDGET(m_root));
}

void ResourceTab::set_layout(int i)
{
	std::cout << "OK\n";
	if(i==-1)
		for(int j=0; j<4; j++)
			if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(m_type[j])))
				i=j;
	
	for(int j=0; j<4; j++)
		gtk_widget_hide(GTK_WIDGET(m_layout[j]));
	gtk_widget_show_all(GTK_WIDGET(m_layout[i]));
	
	m_activeTab=i;
}


void ResourceTab::insert(std::string name,  Resource* ra)
{
	if(findResource (name)==0)
	{
		GtkTreeSelection* sel = gtk_tree_view_get_selection (m_list);
		GtkTreeIter app;
		Resource r;

		gtk_tree_model_get_iter_last (GTK_TREE_MODEL(m_listStore), &app);
		r.setName(name);
		if(!ra) ra=&r; 

		gtk_list_store_append(m_listStore, &app);
		gtk_list_store_set(m_listStore, &app, 0, name.c_str(), -1);

		m_resources.push_back(*ra);
		gtk_tree_selection_select_iter(sel, &app);
		on_select();
	}
	else
	{
		dialog_error("Une ressource existe déja avec ce nom");
	}
}



GtkListStore* ResourceTab::getModel()
{
	return m_listStore;
}