/*
  Copyright (c) 2005 Joshua Elsasser. All rights reserved.
   
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:
   
   1. Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
   2. Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in the
      documentation and/or other materials provided with the distribution.
   
  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
*/

#include <assert.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/param.h>
#include <time.h>
#include <unistd.h>

#include <gtk/gtk.h>

#include "conf.h"
#include "transmission.h"
#include "util.h"

#define TRACKER_EXIT_TIMEOUT    30

struct cbdata {
  tr_handle_t *tr;
  GtkWidget *wind;
  GtkListStore *model;
  GtkTreeView *view;
  guint timer;
};

struct exitdata {
  struct cbdata *cbdata;
  time_t started;
  guint timer;
};

struct pieces {
  char p[120];
};

void
readargs(int argc, char **argv, int *port, int *limit);
void
maketypes(void);
gpointer
tr_pieces_copy(gpointer);
void
tr_pieces_free(gpointer);

void
makewind(GtkWidget *wind, tr_handle_t *tr, GList *saved);
gboolean
winclose(GtkWidget *widget, GdkEvent *event, gpointer gdata);
gboolean
exitcheck(gpointer gdata);
GtkWidget *
makewind_toolbar(struct cbdata *data);
GtkWidget *
makewind_list(struct cbdata *data);

gboolean
updatemodel(gpointer gdata);
gboolean
listclick(GtkWidget *widget, GdkEventButton *event, gpointer gdata);
gboolean
listpopup(GtkWidget *widget, gpointer userdata);
void
dopopupmenu(GtkWidget *widget, GdkEventButton *event, struct cbdata *data);
void
actionclick(GtkWidget *widget, gpointer gdata);

void
makeaddwind(struct cbdata *data);
gboolean
addtorrent(tr_handle_t *tr, GtkWidget *parentwind, const char *torrent,
           const char *dir, gboolean paused);
void
fileclick(GtkWidget *widget, gpointer gdata);
const char *
statusstr(int status);
void
makeinfowind(struct cbdata *data, int index);
gboolean
savetorrents(tr_handle_t *tr, GtkWidget *wind, int count, tr_stat_t *stat);

#define TR_TYPE_PIECES_NAME     "tr-type-pieces"
#define TR_TYPE_PIECES          ((const GType)tr_type_pieces)
#define TR_PIECES(ptr)          ((struct pieces*)ptr)
GType tr_type_pieces;

#define LIST_ACTION           "torrent-list-action"
enum listact { ACT_OPEN, ACT_START, ACT_STOP, ACT_DELETE, ACT_INFO };
#define LIST_ACTION_FROM      "torrent-list-action-from"
enum listfrom { FROM_BUTTON, FROM_POPUP };

#define LIST_INDEX            "torrent-list-index"

struct { gint pos; const gchar *name; const gchar *id; enum listact act;
  const char *ttext; const char *tpriv; }
actionitems[] = {
  {0,  "Add",         GTK_STOCK_ADD,          ACT_OPEN,
   "Add a new torrent file", "XXX"},
  {1,  "Resume",      GTK_STOCK_MEDIA_PLAY,   ACT_START,
   "Resume a torrent that has been paused", "XXX"},
  {2,  "Pause",       GTK_STOCK_MEDIA_PAUSE,  ACT_STOP,
   "Pause a torrent", "XXX"},
  {3,  "Remove",      GTK_STOCK_REMOVE,       ACT_DELETE,
   "Remove a torrent from the list", "XXX"},
  {4,  "Properties",  GTK_STOCK_PROPERTIES,   ACT_INFO,
   "Get additional information for a torrent", "XXX"},
};

#define CBDATA_PTR              "callback-data-pointer"
int
main(int argc, char **argv) {
  GtkWidget *mainwind, *preferr, *stateerr;
  char *err;
  int port, limit;
  tr_handle_t *tr;
  GList *saved;

  gtk_init(&argc, &argv);
  readargs(argc, argv, &port, &limit);

  tr = tr_init();

  if(cf_init(tr_getPrefsDirectory(tr), &err)) {
    if(cf_lock(&err)) {
      /* create main window now so any error dialogs can be it's children */
      mainwind = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      preferr = NULL;
      stateerr = NULL;

      if(!cf_loadprefs(&err)) {
        preferr = errmsg(mainwind, "%s", err);
        g_free(err);
      }
      saved = cf_loadstate(&err);
      if(NULL != err) {
        stateerr = errmsg(mainwind, "%s", err);
        g_free(err);
      }

      /* XXX need to remove port and limit options and make them prefs */
      /* XXX need prefs gui */
      /* XXX need default save dir pref */

      if(0 != port)
        tr_setBindPort(tr, port);
      if(0 != limit)
        tr_setUploadLimit(tr, limit);

      maketypes();
      makewind(mainwind, tr, saved);

      if(NULL != preferr)
        gtk_widget_show_all(preferr);
      if(NULL != stateerr)
        gtk_widget_show_all(stateerr);
    } else {
      errmsg_full(NULL, (errfunc_t)gtk_main_quit, NULL, "%s", err);
      g_free(err);
    }
  } else {
    errmsg_full(NULL, (errfunc_t)gtk_main_quit, NULL, "%s", err);
    g_free(err);
  }

  gtk_main();

  return 0;
}

void
readargs(int argc, char **argv, int *port, int *limit) {
  char *name;
  int opt, num;

  *port = 0;
  *limit = 0;

  if(NULL == (name = strrchr(argv[0], '/')) || '\0' == *(++name))
    name = argv[0];

  for(num = 1; num < argc; num++)
    if(0 == strcmp(argv[num], "-help") || 0 == strcmp(argv[num], "--help"))
      goto usage;

  while(0 <= (opt = getopt(argc, argv, "hp:u:"))) {
    switch(opt) {
      case 'p':
        num = atoi(optarg);
        if(0 < num && 0xffff > num)
          *port = num;
        break;
      case 'u':
        num = atoi(optarg);
        if(0 != num)
          *limit = num;
        break;
      default:
        goto usage;
    }
  }

  return;

 usage:
  printf("usage: %s [-h] [-p port] [-u limit]\n", name);
  exit(1);
}

void
maketypes(void) {
  tr_type_pieces = g_boxed_type_register_static(
    TR_TYPE_PIECES_NAME, tr_pieces_copy, tr_pieces_free);
}

gpointer
tr_pieces_copy(gpointer data) {
  return g_memdup(data, sizeof(struct pieces));
}

void
tr_pieces_free(gpointer data) {
  g_free(data);
}

void
makewind(GtkWidget *wind, tr_handle_t *tr, GList *saved) {
  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
  struct cbdata *data = g_new0(struct cbdata, 1);
  GtkWidget *list;
  GtkRequisition req;
  GList *ii;
  struct cf_torrentstate *ts;

  data->tr = tr;
  data->wind = wind;
  data->timer = -1;
  /* filled in by makewind_list */
  data->model = NULL;
  data->view = NULL;

  gtk_box_pack_start(GTK_BOX(vbox), makewind_toolbar(data), FALSE, FALSE, 0);

  list = makewind_list(data);
  gtk_widget_size_request(list, &req);
  gtk_container_add(GTK_CONTAINER(scroll), list);
  gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 5);

  gtk_container_add(GTK_CONTAINER(wind), vbox);
  gtk_window_set_default_size(GTK_WINDOW(wind), req.width, req.height);
  g_signal_connect(G_OBJECT(wind), "delete_event", G_CALLBACK(winclose), data);
  gtk_widget_show_all(wind);

  for(ii = g_list_first(saved); NULL != ii; ii = ii->next) {
    ts = ii->data;
    addtorrent(tr, wind, ts->ts_torrent, ts->ts_directory, ts->ts_paused);
    cf_freestate(ts);
  }
  g_list_free(saved);

  data->timer = g_timeout_add(500, updatemodel, data);
  updatemodel(data);
}

/* XXX is this the right thing to do? */
#define TR_TORRENT_NEEDS_STOP(t) \
  ((t) & TR_STATUS_CHECK || (t) & TR_STATUS_DOWNLOAD || (t) & TR_STATUS_SEED)

gboolean
winclose(GtkWidget *widget SHUTUP, GdkEvent *event SHUTUP, gpointer gdata) {
  struct cbdata *data = gdata;
  struct exitdata *edata;
  tr_stat_t *st;
  int ii;

  if(0 >= data->timer)
    g_source_remove(data->timer);
  data->timer = -1;

  for(ii = tr_torrentStat(data->tr, &st); 0 < ii; ii--) {
    if(TR_TORRENT_NEEDS_STOP(st[ii-1].status)) {
      fprintf(stderr, "quit: stopping %i %s\n", ii, st[ii-1].info.name);
      tr_torrentStop(data->tr, ii - 1);
    } else {
      fprintf(stderr, "quit: closing %i %s\n", ii, st[ii-1].info.name);
      tr_torrentClose(data->tr, ii - 1);
    }
  }
  free(st);

  /* XXX should disable widgets or something */

  /* try to wait until torrents stop before exiting */
  edata = g_new0(struct exitdata, 1);
  edata->cbdata = data;
  edata->started = time(NULL);
  edata->timer = g_timeout_add(500, exitcheck, edata);

  fprintf(stderr, "quit: starting timeout at %i\n", edata->started);

  //exitcheck(edata);

  /* returning FALSE means to destroy the window */
  return TRUE;
}

gboolean
exitcheck(gpointer gdata) {
  struct exitdata *data = gdata;
  tr_stat_t *st;
  int ii;

  for(ii = tr_torrentStat(data->cbdata->tr, &st); 0 < ii; ii--) {
    if(TR_STATUS_PAUSE == st[ii-1].status) {
      fprintf(stderr, "quit: closing %i %s\n", ii, st[ii-1].info.name);
      tr_torrentClose(data->cbdata->tr, ii - 1);
    }
  }
  free(st);

  fprintf(stderr, "quit: %i torrents left at %i\n",
          tr_torrentCount(data->cbdata->tr), time(NULL));
  /* keep going if we still have torrents and haven't hit the exit timeout */
  if(0 < tr_torrentCount(data->cbdata->tr) &&
     time(NULL) - data->started < TRACKER_EXIT_TIMEOUT) {
    updatemodel(data->cbdata);
    return TRUE;
  }

  fprintf(stderr, "quit: giving up on %i torrents\n",
          tr_torrentCount(data->cbdata->tr));

  for(ii = tr_torrentCount(data->cbdata->tr); 0 < ii; ii--)
    tr_torrentClose(data->cbdata->tr, ii - 1);

  /* exit otherwise */

  if(0 >= data->timer)
    g_source_remove(data->timer);
  data->timer = -1;

  gtk_widget_destroy(data->cbdata->wind);
  tr_close(data->cbdata->tr);
  g_free(data->cbdata);
  g_free(data);
  gtk_main_quit();

  return FALSE;
}

GtkWidget *
makewind_toolbar(struct cbdata *data) {
  GtkWidget *bar = gtk_toolbar_new();
  GtkToolItem *item;
  unsigned int ii;

  gtk_toolbar_set_tooltips(GTK_TOOLBAR(bar), TRUE);
  gtk_toolbar_set_style(GTK_TOOLBAR(bar), GTK_TOOLBAR_BOTH);

  for(ii = 0; ii < sizeof(actionitems) / sizeof(actionitems[0]); ii++) {
    item = gtk_tool_button_new_from_stock(actionitems[ii].id);
    gtk_tool_button_set_label(GTK_TOOL_BUTTON(item), actionitems[ii].name);
    gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(item), GTK_TOOLBAR(bar)->tooltips,
                              actionitems[ii].ttext, actionitems[ii].tpriv);
    g_object_set_data(G_OBJECT(item), LIST_ACTION,
                      GINT_TO_POINTER(actionitems[ii].act));
    g_object_set_data(G_OBJECT(item), LIST_ACTION_FROM,
                      GINT_TO_POINTER(FROM_BUTTON));
    g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(actionclick), data);
    gtk_toolbar_insert(GTK_TOOLBAR(bar), GTK_TOOL_ITEM(item), actionitems[ii].pos);
  }

  return bar;
}

enum {MC_NAME, MC_SIZE, MC_STAT, MC_ERR, MC_PROG, MC_DRATE, MC_URATE,
      MC_ETA, MC_PEERS, MC_UPEERS, MC_DPEERS, MC_PIECES, MC_DOWN, MC_UP,
      MC_ROW_INDEX, MC_ROW_COUNT};

GtkWidget *
makewind_list(struct cbdata *data) {
  GType types[] = {
    /* info->name, info->totalSize, status,     error,         progress */
    G_TYPE_STRING, G_TYPE_UINT64,   G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT,
    /* rateDownload, rateUpload,   eta,        peersTotal, peersUploading */
    G_TYPE_FLOAT,    G_TYPE_FLOAT, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT,
    /* peersDownloading, pieces,         downloaded,    uploaded */
    G_TYPE_INT,          TR_TYPE_PIECES, G_TYPE_UINT64, G_TYPE_UINT64,
    /* index into the torrent array */
    G_TYPE_INT};
  GtkListStore *model;
  GtkWidget *view;
  /*GtkTreeViewColumn *col;*/
  GtkTreeSelection *sel;
  GtkCellRenderer *rend;
  GtkCellRenderer *rendprog;

  assert(MC_ROW_COUNT == sizeof(types) / sizeof(types[0]));

  model = gtk_list_store_newv(MC_ROW_COUNT, types);
  view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
  /* XXX do I need to worry about reference counts anywhere else? */
  g_object_unref(G_OBJECT(model));
  data->model = model;
  data->view = GTK_TREE_VIEW(view);

  rend = gtk_cell_renderer_text_new();
  rendprog = gtk_cell_renderer_progress_new();
  g_object_set(rendprog, "text", "", NULL);

/*
  col = gtk_tree_view_column_new_with_attributes(
    "Name", rend, "text", MC_NAME, NULL);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_SIZE);
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);

  col = gtk_tree_view_column_new_with_attributes(
    "Status", rend, "text", MC_STAT, NULL);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_ERR);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_DPEERS);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_UPEERS);
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);

  col = gtk_tree_view_column_new_with_attributes(
    "Progress", rendprog, "value", MC_PROG, NULL);
  gtk_tree_view_column_pack_start(col, rend, TRUE);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_ETA);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_DRATE);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_URATE);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_DOWN);
  gtk_tree_view_column_add_attribute(col, rend, "text", MC_UP);
  gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
*/

  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Name", rend,
                                             "text", MC_NAME, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Size", rend,
                                             "text", MC_SIZE, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Status", rend,
                                             "text", MC_STAT, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Error", rend,
                                             "text", MC_ERR, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Progress", rendprog,
                                             "value", MC_PROG, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Download Rate", rend,
                                             "text", MC_DRATE, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Upload Rate", rend,
                                             "text", MC_URATE, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("ETA", rend,
                                             "text", MC_ETA, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Peers", rend,
                                             "text", MC_PEERS, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Seeders", rend,
                                             "text", MC_UPEERS, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Leechers", rend,
                                             "text", MC_DPEERS, NULL));
  /*gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("", rend,
                                             "text", MC_PIECES, NULL));*/
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Downloaded", rend,
                                             "text", MC_DOWN, NULL));
  gtk_tree_view_append_column(GTK_TREE_VIEW(view),
    gtk_tree_view_column_new_with_attributes("Uploaded", rend,
                                             "text", MC_UP, NULL));

  gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
  sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gtk_tree_selection_set_mode(GTK_TREE_SELECTION(sel), GTK_SELECTION_SINGLE);
  g_signal_connect(G_OBJECT(view), "button-press-event",
                   G_CALLBACK(listclick), data);
  g_signal_connect(G_OBJECT(view), "popup-menu", G_CALLBACK(listpopup), data);
  gtk_widget_show_all(view);

  return view;
}

gboolean
updatemodel(gpointer gdata) {
  struct cbdata *data = gdata;
  tr_stat_t *st;
  int ii, max, prog;
  GtkTreeIter iter;

  max = tr_torrentStat(data->tr, &st);
  for(ii = 0; ii < max; ii++) {
    if(!(ii ? gtk_tree_model_iter_next(GTK_TREE_MODEL(data->model), &iter) :
         gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->model), &iter)))
      gtk_list_store_append(data->model, &iter);
    if(0.0 > (prog = st[ii].progress * 100.0))
      prog = 0;
    else if(100 < prog)
      prog = 100;
    /* XXX find out if setting the same data emits changed signal */
    gtk_list_store_set(data->model, &iter, MC_ROW_INDEX, ii,
      MC_NAME, st[ii].info.name, MC_SIZE, st[ii].info.totalSize, MC_STAT, st[ii].status,
      MC_ERR, st[ii].error, MC_PROG, prog, MC_DRATE, st[ii].rateDownload,
      MC_URATE, st[ii].rateUpload, MC_ETA, st[ii].eta, MC_PEERS, st[ii].peersTotal,
      MC_UPEERS, st[ii].peersUploading, MC_DPEERS, st[ii].peersDownloading,
      /*MC_PIECES, st[ii].pieces,*/ MC_DOWN, st[ii].downloaded, MC_UP, st[ii].uploaded, -1);
  }
  free(st);

  return TRUE;
}

gboolean
listclick(GtkWidget *widget, GdkEventButton *event, gpointer gdata) {
  struct cbdata *data = gdata;

  if(GDK_BUTTON_PRESS == event->type && 3 == event->button) {
    dopopupmenu(widget, event, data);
    return TRUE;
  }

  return FALSE;
}

gboolean
listpopup(GtkWidget *widget, gpointer userdata) {
  dopopupmenu(widget, NULL, userdata);

  return TRUE;
}

void
dopopupmenu(GtkWidget *widget SHUTUP, GdkEventButton *event,
            struct cbdata *data) {
  GtkWidget *menu = gtk_menu_new();
  GtkWidget *item;
  GtkTreePath *path;
  GtkTreeIter iter;
  unsigned int ii;
  int index;

  index = -1;
  if(NULL != event && gtk_tree_view_get_path_at_pos(
       data->view, event->x, event->y, &path, NULL, NULL, NULL)) {
    if(gtk_tree_model_get_iter(GTK_TREE_MODEL(data->model), &iter, path))
      gtk_tree_model_get(GTK_TREE_MODEL(data->model), &iter, MC_ROW_INDEX, &index, -1);
    gtk_tree_path_free(path);
  }

  /* XXX am I leaking references here? */
  /* XXX can I cache this in cbdata? */
  for(ii = 0; ii < sizeof(actionitems) / sizeof(actionitems[0]); ii++) {
    item = gtk_menu_item_new_with_label(actionitems[ii].name);
    g_object_set_data(G_OBJECT(item), LIST_ACTION,
                      GINT_TO_POINTER(actionitems[ii].act));
    g_object_set_data(G_OBJECT(item), LIST_ACTION_FROM,
                      GINT_TO_POINTER(FROM_POPUP));
    g_object_set_data(G_OBJECT(item), LIST_INDEX, GINT_TO_POINTER(index));
    g_signal_connect(G_OBJECT(item), "activate",
                     G_CALLBACK(actionclick), data);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
  }

  gtk_widget_show_all(menu);

  gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
                 (NULL == event ? 0 : event->button),
                 gdk_event_get_time((GdkEvent*)event));
}

void
actionclick(GtkWidget *widget, gpointer gdata) {
  struct cbdata *data = gdata;
  GtkTreeSelection *sel = gtk_tree_view_get_selection(data->view);
  GtkTreeModel *model;
  GtkTreeIter iter;
  enum listact act =
    GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), LIST_ACTION));
  enum listfrom from =
    GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), LIST_ACTION_FROM));
  int index;
  tr_stat_t *sb;

  if(ACT_OPEN == act) {
    makeaddwind(data);
    return;
  }

  index = -1;
  switch(from) {
    case FROM_BUTTON:
      if(gtk_tree_selection_get_selected(sel, &model, &iter))
        gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
                           MC_ROW_INDEX, &index, -1);
      /* XXX should I assert(0 <= index) to insure a row was selected? */
      break;
    case FROM_POPUP:
      index = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), LIST_INDEX));
      break;
    default:
      assert(!"unknown action source");
      break;
  }

  if(0 <= index) {
    switch(act) {
      case ACT_START:
        tr_torrentStart(data->tr, index);
        savetorrents(data->tr, data->wind, -1, NULL);
        break;
      case ACT_STOP:
        tr_torrentStop(data->tr, index);
        savetorrents(data->tr, data->wind, -1, NULL);
        break;
      case ACT_DELETE:
        /* XXX need to be able to stat just one torrent */
        if(index >= tr_torrentStat(data->tr, &sb)) {
          assert(!"XXX i'm tired");
        }
        if(TR_TORRENT_NEEDS_STOP(sb[index].status))
          tr_torrentStop(data->tr, index);
        free(sb);
        tr_torrentClose(data->tr, index);
        gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
        savetorrents(data->tr, data->wind, -1, NULL);
        break;
      case ACT_INFO:
        makeinfowind(data, index);
        break;
      default:
        assert(!"unknown type");
        break;
    }
  }
}

void
makeaddwind(struct cbdata *data) {
  GtkWidget *wind = gtk_file_selection_new("Add a Torrent");

  g_object_set_data(G_OBJECT(GTK_FILE_SELECTION(wind)->ok_button),
                    CBDATA_PTR, data);
  g_signal_connect(GTK_FILE_SELECTION(wind)->ok_button, "clicked",
                   G_CALLBACK(fileclick), wind);
  g_signal_connect_swapped(GTK_FILE_SELECTION(wind)->cancel_button, "clicked",
                           G_CALLBACK(gtk_widget_destroy), wind); 
  gtk_window_set_transient_for(GTK_WINDOW(wind), GTK_WINDOW(data->wind));
  gtk_window_set_destroy_with_parent(GTK_WINDOW(wind), TRUE);
  gtk_window_set_modal(GTK_WINDOW(wind), TRUE);
  gtk_widget_show_all(wind);
}

gboolean
addtorrent(tr_handle_t *tr, GtkWidget *parentwind, const char *torrent,
           const char *dir, gboolean paused) {
  char *wd;

  if(0 != tr_torrentInit(tr, torrent)) {
    /* XXX would be nice to have errno strings, are they printed to stdout? */
    errmsg(parentwind, "Failed to open torrent file %s", torrent);
    return FALSE;
  }

  if(NULL != dir)
    tr_torrentSetFolder(tr, tr_torrentCount(tr) - 1, dir);
  else {
    /* XXX need pref for download directory */
    wd = g_new(char, MAXPATHLEN + 1);
    if(NULL == getcwd(wd, MAXPATHLEN + 1))
      tr_torrentSetFolder(tr, tr_torrentCount(tr) - 1, ".");
    else {
      tr_torrentSetFolder(tr, tr_torrentCount(tr) - 1, wd);
      free(wd);
    }
  }

  if(!paused)
    tr_torrentStart(tr, tr_torrentCount(tr) - 1);
  return TRUE;
}

void
fileclick(GtkWidget *widget, gpointer gdata) {
  struct cbdata *data = g_object_get_data(G_OBJECT(widget), CBDATA_PTR);
  GtkWidget *wind = gdata;
  const char *file = gtk_file_selection_get_filename(GTK_FILE_SELECTION(wind));

  if(addtorrent(data->tr, data->wind, file, NULL, FALSE)) {
    updatemodel(data);
    savetorrents(data->tr, data->wind, -1, NULL);
  }

  gtk_widget_destroy(wind);
}

const char *
statusstr(int status) {
  switch(status) {
    case TR_STATUS_CHECK:       return "check";
    case TR_STATUS_DOWNLOAD:    return "download";
    case TR_STATUS_SEED:        return "seed";
    case TR_STATUS_STOPPING:    return "stopping";
    case TR_STATUS_STOPPED:     return "stopped";
    case TR_STATUS_PAUSE:       return "pause";
    case TR_TRACKER_ERROR:      return "error";
    default:
      assert(!"unknown status code");
      return NULL;
  }
}

void
makeinfowind(struct cbdata *data, int index) {
  tr_stat_t *sb;
  GtkWidget *wind, *table, *name, *value;
  char buf[32];

  if(index >= tr_torrentStat(data->tr, &sb)) {
    assert(!"XXX i'm tired");
  }
  wind = gtk_dialog_new_with_buttons(sb[index].info.name, GTK_WINDOW(data->wind),
    GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);

  table = gtk_table_new(21, 2, FALSE);

  name = gtk_label_new("Torrent File");
  value = gtk_label_new(sb[index].info.torrent);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 0, 1);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 0, 1);
  name = gtk_label_new("Name");
  value = gtk_label_new(sb[index].info.name);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 1, 2);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 1, 2);
  name = gtk_label_new("Tracker Address");
  value = gtk_label_new(sb[index].info.trackerAddress);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 2, 3);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 2, 3);
  name = gtk_label_new("Tracker Port");
  snprintf(buf, sizeof buf, "%i", sb[index].info.trackerPort);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 3, 4);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 3, 4);
  name = gtk_label_new("Tracker Announce URL");
  value = gtk_label_new(sb[index].info.trackerAnnounce);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 4, 5);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 4, 5);
  name = gtk_label_new("Piece Size");
  snprintf(buf, sizeof buf, "%i", sb[index].info.pieceSize);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 5, 6);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 5, 6);
  name = gtk_label_new("Piece Count");
  snprintf(buf, sizeof buf, "%i", sb[index].info.pieceCount);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 6, 7);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 6, 7);
  name = gtk_label_new("Total Size");
  snprintf(buf, sizeof buf, "%llu", sb[index].info.totalSize);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 7, 8);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 7, 8);
  name = gtk_label_new("File Count");
  snprintf(buf, sizeof buf, "%i", sb[index].info.fileCount);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 8, 9);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 8, 9);
  name = gtk_label_new("Status");
  value = gtk_label_new(statusstr(sb[index].status));
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 9, 10);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 9, 10);
  name = gtk_label_new("Error");
  value = gtk_label_new(sb[index].error);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 10, 11);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 10, 11);
  name = gtk_label_new("Progress");
  snprintf(buf, sizeof buf, "%f", sb[index].progress);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 11, 12);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 11, 12);
  name = gtk_label_new("Download Rate");
  value = gtk_label_new(buf);
  snprintf(buf, sizeof buf, "%f", sb[index].rateDownload);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 12, 13);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 12, 13);
  name = gtk_label_new("Upload Rate");
  snprintf(buf, sizeof buf, "%f", sb[index].rateUpload);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 13, 14);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 13, 14);
  name = gtk_label_new("ETA");
  snprintf(buf, sizeof buf, "%i", sb[index].eta);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 14, 15);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 14, 15);
  name = gtk_label_new("Total Peers");
  snprintf(buf, sizeof buf, "%i", sb[index].peersTotal);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 15, 16);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 15, 16);
  name = gtk_label_new("Uploading Peers");
  snprintf(buf, sizeof buf, "%i", sb[index].peersUploading);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 16, 17);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 16, 17);
  name = gtk_label_new("Downloading Peers");
  snprintf(buf, sizeof buf, "%i", sb[index].peersDownloading);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 17, 18);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 17, 18);
  name = gtk_label_new("Downloaded");
  snprintf(buf, sizeof buf, "%llu", sb[index].downloaded);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 18, 19);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 18, 19);
  name = gtk_label_new("Uploaded");
  snprintf(buf, sizeof buf, "%llu", sb[index].uploaded);
  value = gtk_label_new(buf);
  gtk_table_attach_defaults(GTK_TABLE(table), name, 0, 1, 19, 20);
  gtk_table_attach_defaults(GTK_TABLE(table), value, 1, 2, 19, 20);

  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(wind)->vbox), table);
  g_signal_connect(G_OBJECT(wind), "response",
                   G_CALLBACK(gtk_widget_destroy), NULL);
  gtk_widget_show_all(wind);
  free(sb);
}

gboolean
savetorrents(tr_handle_t *tr, GtkWidget *wind, int count, tr_stat_t *stat) {
  char *errstr;
  tr_stat_t *st;
  gboolean ret;

  assert(NULL != tr || 0 <= count);

  if(0 <= count)
    ret = cf_savestate(count, stat, &errstr);
  else {
    count = tr_torrentStat(tr, &st);
    ret = cf_savestate(count, st, &errstr);
    free(st);
  }

  if(!ret) {
    errmsg(wind, "%s", errstr);
    g_free(errstr);
  }

  return ret;
}