/*
 * browse.c
 */

#include "browse.h"
#include "cache.h"
#include "external-player.h"
#include "audiorecorder.h"
#include "setup.h"

#include <vdr/skins.h>
#include <vdr/interface.h>
#include <vdr/tools.h>

#include <sstream>


#define MAXCOLS 5
#define TAB_LEN 3
#define SERVICE "MP3-Play-v1"

using namespace std;

/* --- cBrowse -------------------------------------------------------------- */

cBrowse::cBrowse(void)
:cOsdMenu("")
{
	num_columns = MAXCOLS;
	columns = NULL;
	columns = new cColumn[num_columns + 1];
        
	player = cPluginManager::CallFirstService(SERVICE);
        
        string skin = Skins.Current()->Name();
        width = DisplayMenu()->EditableWidth();
        
        if (skin != "curses")
                width /= 12;
        
	dsyslog("[audiorecorder]: skin %s (width %d) detected (%s, %s())",
                skin.c_str(), width, __FILE__, __func__);
        
        set_view(SetupValues.default_view);
}


cBrowse::~cBrowse()
{
	delete[] columns;
}


eOSState cBrowse::ProcessKey(eKeys key)
{
	eOSState state = cOsdMenu::ProcessKey(key);
        
        if (HasSubMenu()) {
		process_submenu_states(state);
                
                if (state == osBack || key == kBlue || key == kOk)
                        CloseSubMenu();
                        
		return osContinue;
        }
        
        set_status();
        set_help_keys();
        
	cBrowseItem *item = get_actual_item();
        
	switch (key) {
        case kRed:
		if (! item)
                        break;
                
                if (item->is_node())
                        AddSubMenu(new cBrowseAction(true,
                                        get_category(item)));
                else
                        AddSubMenu(new cBrowseAction(false,
                                        get_trackname(item->get_track())));
                
                break;
	case kGreen:
		if (help_green.empty())
			break;
                
		expand ? expand = false : expand = true;
		set_view(view, false);
                
		break;
        case kYellow:
                set_view(++view);
                
                break;
	case kBlue:
                if (item && ! item->is_node())
                        AddSubMenu(new cBrowseInfo(item->get_track()));
                
                break;
	case kOk:
		if (! item)
			break;
                
                if (! item->is_node())
                        play_file(item->get_track());
                else if (item->is_closed()) {
                        item->toggle_node();
                        insert_items();
                }
		else {
                        item->toggle_node();
                        delete_items();
                }
		break;
	default:
		break;
	}
        
	return state;
}


void cBrowse::set_view(int _view, bool init)
{
        view = _view;
        
        if (view == 1) {
                /* view by artist */
                num_columns = 2;
                
                columns[0].set(colArtist, TAB_LEN);
                columns[1].set(colTitle, width - TAB_LEN);
                columns[2].set(colEnd);
                
		if (init)
			expand = false;
                
                help_yellow = views[2];
        }
        else if (view == 2) {
                /* view by channel */
                num_columns = 3;
                
                columns[0].set(colChannel, TAB_LEN);
                columns[1].set(colEvent, TAB_LEN);
                columns[2].set(colArtistTitle, width - 2 * TAB_LEN);
                columns[3].set(colEnd);
        	
		if (init)
			expand = false;
                
                help_yellow = views[3];
        }
        else if (view == 3) {
                /* view by date */
                num_columns = 2;
                
                columns[0].set(colDate, TAB_LEN);
                columns[1].set(colTime, 6, true);
                columns[2].set(colChannel, 11, true, true);
                columns[3].set(colArtistTitle, width - TAB_LEN - 17);
                columns[4].set(colEnd);
                
		if (init)
			expand = true;
                
                help_yellow = views[0];
        }
        else {
                /* all */
                view = 0;
                num_columns = 1;
                
                columns[0].set(colArtistTitle, width);
                columns[1].set(colEnd);
                
		if (init)
			expand = true;
                
                help_yellow = views[1];
        }
        
	if (init) { 
		SetCols(columns[0].get_width(), columns[1].get_width(),
			columns[2].get_width(), columns[3].get_width(),
			columns[4].get_width());
                
        	Cache.sort(columns);
	}
        
        Clear();
        insert_items();
        
        set_status();
	set_help_keys();
        set_title();
}


void cBrowse::set_help_keys(void)
{
	/* green key */
	if (view == 0)
		help_green.erase();
	else if (expand)
                help_green = tr("collapse all");
	else
                help_green = tr("expand all");
        
        cBrowseItem *item = get_actual_item();
        
        SetHelp(tr("action"), (help_green.empty() ? NULL : help_green.c_str()) ,
		help_yellow, (item && ! item->is_node() ? "info" : NULL));
}


void cBrowse::set_status(void)
{
        /* disable status for the skin sttng: */
        if (strcmp(Skins.Current()->Name(), "sttng") == 0)
                return;
        
	string status(views[view]);
        
	cBrowseItem *item = get_actual_item();
        
	if (item && item->get_main_item()) {
                status.append(" ");
		status.append(get_category(item));
        }
        
        cut_string(status, width);
	SetStatus(status.c_str());
}


void cBrowse::set_title(void)
{
        stringstream title;
        title << tr("Audiorecorder") << ", " << tr("Browse tracks") << " (" << Cache.get_num_cached()
              << ")";
        
        SetTitle(title.str().c_str());
}


void cBrowse::process_submenu_states(eOSState &state)
{
	cBrowseItem *item = get_actual_item();
        
	switch(state) {
	case osUser1:
		play_all_files(item);
		state = osBack;
                
		break;
	case osUser6:
		if (item)
			play_file(item->get_track());
                
		state = osBack;
                
		break;
	default:
		break;
	}
}


cBrowseItem *cBrowse::get_actual_item(void)
{
	if (Current() < 0)
		return NULL;
        
	return (cBrowseItem *)Get(Current());
}


void cBrowse::insert_items(void)
{
        int pos = Current();
        
        /* clean up old states */
        for (int c = 0; c < num_columns; ++c) {
                columns[c].set_main_item(NULL);
                columns[c].del_last_entry();
        }
        
	int column = 0;
	cBrowseItem *item = get_actual_item();
        if (item && item->is_node()) {
		set_filter(item);
                column = item->get_column();
                columns[column].set_main_item(item);
                ++column;
        }
        
	int depth;
	if (expand)
		depth = num_columns;
	else
		depth = column + 1;
        
	for (const cTrackInfo *track = Cache.get_next_track(true); track;
             track = Cache.get_next_track()) {
                
                if (filter_track(track))
                        continue;
                
                for (int c = column; c < depth; ++c) {
                        eItemType type;
                        
                        string entry = get_value_of_column(track, c);                        
                        
                        if (c == num_columns - 1)
                                type = itemTrack;
			else if (expand)
				type = itemNodeOpen;
			else
				type = itemNodeClose;
                        
			/* don't show double nodes: */
                        if (type != itemTrack &&
			    entry == columns[c].get_last_entry())
                                continue;
                        
                        columns[c].set_last_entry(entry);
                        for (int i = c + 1; i < num_columns; ++i)
                                columns[i].del_last_entry();
                        
                        if (type == itemNodeOpen)
                                entry.insert(0, "[-] ");
                        else if (type == itemNodeClose)
                                entry.insert(0, "[+] ");
                        
                        string indent(c, '\t');
                        entry.insert(0, indent);
                        
                        cBrowseItem *item, *main = NULL;
                        if (c > 0)
                                main = columns[c - 1].get_main_item();
                        
                        item = new cBrowseItem(main, track, c, type);
                        item->SetText(entry.c_str());
                        columns[c].set_main_item(item);
                        
                        Add(item, true, Get(Current()));
                }
	}
        
        SetCurrent(Get(pos));
        Display();
}


void cBrowse::delete_items(void)
{
	cBrowseItem *item = get_actual_item();
	if (! item || ! item->is_node())
		return;
        
        for (int c = 0; c < item->get_items(); ++c)
                Del(Current() + 1);
        
        item->delete_items(item->get_items());
        
        Display();
}


void cBrowse::set_filter(const cBrowseItem *item)
{
        for (int c = 0; c < num_columns; ++c) {
                string filter("");
                if (c <= item->get_column())
                        filter = get_value_of_column(item->get_track(), c);
                
                columns[c].set_filter(filter);
        }
}


bool cBrowse::filter_track(const cTrackInfo *track)
{
        for (int c = 0; c < num_columns; ++c) {
                
                if (columns[c].get_filter().empty())
                        continue;
                
                if (columns[c].get_filter() != get_value_of_column(track, c))
                        return true;
        }
        
        return false;
}


string cBrowse::get_category(const cBrowseItem *item)
{
	string category("");
        
        if (item) {
                int columns = item->get_column();
                
                if (item->is_node())
                        ++columns;
                
                for (int c = 0; c < columns; ++c) {
                        if (c != 0)
                                category.append("/");
                        
                        category.append(get_value_of_column(item->get_track(),
                                        c));
                }
        }
        
	return category;
}


string cBrowse::get_trackname(const cTrackInfo *track)
{
        string trackstr("");
        
        if (track) {
                trackstr.append(track->get_artist());
                trackstr.append(" - ");
                trackstr.append(track->get_title());
        }
        
        return trackstr;
}


string cBrowse::get_value_of_column(const cTrackInfo *track, int c)
{
        string value("");
        bool join = true;
        
        while (join && columns[c].get_type() != colEnd) {
                stringstream col_tmp;
                
                switch (columns[c].get_type()) {
                case colArtist:
                        col_tmp << track->get_artist();
                        break;
                case colTitle:
                        col_tmp << track->get_title();
                        break;
                case colArtistTitle:
                        col_tmp << track->get_artist() << " - "
                                << track->get_title();
			break;
                case colAlbum:
                        col_tmp << track->get_album();
                        break;
                case colTrack:
                        col_tmp << track->get_track();
                        break;
                case colYear:
                        col_tmp << track->get_year();
                        break;
                case colGenre:
                        col_tmp << track->get_genre();
                        break;
                case colChannel:
                        col_tmp << track->get_channel();
                        break;
                case colEvent:
                        col_tmp << track->get_event();
                        break;
                case colDate:
                        col_tmp << track->get_date();
                        break;
                case colTime:
                        col_tmp << track->get_time();
                        break;
                default:
                        break;
                }
                
                if (col_tmp.str().empty())
                        col_tmp << tr("unknown");
                
                string col(col_tmp.str());
                
		if (columns[c].get_cut())
                        cut_string(col, columns[c].get_width() - 1);
                
                value.append(col);
                
                join = columns[c].is_joined();
                if (join)
                        value.append("\t");
                
                ++c;
        }
        
        return value;
}


void cBrowse::play_all_files(const cBrowseItem *node)
{
	if (! player) {
                Skins.Message(mtError, tr("No external player-plugin found"), 2);
		return;
        }
        
	if (! node || ! node->is_node())
		return;
        
	set_filter(node);
        
        string status = tr("Playing all tracks in ");
        status.append(get_category(node));
        cut_string(status, width);
        SetStatus(status.c_str());
        
	for (const cTrackInfo *track = Cache.get_next_track(true); track;
             track = Cache.get_next_track()) {
                
                if (! filter_track(track))
                        play_file(track, false);
	}
}


void cBrowse::play_file(const cTrackInfo *track, bool set_status)
{
	if (! player) {
                Skins.Message(mtError, tr("No external player-plugin found"), 2);
		return;
        }
        
	MP3ServiceData data;
	data.data.filename = track->get_path().c_str();
	data.result = 0;
        
#ifndef AUDIORECORDER_DEVEL
	player->Service(SERVICE, &data);
        
	if (data.result == 0) {
		dsyslog("[audiorecorder]: plugin %s could not play the file "
			"%s (%s, %s())", player->Name(),
			track->get_path().c_str(), __FILE__, __func__);
                return;
	}
#endif /* AUDIORECORDER_DEVEL */
        
        if (set_status) {
                string status = tr("Playing ");
                status.append(get_trackname(track));
                cut_string(status, width);
                SetStatus(status.c_str());
        }
}


void cBrowse::cut_string(string &cut, int length)
{
        if ((int)cut.length() > length) {
                cut.erase(length - 1);
                cut.append("~");
        }
}


/* --- cBrowseAction -------------------------------------------------------- */

cBrowseAction::cBrowseAction(bool node, const string &text)
:cOsdMenu(tr("Audiorecorder, Action"))
{
        string status("");
        if (node) {
                status.append(tr("Category : "));
                status.append(text);
                Add(new cOsdItem(tr("Play all tracks"), osUser1));
                Add(new cOsdItem(tr("More to come ..."), osUser7));
        }
        else {
                status.append(tr("Track: "));
                status.append(text);
                Add(new cOsdItem(tr("Play track"), osUser6));
                Add(new cOsdItem(tr("More to come ..."), osUser7));
        }
        
        SetStatus(status.c_str());
        SetHelp(NULL, NULL, NULL, tr("back"));
}


/* --- cBrowseInfo ---------------------------------------------------------- */

cBrowseInfo::cBrowseInfo(const cTrackInfo *track)
:cOsdMenu(tr("Audiorecorder, Info"), 11)
{
	string path = track->get_path();
	path.erase(0, cPluginAudiorecorder::get_recdir().length());
        Add(add_item(tr("File"), path));
        
        Add(add_item(tr("Artist"), track->get_artist()));
        Add(add_item(tr("Title"), track->get_title()));
        Add(add_item(tr("Album"), track->get_album()));
        Add(add_item(tr("Genre"), track->get_genre()));
        
       	stringstream tmp;
        tmp << track->get_track();
        Add(add_item(tr("Track"), tmp.str()));
        
        tmp.str("");
        tmp.clear();
        tmp << track->get_year();
        Add(add_item(tr("Year"), tmp.str()));
        
        Add(add_item(tr("Channel"), track->get_channel()));
        Add(add_item(tr("Event"), track->get_event()));
        Add(add_item(tr("Date"), track->get_date()));
        Add(add_item(tr("Time"), track->get_time()));
        
        SetHelp(NULL, NULL, NULL, tr("back"));
}


cOsdItem *cBrowseInfo::add_item(const char *type, const string &text)
{
	string txt = type;
	txt.append(":\t");
        
	if (text.empty() || text == "0")
                txt.append(tr("unknown"));
	else
		txt.append(text);
        
	return new cOsdItem(txt.c_str(), osUnknown, false);
}
