%h{

#include "defines.h"
#include "brushing.h"
#include "vartable.h"
#include "fileio.h"

#include <gtk/gtk.h>

typedef struct _Subset {
  gint random_n;
  gint string_pos;
 /*-- adjustments from which to get values for blocksize, everyn --*/
  GtkAdjustment *bstart_adj, *bsize_adj;
  GtkAdjustment *estart_adj, *estep_adj;
} Subset;


typedef struct _Jitterd {
  gfloat factor;
  gboolean type;
  gboolean convex;
  gfloat *jitfacv;
} Jitterd;

typedef struct _Varpanel_cboxd {
  GtkWidget *ebox;   /*-- child1 of pane widget --*/
  GtkWidget *swin;   /*-- child of ebox --*/
  GtkWidget *vbox;   /*-- child of swin --*/
  GSList *box;       /*-- single column of hboxes --*/
} Varpanel_cboxd;

typedef struct _Varpanel_circd {
  GtkWidget *ebox;        /*-- child2 of pane widget --*/
  GtkWidget *vbox;        /*-- child of ebox --*/
  GtkWidget *swin, *hbox; /*-- children of vbox --*/
  GtkWidget *table;       /*-- sole child of swin; now a vbox --*/
  GtkWidget *manip_btn, *freeze_btn; /*-- children of hbox --*/

  GdkCursor *cursor;
  gint jcursor;

 /*-- components and properties of the table --*/
  GSList *vb, *da, *label;
  GSList *da_pix;         /*-- backing pixmaps --*/
  gint nvars;
} Varpanel_circd;

typedef struct _Varpaneld {
  GtkWidget *hpane;  /*-- child of the ebox --*/
} Varpaneld;

/*-------------------- transformation --------------------------------*/

/* sphering transformation */
typedef struct _Sphere_d {
  vector_i vars;        /*-- vars available to be sphered --*/
  vector_i vars_sphered;/*-- vars that have been sphered --*/
  gint npcs;      /*-- the first npcs vars of vars will be sphered --*/
  vector_i pcvars;/*-- vars into which sphered data is written --*/

  vector_f eigenval;
  array_d eigenvec;
  array_f vc;
  vector_f tform_mean;
  vector_f tform_stddev;

  gboolean vars_stdized;
} Sphere_d;


typedef struct _EdgeData {
  gint n;
  SymbolicEndpoints *sym_endpoints;
  GList *endpointList;   
    /* a list of endpointsd elements corresponding to the resolved 
       record ids relative to a given datad. This is akin to a table
       indexed by datad elements. */

  gint nxed_by_brush;
  vector_b xed_by_brush;
} EdgeData;

typedef struct _BrushBins {
  gint nbins;
  bin_struct **binarray;
  icoords bin0, bin1;
} BrushBins;


%}

%{
#include "vars.h"
#include "externs.h"
%}

class GGobi:Data from G:Object {

public const gchar *name;
public const gchar *nickname;
public InputDescription *input;

public guint nrows;
public gint ncols;

public gboolean missings;

public struct _ggobid *gg; /*-- a pointer to the parent --*/

public GArray *rowlab;

/*-- row ids to support generalized linking --*/
public GHashTable *idTable;
public char **rowIds;
/*-- to support brushing by categorical variable --*/
public vartabled *linkvar_vt;  /*-- the linking variable --*/

public Subset  subset;
public Jitterd  jitter;
public Varpanel_cboxd  vcbox_ui;
public Varpanel_circd  vcirc_ui;
public Varpaneld  varpanel_ui;
public Sphere_d  sphere;
public EdgeData  edge;
public BrushBins  brush;

public GSList *vartable;

public GtkWidget *vartable_tree_view[all_vartypes];
public GtkTreeModel *vartable_tree_model; /* the root model, with all vars */

public array_f raw;
public array_f tform;
public array_g world;
public array_g jitdata;

/*----------------------- missing values ---------------------------*/

public array_s missing; 
public gboolean missings_show_p; /*-- show/hide per datad, not per display --*/

/*---------------- deleting the hidden points; subsetting ----------*/

public vector_i rows_in_plot;  /*-- always of length self->nrows --*/
public gint nrows_in_plot;     /*-- how many elements of rows_in_plot to use --*/
public vector_b sampled;
public vector_b excluded;

/*--------------- clusters: hiding, excluding ----------------------*/

public symbol_cell symbol_table[NGLYPHTYPES][NGLYPHSIZES][MAXNCOLORS];
public GtkWidget *cluster_table; /*-- table of symbol groups from brushing --*/
public gint nclusters;
public clusterd *clusv;
public clusteruid *clusvui;
public vector_i clusterid;  /* cluster membership for each record */

/*------------------------ brushing ----------------------------------*/

public gint npts_under_brush;
public vector_b pts_under_brush;
public vector_s color;
public vector_s color_now; 
public vector_s color_prev;
public vector_b hidden;
public vector_b hidden_now;
public vector_b hidden_prev;
public vector_g glyph;
public vector_g glyph_now;
public vector_g glyph_prev;

/*-- used in identification, line editing, and point motion --*/
public gint nearest_point;
public gint nearest_point_prev;
public GSList *sticky_ids;

/*-------------------- moving points ---------------------------------*/
public GSList *movepts_history; /*-- a list of elements of type celld --*/


property UINT nrows 
  (nick = "nrows", blurb = "Number of rows in the dataset",
   minimum = 0, maximum = INT_MAX, default_value = 0,
   flags = CONSTRUCT_ONLY, link, export);
property UINT ncols 
  (nick = "ncols", blurb = "Number of cols in the dataset",
   minimum = 0, maximum = INT_MAX, default_value = 0,
   flags = CONSTRUCT_ONLY, link, export);
   
signal private NONE (INT, INT, POINTER) void rows_in_plot_changed(self, int arg1, int arg2, ggobid* arg3);

signal public NONE (INT) void col_name_changed(self, int j);

init (self) {
  sphere_init(self); 
  
  self_set_name(self, "unknown", NULL);

  self->nearest_point = -1;
  self->missings_show_p = true;
}

override (G:Object) GObject*
constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties)
{
  GGobiData* d = (GGobiData*) PARENT_HANDLER(type, n_construct_properties, construct_properties);
  /* we can put these here OR we can put them in the setter for the 'ncols'
     property, since we know that comes last (after 'nrows' has been set) */
  
  d->nrows_in_plot = d->nrows;  /*-- for now --*/

  arrayf_alloc (&d->raw, d->nrows, d->ncols); //FIXME: probably leaks memory
  //arrays_alloc (&d->missing, d->nrows, d->ncols);
  arrays_alloc_zero (&d->missing, d->nrows, d->ncols);

  rowlabels_alloc (d);

  vartable_alloc (d);
  vartable_init (d);

  br_glyph_ids_alloc (d);
  br_glyph_ids_init (d);

  br_color_ids_alloc (d);
  br_color_ids_init (d);

  br_hidden_alloc (d);
  br_hidden_init (d);


  return((GObject *)d);
}

public GGobiData* 
new(guint nrows, guint ncols)
{
  GGobiData* d = (GGobiData*) g_object_new(GGOBI_TYPE_DATA, "ncols", ncols, "nrows", nrows, NULL);
  return(d);
}

/* General comments: 
  1) the (broken) datad_free function may not be necessary, since we can specify
     finalizers for all the fields using GOB
  2) the (evil) datad_init function must be vanquished asap
*/

public gchar *
get_name (self)
{
  return (g_strdup(self->name));
}

public void
set_name (self, gchar *name, gchar *nickname)
{
  if (name == NULL) name = g_strdup("unknown");
  if (nickname == NULL) nickname = g_strndup(name, 5);

  self->name = g_strdup(name);
  self->nickname = g_strndup(name, 5);
}

public guint
get_n_cols(self) {
  return self->ncols;
}

public guint
get_n_rows(self) {
  return self->nrows;
}


public gchar* 
get_col_name(self, guint j) 
{
  vartabled* vt = vartable_element_get (j, self);
  return(vt->collab);
}

public void 
set_col_name(self, guint j, gchar* value) 
{
  vartabled* vt = vartable_element_get (j, self);

  //if (vt->collab) g_object_unref(vt->collab); 
	//if (vt->nickname) g_object_unref(vt->nickname);
  //if (vt->collab_tform) g_object_unref(vt->collab_tform);

  if (value == NULL) value = g_strdup_printf("V%d", j + 1);

  vt->collab = g_strdup(value);
  vt->collab_tform = g_strdup(value);
  vt->nickname = g_strndup (vt->collab, 2);

  g_signal_emit_by_name (self, "col_name_changed", (gpointer) self, j);

  // SEND COLUMN NAME CHANGED SIGNAL
  // Listeners:
  //  * vartable_collab_set_by_var (j, d);
  //  * varpanel_label_set (j, d);   /*-- checkboxes --*/
  //  * varcircle_label_set (j, d);  /*-- variable circles --*/
  //  * tform_label_update (jvar, d);
  
}

// FIXME: to be removed once pipeline in place
public gchar* 
get_transformed_col_name(self, guint j) 
{
  vartabled* vt = vartable_element_get (j, self);
  return(vt->collab_tform);
}

public void 
set_transformed_col_name(self, guint j, gchar* value) 
{
  vartabled* vt = vartable_element_get (j, self);
  //if (vt->collab_tform) g_object_unref(vt->collab_tform);  //is this necessary?
  vt->collab_tform = g_strdup(value);
}


/**
 * set_missing:
 * 
 * Set specified cell to be a missing value
 */
public void
set_missing (self, guint i, guint j)
{
  self->missing.vals[i][j] = 1;
  self->raw.vals[i][j] = 0;
  self->missings = TRUE;
}

public gboolean
is_missing (self, guint i, guint j) 
{
  return self->missings && (self->missing.vals[i][j] == 1);  
}

public gboolean
has_missings(self) 
{
  return self->missings;
}


public guint 
get_col_n_missing(self, guint j) {
  guint i, n = 0;

  for(i = 0; i < self->nrows; i++) {
    if (self_is_missing(self, i, j)) n++;
  }
  
  return(n);
}

public void
set_raw_values(self, guint j, gdouble *values)
{
  gint i;
  for (i = 0; i < self->nrows; i++) {
    self_set_raw_value(self, i, j, values[i]);
  }
}

public void
set_raw_value(self, guint i, guint j, gdouble value)
{
  if(GGobiMissingValue && GGobiMissingValue(value))
    self_set_missing(self, i, j);
  else self->raw.vals[i][j] = value;
}

/*
public void
set_catgorical_value(self, guint i, guint j, gchar* value) 
{
  vartabled *vt = vartable_element_get(j, self);
  guint i, level = -1;
  
  g_assert(vt->vartype == categorical);
  
  for(i = 0; i < vt->nlevels; i++) {
    if (g_ascii_strcasecmp(value, vt->level_names[i])) {
      level = i;
      break;
    }
  }
  //not found, must be new variable
  if (level == -1) {
    level = vt->nlevels++;
    
    vt->level_values[level] == level;
  }
  
  vt->level_counts[level]++;
  self_set_raw_value(self, i, j, vt->level_values[level]);
}

public void
set_string_value(self, guint i, guint j, gchar* value) 
{
  if (FALSE) {//FIXME: should be is_numeric
    self_set_raw_value(self, i, j, (gfloat) g_strtod (value, NULL));
  } else {
    if (value[0] == '\0' || !g_ascii_strcasecmp (value, "na") || !strcmp (value, "."))  
      self_set_missing(self, i, j);
    else
      self_set_categorical_value(self, i, j, value);
  }
}
*/

public gchar*
get_string_value(self, guint i, guint j, gboolean transformed) 
{
  gint n = 0, lval = -1;
  vartabled *vt = vartable_element_get(j, self);
  gdouble raw = transformed ? self->tform.vals[i][j] : self->raw.vals[i][j];
  
  if (self_is_missing(self, i, j)) 
    return g_strdup("NA");
  if (vt->vartype != categorical)
    return g_strdup_printf("%g", raw);
  
  for (n = 0; n < vt->nlevels; n++) {
    if (vt->level_values[n] == raw) {
      lval = n;
      break;
    }
  }
  if (lval == -1) {
    g_printerr ("The levels for %s aren't specified correctly\n",            vt->collab);
    return(NULL);
  }
  
  return vt->level_names[lval];
}

public gboolean 
has_edges (self) 
{
  return (self->edge.n > 0);
}

public gboolean 
has_variables (self) 
{
  return (self->ncols > 0);
}


}


%h{

void freeLevelHashEntry(gpointer key, gpointer value, gpointer data);

/*-- used as an attribute of variable notebooks --*/
typedef enum {no_edgesets, edgesets_only, all_datatypes} datatyped;

extern endpointsd *resolveEdgePoints(GGobiData *e, GGobiData *d);
void unresolveAllEdgePoints(GGobiData *e);

void datad_record_ids_set(GGobiData *d, gchar **ids, gboolean duplicate);
void ggobi_data_set_row_labels(GGobiData *d, gchar **labels);
%}

%{
void
datad_free (GGobiData *d, ggobid *gg) 
{
  arrayf_free (&d->raw, 0, 0);
  pipeline_arrays_free (d, gg);

  arrays_free (&d->missing, 0, 0);

   /* rowIds and idTable are intrinsically linked !*/
  if(d->idTable) {
    g_hash_table_foreach(d->idTable, freeLevelHashEntry, d->idTable);
    g_hash_table_destroy(d->idTable); 
  }

  if(d->rowIds) 
    g_free(d->rowIds);

  g_free (d);
}

displayd *
datad_init (GGobiData *d, ggobid *gg, gboolean cleanup)
{
  /* GGobi assumes datasets have at least one row */
  g_return_val_if_fail(d->nrows > 0, NULL);
  d->gg = gg;
  gg->d = g_slist_append (gg->d, d);
  displayd *display = NULL;

  if (cleanup) {
    varpanel_clear (d, gg);
  }

  varpanel_populate (d, gg);   /*-- toggles */
  /*-- circles: build but don't show --*/
  varcircles_populate (d, gg);

  pipeline_init (d, gg);
  clusters_set (d, gg);  /*-- find the clusters for data just read in --*/

  if (cleanup || g_list_length(gg->displays) == 0) {
    display_free_all (gg);  /*-- destroy any existing displays --*/
    gg->pmode = NULL_PMODE;

    /*-- initialize the first display --*/
    if(sessionOptions->info->createInitialScatterPlot && d->ncols > 0) {
/*XXX allow this to be specified as a gtk type name on the command
      line, initialization file, etc.  and invoke the corresponding
      create() method. */
      display = scatterplot_new (true, false, NULL, d, gg);
        /* Need to make certain this is the only one there. */

      if (display != NULL) {
        gg->displays = g_list_append (gg->displays, (gpointer) display);
	    gg->current_splot = (splotd *)
        	g_list_nth_data (display->splots, 0);
        display->current_splot = gg->current_splot;
        display_set_current (display, gg);

        /*-- turn on event handling in the very first plot --*/
        /*-- ... but will it cause trouble for later plots?  ok so far
	  --*/
	/* Is imode set yet?  I hope so. */
        sp_event_handlers_toggle (gg->current_splot, on, gg->pmode, gg->imode);
      }
    }
  }

  if (gg->current_display != NULL)
    varpanel_refresh (gg->current_display, gg);

  if (g_slist_index(gg->d, (gpointer)d) == 0)
    varpanel_set_sensitive (d, true, gg);

  g_signal_emit (G_OBJECT (gg), GGobiSignals[DATAD_ADDED_SIGNAL], 0, d);

  display_menu_build (gg);

  return (display);
}




/*------------------------------------------------------------------------*/
/*                          row labels                                    */
/*------------------------------------------------------------------------*/
/* This initializes rowIds to row numbers if ids are not provided */
void
datad_record_ids_set(GGobiData *d, gchar **ids, gboolean duplicate)
{
  gint i;
  guint *index;
  gchar *tmp;

  d->idTable = g_hash_table_new(g_str_hash, g_str_equal);
  d->rowIds = (gchar **) g_malloc(sizeof(gchar *) * d->nrows);
  for(i = 0; i < d->nrows; i++) {
     if(ids)
       tmp = duplicate ? g_strdup(ids[i]) : ids[i];
     else {
       char buf[10];
       sprintf(buf, "%d", i+1);
       tmp = g_strdup(buf);
     }
     index = (guint *) g_malloc(sizeof(guint));
     *index = i;
     g_hash_table_insert(d->idTable, tmp, index);
     d->rowIds[i] = tmp;     
     /* do not free anything here */
  }
}

/* Add a record id */
void
datad_record_id_add (gchar *id, GGobiData *d)
{
  gint i;
  guint *index;

  d->rowIds = (gchar **) g_realloc (d->rowIds, sizeof(gchar *) * d->nrows);
  i = d->nrows - 1;

  index = (guint *) g_malloc(sizeof(guint));
  *index = i;
  g_hash_table_insert (d->idTable, id, index);
  d->rowIds[i] = id;

/*
 * I don't really understand why I can't free this
 * when it's freed in datad_record_ids_set, but purify is
 * quite clear on this point.  -- dfs
*/
  /*g_free (index);*/
}

/* FIXME: this only works the first time */
void
ggobi_data_set_row_labels(GGobiData *d, gchar **labels)
{
	gint i;
	for (i = 0; i < d->nrows; i++) {
		gchar *label;
		if (labels && labels[i])
			label = g_strdup(labels[i]);
		else label = g_strdup_printf("%d", i);
		g_array_append_val(d->rowlab, label);
	}
}

void 
rowlabels_free (GGobiData *d)
{
  g_array_free (d->rowlab, true);
}


void
rowlabels_alloc (GGobiData *d) 
{
  if (d->rowlab != NULL) rowlabels_free (d);
  d->rowlab = g_array_sized_new (false, false, sizeof (gchar *), d->nrows);
}

void
rowlabel_add (gchar *label, GGobiData *d) 
{
  g_array_append_val (d->rowlab, label);

  g_assert (d->rowlab->len == d->nrows);
}


%}