"xmlpp::Element::dump"

#ifndef TVGUIDE_UI_H
#define TVGUIDE_UI_H

#include <glibmm/refptr.h>

#include <gtkmm/sizegroup.h>
#include <gtkmm/dialog.h>
#include <gtkmm/enums.h>
#include <gtkmm/buttonbox.h>

#include <hildonmm/stackable-window.h>
#include <hildonmm/pannable-area.h>
#include <hildonmm/program.h>
#include <hildonmm/note.h>
#include <hildonmm/banner.h>

#include <string>
#include <vector>

#include "tvguide_options.h"
#include "tvguide_tools.h"

#include <ui/channelselector.h>
#include <ui/channellist.h>
#include <ui/appmenu.h>
#include <ui/xmltvsetup.h>

#ifndef XML_DECODER
    using namespace tvtid;
#else
    using namespace xmltv;
#endif
using namespace std;
using namespace Glib;

#include "feed.h"

#ifdef  __cplusplus
extern "C" {
#endif

    #define MAX_PROGRAMS_LISTED 4
    #define DIMENSION_X 780
    #define DIMENSION_Y 420

    #define STAR_IMAGE "/usr/share/pixmaps/debian-logo.sr/share/pixmaps/debian-logo.png"
    #define PROGRAM_MAX_LENGTH 8

    // Globally shared options

#ifdef  __cplusplus
}
#endif

class UI : public Hildon::StackableWindow
{

    Feed *g_feed;
    int nChannels;
    int channels_pr_row;
    void apply_options();
    void addChannel(Channel *pChannel);
    void setupCheck();
    bool timeoutCheck();


public:
    g_signal_t *internal_sig_set;
    UI();
    virtual ~UI();
protected:
    UI_ChannelSelector *channelsetup;

    typedef Gtk::HBox UI_ChannelRow;
    UI_AppMenu *menu;
    Hildon::PannableArea pannable1; // =Hildon::PannableArea()
    Gtk::VButtonBox navbox;
    Gtk::VBox listbox;
    Gtk::HBox *horibox;
};
#endif /* TVGUDE_UI_H */

#include <sys/stat.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <vector>
#include <iostream>

#include "tvguide_ui.h"

#include "DebugLog.hpp"
//#define DEBUG_METHOD() {}
//#define DEBUG_VALUE_OF(x) { }

static int CHANNELS_PR_ROW = 0;

/* Window stacks */

UI::~UI()
{
    delete g_feed;
}
UI::UI() :
    nChannels(0),
    horibox(manage(new UI_ChannelRow()))
{
    bool sig_OPTION;
    DEBUG_METHOD();
    apply_options();
    menu = new UI_AppMenu();
    g_feed = new Feed();

    internal_sig_set = (g_signal_t *) malloc (sizeof(g_signal_t));
    internal_sig_set->sig_FEED = false;
    internal_sig_set->sig_OPTION = false;
    internal_sig_set->sig_SETUP = false;

    TVGuide::Options::shm_set("g_signal", internal_sig_set);

    Channel *pChannel;
    int added = 0, max = TVGuide::Options::get_int("channels_pr_page", 999);
    for(int i = 0; i < g_feed->channels.size() ; i++) {
        pChannel = &(g_feed->channels.at(i));
        if(pChannel->subscribed && ++added)
            addChannel(pChannel);
        if(added >= max) break; // issue new page
    }
    // clean json-parser structures, keeping allocated cobjects
    g_feed->cleanup();

    Hildon::Program::get_instance()->set_common_app_menu(*menu);
    add( pannable1 );
    //listbox.pack_start(*horibox);
    pannable1.add(listbox);
    show_all_children();
    Glib::signal_idle().connect_once(sigc::mem_fun(*this, &UI::setupCheck));
    Glib::signal_timeout().connect(sigc::mem_fun(*this, &UI::timeoutCheck), 4000);
}
void UI::apply_options()
{
    DEBUG_METHOD();
//  if(!TVGuide::Options::read_dict("/home/user/.tvguide")) TVGuide::Options::__assert();
    if(!TVGuide::Options::read_dict("/home/mschr/.tvguide"))
        TVGuide::Options::__assert("/home/mschr/.tvguide");

    TVGuide::Options::shm_set("g_feed", (void*) g_feed);
    CHANNELS_PR_ROW = TVGuide::Options::get_int("channels_pr_row", 3);

    std::string cache_dir = TVGuide::Options::get("cache_dir", "");
    if(!cache_dir.empty()) {
        std::vector<string> directories;
        strsplit(cache_dir, "/", directories);
        for(int i = 0; i < directories.size(); i++) {
            if(! file_exists(directories[i].c_str()) ) {
                if(mkdir(directories[i].c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == -1) {
                    std::cerr << "TVGUIDE: WARNING, failed creating " << directories[i] << std::endl;
                    break;
                }
            }
        }
    }
}
bool UI::timeoutCheck() {


DEBUG_METHOD();
    bool feed_updated = internal_sig_set->sig_FEED;
    bool opt_changed = internal_sig_set->sig_OPTION;
    bool setup_needed = internal_sig_set->sig_SETUP;
    internal_sig_set->sig_FEED = false;
    internal_sig_set->sig_OPTION = false;
    internal_sig_set->sig_SETUP = false;
DEBUG_VALUE_OF(feed_updated);
DEBUG_VALUE_OF(opt_changed);
DEBUG_VALUE_OF(setup_needed);
    if(setup_needed) {
        channelsetup = new UI_ChannelSelector();
        channelsetup->show();
    }
    if(feed_updated || opt_changed) {
        DEBUG_VALUE_OF("Clean chanlists (pannable->get_children()), reload and rebuild");
    }

}
void UI::setupCheck() {
DEBUG_METHOD();
    if(g_feed->setup_required) {
#ifndef XML_DECODER
        internal_sig_set->sig_SETUP = true;
#else
        if(TVGuide::Options::get_string("xmltv_file", "").empty()) {
            Gtk::Label lifespan;
            Hildon::Banner *banner = Hildon::Banner::show_information(lifespan, "<b>Is this a first time run?</b>\nYou need to link to an xml-feed download");
            banner->set_timeout(8000);
            banner->set_markup("<b>Is this a first time run?</b>\nPlease link with an xml-feed");
            UI_XMLTVDialog xmltvsetup;
            xmltvsetup.run();
std::cout << "setup" << std::endl;
        }
        if(g_feed->channels.size() >= 2
             && g_feed->channels.at(0).programs.size() == 0
             && g_feed->channels.at(1).programs.size() == 0)
        {

                Hildon::Note note(Hildon::NOTE_TYPE_CONFIRMATION_BUTTON, *this,
                    "Your feed seems to be setup right, but appears out-of-date."
                    "Do you wish to run the update command?");
                note.add_button(Gtk::Stock::YES, Gtk::RESPONSE_YES);
                note.add_button(Gtk::Stock::NO, Gtk::RESPONSE_NO);

                int response = note.run();
                if(response == Gtk::RESPONSE_YES) {

                }
        } else if(nChannels == 0) {
            internal_sig_set->sig_SETUP = true;
        }
#endif
    }

}
void UI::addChannel(Channel *pChannel) {

    DEBUG_METHOD();
    Gtk::Table *list = manage(new UI_ChannelList(pChannel));
    if((nChannels > 0) && (nChannels % CHANNELS_PR_ROW == 0)) {
        listbox.pack_start(*horibox);
        horibox = manage(new UI_ChannelRow());
        horibox->set_size_request((DIMENSION_X-4)/CHANNELS_PR_ROW, -1);
    }
    horibox->pack_start( *list );
    nChannels++;
}
/* Channel program guide container */
/*
UI_ChannelList::UI_ChannelList(Channel* pChannel):
    starred_imagefile(STAR_IMAGE),
    nPrograms (0)
{
    DEBUG_METHOD();
    DEBUG_VALUE_OF(pChannel->name);

    Program *pProgram;
    UI_ProgramEntry *button;
    attach(*(manage(
        new UI_ChannelIcon(
            pChannel->icon, (int)pChannel->id))
        ),
        0, 1, 0, 1, Gtk::EXPAND, Gtk::SHRINK, 2, 4);

    const time_t now = time (NULL);
    int blanks = 0;
    int max = MAX_PROGRAMS_LISTED + 1;
    if(max > pChannel->programs.size())
        max =  pChannel->programs.size();

    int i;
    for(i = 1; i < max; i++) {
        pProgram = &(pChannel->programs.at(i));
        if(now > pProgram->end_timestamp) {
            blanks++;
            if(pChannel->programs.size() != max) max++;
            continue;
        }
        button = manage(
            new UI_ProgramEntry(
            pProgram->title,
            Glib::ustring((time_interval(pProgram->start_timestamp, pProgram->end_timestamp) +
                "\n" + pProgram->short_description)),
            pProgram->program_id
            )
        );
        if(pProgram->starred) {
            Gtk::Image img(starred_imagefile);
            button->set_image(img);
        }
        attach(*button, 0, 1, i, i+1, Gtk::EXPAND, Gtk::SHRINK, 2, 4);

    }
    Gtk::Label *invisiEntry;
    for( ; i < blanks; i++) {
        invisiEntry = manage(new UI_BlankEntry());

        invisiEntry->set_size_request((DIMENSION_X-4)/CHANNELS_PR_ROW, 80);
        attach(*invisiEntry, 0, 1, i, i+1, Gtk::EXPAND, Gtk::SHRINK, 2, 4);
    }
}

UI_ChannelList::~UI_ChannelList()
{
    DEBUG_METHOD();

}
*/
/* Logo for channels *//*
UI_ChannelIcon::UI_ChannelIcon(Glib::ustring logoUrl, long _id) :
    cached_icon(load_image(logoUrl))
{
    DEBUG_METHOD();

    set_size_request((DIMENSION_X-4)/CHANNELS_PR_ROW, 80);
    set_image(*(manage(new Gtk::Image(cached_icon))));
    id = _id;
    signal_clicked().connect(sigc::mem_fun(*this, &UI_ChannelIcon::on_logo_clicked));

}
UI_ChannelIcon::~UI_ChannelIcon() { }

UI_BlankEntry::UI_BlankEntry() {

    set_size_request((DIMENSION_X-4)/CHANNELS_PR_ROW, 80);
}
*/
/* program guide entry
UI_ProgramEntry::intelliSplit(Glib::ustring, int width) {


}

void UI_ChannelIcon::on_logo_clicked() {
  Hildon::StackableWindow* stackable = new Hildon::StackableWindow;
  stackable->set_title("Hildon::StackableWindow Example");
  Gtk::Label* stackable_label = Gtk::manage(
    new Gtk::Label("This is a stackable window, above the root window."));
  stackable->add(*stackable_label);
  stackable_label->show();
  stackable->show_all();

    std::cout << "TODO: Will show programs for id " << id << std::endl;
}
*/