/*
 * Copyright 2014 (c) Anna Schumaker.
 */
#include <core/deck.h>
#include <core/string.h>
#include <gui/tabs.h>
#include <gui/queue/view.h>


static void renumber_queues();

static class QueueColumns : public Gtk::TreeModelColumnRecord {
public:
	QueueColumns()
	{ add(q_col_track);  add(q_col_title); add(q_col_length);
	  add(q_col_artist); add(q_col_album); add(q_col_year);
	  add(q_col_genre);  add(q_col_count); add(q_col_played);
	  add(q_col_path); }

	Gtk::TreeModelColumn<unsigned int> q_col_track;
	Gtk::TreeModelColumn<std::string> q_col_title;
	Gtk::TreeModelColumn<std::string> q_col_length;
	Gtk::TreeModelColumn<std::string> q_col_artist;
	Gtk::TreeModelColumn<std::string> q_col_album;
	Gtk::TreeModelColumn<unsigned int> q_col_year;
	Gtk::TreeModelColumn<std::string> q_col_genre;
	Gtk::TreeModelColumn<unsigned int> q_col_count;
	Gtk::TreeModelColumn<std::string> q_col_played;
	Gtk::TreeModelColumn<std::string> q_col_path;
} queue_cols;



class QueueTab : public Tab {
private:
	Glib::RefPtr<Gtk::Builder> builder;

	/**
	 * Queue tab widgets
	 */
	Gtk::HBox   q_tab_box;
	Gtk::Label  q_tab_number;
	Gtk::Label  q_tab_size;
	Gtk::Button q_tab_close;


	/**
	 * Queue page widgets
	 */
	Gtk::VBox q_vbox;

	/**
	 * Toolbar widgets
	 */
	Gtk::HBox         q_toolbar_box;
	Gtk::SearchEntry  q_search;
	Gtk::ToggleButton q_random;
	Gtk::ToggleButton q_repeat;
	Gtk::Switch       q_switch;

	/* Treeview widgets */
	Gtk::ScrolledWindow q_window;
	QueueView *q_treeview;


public:
	QueueTab(Queue *, unsigned int num);
	~QueueTab();

	void on_track_removed(unsigned int);

	/**
	 * Helper functions
	 */
	void setup_treeview();
	void on_post_init();
	bool on_key_press_event(const std::string &);
	void tab_set_size();
	void queue_set_number(unsigned int);
	void on_tab_reordered();
	void on_move_queue(int);
	void queue_set_sensitive(bool);

	/**
	 * GTK-MM Callbacks
	 */
	void on_close_clicked();
	void on_switch_changed();
};

static std::map<Gtk::Widget *, QueueTab *> queue_mapping;


QueueTab :: QueueTab(Queue *pq, unsigned int num)
	  : Tab(pq)
{
	builder = Gtk::Builder::create();
	builder->add_from_file(gui :: share_file("QueueView.ui"));

	/*
	 * Create our tab widget
	 */
	q_tab_size.set_justify(Gtk::JUSTIFY_CENTER);

	q_tab_close.set_image_from_icon_name("window-close", Gtk::ICON_SIZE_MENU);
	q_tab_close.set_relief(Gtk::RELIEF_NONE);
	q_tab_close.signal_clicked().connect(sigc::mem_fun(*this,
					&QueueTab::on_close_clicked));

	q_tab_box.pack_start(q_tab_number, false, true);
	q_tab_box.pack_start(q_tab_size,   true,  true);
	q_tab_box.pack_start(q_tab_close,  false, true);

	tab_set_size();
	queue_set_number(num);
	q_tab_box.show_all();


	/*
	 * Now set up the toolbar
	 */
	q_repeat.set_image_from_icon_name("media-playlist-repeat", Gtk::ICON_SIZE_BUTTON);
	q_random.set_image_from_icon_name("media-playlist-shuffle", Gtk::ICON_SIZE_BUTTON);

	q_toolbar_box.set_margin_left(5);
	q_toolbar_box.set_margin_right(5);
	q_toolbar_box.set_spacing(5);
	q_toolbar_box.set_homogeneous(false);

	q_toolbar_box.pack_start(q_search, true,  true);
	q_toolbar_box.pack_start(q_switch, false, true);
	q_toolbar_box.pack_start(q_repeat, false, true);
	q_toolbar_box.pack_start(q_random, false, true);


	/*
	 * And the treeview with scrolled window
	 */
	builder->get_widget_derived("QueueView", q_treeview);
	q_window.set_shadow_type(Gtk::SHADOW_IN);
	q_window.set_margin_left(5);
	q_window.set_margin_right(5);
	q_window.set_margin_bottom(5);
	q_window.add(*q_treeview);


	/*
	 * Fill in the page!
	 */

	q_vbox.set_margin_left(1);
	q_vbox.set_margin_right(1);
	q_vbox.set_homogeneous(false);
	q_vbox.pack_start(q_toolbar_box, false, true, 2);
	q_vbox.pack_start(q_window, true, true);


	/*
	 * Set generic tab widgets
	 */

	tab_random   = &q_random;
	tab_repeat   = &q_repeat;
	tab_search   = &q_search;
	tab_size     = &q_tab_size;
	tab_treeview = q_treeview;
	tab_widget   = &q_vbox;

	tab_finish_init();
	queue_mapping[tab_widget] = this;

	gui :: get_widget<Gtk::Notebook>("o_notebook")->insert_page(q_vbox, q_tab_box, num);
	gui :: get_widget<Gtk::Notebook>("o_notebook")->set_tab_reorderable(q_vbox);
	q_vbox.show_all();
}

QueueTab :: ~QueueTab()
{
	queue_mapping.erase(tab_widget);
	tab_unmap();
	gui :: get_widget<Gtk::Notebook>("o_notebook")->remove_page(q_vbox);
	renumber_queues();
}

void QueueTab :: on_track_removed(unsigned int row)
{
	this->Tab :: on_track_removed(row);
	if (tab_pq->size() == 0)
		delete this;
}



/**
 *
 * Queue tab helper functions
 *
 */

void QueueTab :: on_post_init()
{
	tab_init_random();
	tab_init_repeat();

	bool active = (tab_pq->has_flag(Q_ENABLED));
	q_switch.set_active(active);
	q_switch.property_active().signal_changed().connect(
			sigc::mem_fun(*this, &QueueTab :: on_switch_changed));
	queue_set_sensitive(active);
}

bool QueueTab :: on_key_press_event(const std::string &key)
{
	std::vector<unsigned int> ids;

	if (key != "Delete")
		return Tab :: on_key_press_event(key);

	/*
	 * tab_selected_ids() returns track_ids and not
	 * playlist_ids,so we can't use it here =(
	 */
	Glib::RefPtr<Gtk::TreeSelection> sel = tab_treeview->get_selection();
	std::vector<Gtk::TreeModel::Path> rows = sel->get_selected_rows();
	Gtk::TreeModel::Path path;

	for (unsigned int i = 0; i < rows.size(); i++) {
		path = tab_filter->convert_path_to_child_path(rows[i]);
		ids.push_back(path[0]);
	}

	for (unsigned int i = ids.size(); i > 0; i--)
		tab_pq->del(ids[i-1]);
	return true;
}

void QueueTab :: tab_set_size()
{
	std::string span = "<span size='x-large'>";
	span += string :: utos(tab_pq->size()) + "</span>";
	q_tab_size.set_markup(span);
}

void QueueTab :: queue_set_number(unsigned int num)
{
	std::string span = "<span size='x-large'>";
	span += string :: utos(num) + ". </span>";
	q_tab_number.set_markup(span);
}

void QueueTab :: on_tab_reordered()
{
	queue_set_number(tab_page_num());
}

void QueueTab :: on_move_queue(int num)
{
	deck :: move(tab_pq, num);
}

void QueueTab :: queue_set_sensitive(bool sensitive)
{
	q_tab_number.set_sensitive(sensitive);
	q_tab_size.set_sensitive(sensitive);
	q_treeview->set_sensitive(sensitive);
}



/**
 *
 * Gtk-MM Callback Functions
 *
 */

void QueueTab :: on_close_clicked()
{
	deck :: destroy(tab_pq);
	delete this;
}

void QueueTab :: on_switch_changed()
{
	if (q_switch.get_active()) {
		tab_pq->set_flag(Q_ENABLED);
		queue_set_sensitive(true);
	} else {
		tab_pq->unset_flag(Q_ENABLED);
		queue_set_sensitive(false);
	}
}



/**
 *
 * Global functions
 *
 */
static void renumber_queues()
{
	std::map<Gtk::Widget *, QueueTab *>::iterator it;
	for (it = queue_mapping.begin(); it != queue_mapping.end(); it++)
		it->second->on_tab_reordered();
}

void on_pq_created(Queue *pq, unsigned int num)
{
	QueueTab *tab = new QueueTab(pq, num);
	tab->on_post_init();
}

static void on_page_reordered(Gtk::Widget *page, int num)
{
	Gtk::Notebook *notebook = gui :: get_widget<Gtk::Notebook>("o_notebook");

	if ((unsigned int)num >= deck :: get_queues().size()) {
		notebook->reorder_child(*page, deck::get_queues().size() - 1);
		return;
	}

	std::map<Gtk::Widget *, QueueTab *>::iterator it;
	it = queue_mapping.find(page);
	if (it != queue_mapping.end()) {
		it->second->on_move_queue(num);
		renumber_queues();
	}
}

void init_queue_tabs()
{
	Gtk::Notebook *notebook = gui :: get_widget<Gtk::Notebook>("o_notebook");
	notebook->signal_page_reordered().connect(sigc::ptr_fun(on_page_reordered));
}

void post_init_queue_tabs()
{
	std::list<TempQueue>::iterator it;
	unsigned int i = 0;

	for (it = deck :: get_queues().begin(); it != deck :: get_queues().end(); it++)
		on_pq_created(&(*it), i++);
}