/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*-  */
/*
 * zone-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 "zone-tab.h"
#include "resource-tab.h"
#include "map-viewer.h"
#include "area.h"

static void on_dev_res(GtkButton* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_dev_res ();
}

static void on_rm_zone(GtkButton* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_rm_zone ();
}

static void on_add_zone(GtkButton* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_add_zone ();
}

static void on_save(GtkWidget* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_save_clicked ();
}

static void on_save_angle(GtkSpinButton* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_save_angle ();
}

static void on_save_switch(GtkSwitch* b, gboolean state, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_save_switch (state);
}

static void on_delete(GtkButton* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_delete ();
}

static void on_select(GtkTreeView* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_select ();
}

static void on_select_res(GtkTreeView* b, gpointer user_data)
{
	ZoneTab* z = (ZoneTab*) ((CallbackArg*)user_data)->tab;
	z->on_select_res ();
}

ZoneTab::ZoneTab(GtkWidget *win, GtkBuilder *builder, ResourceTab* tab)
	: Tab(win, builder)
{
	CallbackArg* mca = new CallbackArg (this);
	m_isLoading=false;
	m_resTab=tab;
	m_delete=GTK_BUTTON(gtk_builder_get_object(m_builder, "button_zon_del"));
	m_add=GTK_BUTTON(gtk_builder_get_object(m_builder, "button_zon_add"));
	m_rmZone=GTK_BUTTON(gtk_builder_get_object(m_builder, "zon_rm_zon"));
	m_devRes=GTK_BUTTON(gtk_builder_get_object(m_builder, "zon_dev_resource"));
		
	m_useAngle=GTK_SWITCH(gtk_builder_get_object(m_builder, "zon_useangle"));

	CONNECT(m_devRes, "clicked", ::on_dev_res, mca);
	CONNECT(m_rmZone, "clicked", ::on_rm_zone, mca);
	CONNECT(m_add, "clicked", ::on_add_zone, mca); 
	
	m_name=GTK_ENTRY(gtk_builder_get_object(m_builder, "zon_name"));
	CONNECT(m_name, "changed", ::on_save, mca); 

		
	m_resource=GTK_ENTRY(gtk_builder_get_object(m_builder, "zon_resource"));
	CONNECT(m_resource, "changed", ::on_save, mca); 
	
	m_angle=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "zon_angle"));
	CONNECT(m_angle, "value-changed", ::on_save_angle, mca); 

	m_field=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "zon_field"));
	CONNECT(m_field, "value-changed", ::on_save, mca); 
	
	m_radius=GTK_SPIN_BUTTON(gtk_builder_get_object(m_builder, "zon_radius"));
	CONNECT(m_radius, "value-changed", ::on_save, mca); 
		
	CONNECT(m_useAngle, "state-set", ::on_save_switch, mca); 
		
	m_list=GTK_TREE_VIEW(gtk_builder_get_object(m_builder, "listview_zon"));
	m_listRes=GTK_TREE_VIEW(gtk_builder_get_object(m_builder, "tv_zon_res"));
	m_root=GTK_BOX(gtk_builder_get_object(m_builder, "box_zon"));
	m_rootMap=GTK_BOX(gtk_builder_get_object(m_builder, "box_zon2"));
		
	m_map = new MapViewer (m_rootMap, m_angle, this);
	
	CONNECT(m_delete, "clicked", ::on_delete, mca); 
	
	CONNECT(m_list, "cursor-changed", ::on_select, new CallbackArg(this));
	CONNECT(m_listRes, "cursor-changed", ::on_select_res, new CallbackArg(this));


	
	m_listStore=GTK_LIST_STORE(gtk_builder_get_object(m_builder, "liststore1"));
	m_listResStore=m_resTab->getModel();
	gtk_tree_view_set_model (m_listRes, GTK_TREE_MODEL(m_listResStore));
	on_select ();
	gtk_widget_hide(GTK_WIDGET(m_listRes));
}

void ZoneTab::on_rm_zone()
{
	m_map->new_poly ();
}

void ZoneTab::on_add_zone()
{
	Area* a = new Area();
	insert("null", a);
}

ZoneTab::~ZoneTab()
{
	delete m_rootMap;
}

void ZoneTab::on_save_angle()
{
	m_map->setAngle(0);
	on_save();
}

void ZoneTab::on_save_switch(bool b)
{
	bool activated = b;
	if(activated) gtk_widget_show(GTK_WIDGET(m_angle));
	else gtk_widget_hide(GTK_WIDGET(m_angle));
	on_save();
}

void ZoneTab::on_dev_res()
{
	if(gtk_widget_is_visible (GTK_WIDGET(m_listRes)))
		gtk_widget_hide(GTK_WIDGET(m_listRes));
	else 
		gtk_widget_show(GTK_WIDGET(m_listRes));
}

void ZoneTab::insert(const std::string& name, Area* ra)
{
	if(findArea (name)==0)
	{
		GtkTreeSelection* sel = gtk_tree_view_get_selection (m_list);
		GtkTreeIter app;
		Area r;

		gtk_tree_model_get_iter_last (GTK_TREE_MODEL(m_listStore), &app);
		r.m_name=(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_areas.push_back(*ra);
		gtk_tree_selection_select_iter(sel, &app);
		on_select();
	}
	else
	{
		dialog_error("Une ressource existe déja avec ce nom");
	}
}


void ZoneTab::on_save()
{
	std::string old;
	bool selected, b;
	if(m_isLoading) return;
	
	old = gtk_tree_view_get_str_selected(m_list, &selected);
	
	Area* m = findArea (old);
	Area r = Area::cast(getTab(b));
	if(b)
	{
		insert(r.m_name,&r);
	}
	else if(m)
	{
		*m=r;
	}
}


Area* ZoneTab::findArea(const std::string& name)
{
	//std::cout << "Areas : " << m_areas.size() << std::endl;
	for(int i=0; i<m_areas.size(); i++)
	{
		//std::cout << "\tZone '" << m_areas[i].getName() <<"' == '"
		//	 << name << "'" << std::endl;
		if(m_areas[i].getName() == name)
		{
			//std::cout << "OK" << std::endl;
			return &m_areas[i];
		}
	}
			//std::cout << "Fail" << std::endl;
	return 0;
}


void ZoneTab::setupTab(Data& _a)
{
	Area& a = Area::cast(_a);
	m_isLoading=true;
	gtk_entry_set_text (m_name, a.m_name.c_str());
	gtk_entry_set_text (m_resource, a.m_resource.c_str());
	m_map->setUpArea (a.m_coord);
	std::cout << "Setup\n";
		std::cout << "Coord = " << a.getJson () << "\n";
	if(a.m_points.size()>0)
	{
		gtk_switch_set_active (m_useAngle, a.m_points[0].m_useAngle);
		gtk_switch_set_state (m_useAngle, a.m_points[0].m_useAngle);

		gtk_spin_button_set_value (m_angle, a.m_points[0].m_angle);
		gtk_spin_button_set_value(m_field, a.m_points[0].m_field);
		gtk_spin_button_set_value(m_radius, a.m_points[0].m_radius);
		m_map->setUpPlace (a.m_points[0].m_coord);
	}else
	{
		gtk_switch_set_active (m_useAngle, FALSE);
		gtk_switch_set_state (m_useAngle, FALSE);
		gtk_spin_button_set_value(m_angle, 180);
		gtk_spin_button_set_value(m_field, 120);
		gtk_spin_button_set_value(m_radius, 10);
	}
	m_map->centerView(); 
	if(gtk_switch_get_active (m_useAngle) && gtk_switch_get_state (m_useAngle)) 
		gtk_widget_hide(GTK_WIDGET(m_angle)); 
	m_isLoading=false;
}



Data& ZoneTab::getTab(bool& insert)
{
	
	static Area a;
	static Point p;
	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;
	}
	
	p.m_angle = gtk_spin_button_get_value(m_angle);
	p.m_field = gtk_spin_button_get_value(m_field);
	p.m_radius = gtk_spin_button_get_value(m_radius);
	p.m_coord = m_map->getPlace();
	p.m_useAngle= gtk_switch_get_active (m_useAngle) && 
					gtk_switch_get_state (m_useAngle);
	a.m_coord = m_map->getArea ();
	a.m_name = gtk_entry_get_text(m_name);
	a.m_resource = gtk_entry_get_text(m_resource);
	a.addPoint (p);
	return a;
}


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


void ZoneTab::on_select()
{
	bool exists;
	std::string name;
	name=gtk_tree_view_get_str_selected(m_list, &exists);
	
	if(exists)
	{
		Area * r = findArea (name);
		if(r)
			setupTab(*r);
		gtk_widget_show_all (GTK_WIDGET(m_root));
		gtk_widget_hide (GTK_WIDGET(m_listRes));
		
		if(!gtk_switch_get_active(m_useAngle) || !gtk_switch_get_state(m_useAngle))
			gtk_widget_hide (GTK_WIDGET(m_angle));
	}
	else
	{
		gtk_widget_hide (GTK_WIDGET(m_root));
	}
}

void ZoneTab::on_select_res()
{

	bool exists;
	std::string name;
	name=gtk_tree_view_get_str_selected(m_listRes, &exists);
	if(exists)
	{
		std::string x = gtk_entry_get_text(m_resource);
		if(!x.size() || x=="null")
			gtk_entry_set_text(m_resource, name.c_str());
		else 
			gtk_entry_set_text(m_resource, (x+";"+name).c_str());
	}
}

void ZoneTab::on_delete()
{
	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_areas.size(); i++)
			if(m_areas[i].m_name == name)
			{
				m_areas.erase(m_areas.begin()+i);
				break;
			}
	  remove(name);
	}
}


void ZoneTab::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);
		
		if(cname && name == cname)
		{
			gtk_list_store_remove (m_listStore, &child);
			break;
		}
	}
}


void ZoneTab::open(Json::Value& val)
{
	m_isModified=false;
	gtk_list_store_clear (m_listStore);
	m_areas.clear();
	gtk_widget_hide (GTK_WIDGET(m_root));
	for (Json::Value::iterator it = val.begin(); it != val.end(); ++it) {
            Json::Value v = (*it);
		Area r(v);
        insert(v["name"].asString(), &r);    
    }
	on_select();
}

Json::Value ZoneTab::getJson(bool b)
{
	Json::Value v(Json::arrayValue);
	for(int i=0; i<m_areas.size(); i++)
		v[i]=m_areas[i].getJson();
	
	return v;
}

void ZoneTab::write(const std::string& file)
{
}