/* Copyright The Numerical Algorithms Group Ltd., Oxford, UK, 1998

   This module accepts some 1D lattices and plots the data on a
   set of axes.
  
   Written by Jeremy Walton (jeremyw@nag.co.uk).  24 September 1998. */

#include <cx/cxLattice.h>
#include <cx/Geometry.h>
#include <cx/DataAccess.h>
#include <cx/PortAccess.h>
#include <cx/UI.h>
#include <cx/ModuleCommand.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>

#include "LineGraph.uf.h"

#ifdef __cplusplus
extern "C" {
#endif

    void init(void);

    void getOptions(int select);

    void setPlotDataOptions(int line);

#ifdef __cplusplus
}
#endif

#define MAXCOL 7
#define RED { 1.0, 0.0, 0.0 }
#define GRN { 0.0, 1.0, 0.0 }
#define BLU { 0.0, 0.0, 1.0 }
#define YEL { 1.0, 1.0, 0.0 }
#define MAG { 1.0, 0.0, 1.0 }
#define CYA { 0.0, 1.0, 1.0 }
#define WHI { 1.0, 1.0, 1.0 }
#define BLK { 0.0, 0.0, 0.0 }

/* This is the maximum number of curves that we can plot (that */
/* we have parameter ports (Color, Style, Label and Data) for. */
/* This limit can be changed, but the number of parameter ports */
/* must always correspond to it. */

#define MAXLINE 6

typedef struct {
    int id;
    int drawingmode;
    char label[50];
    int colorindex;
} Plot;

static Plot plot[MAXLINE];
static int line;

void init()
{
  /* Initialisation routine, called once when the module is */
  /* dragged into the map editor. */

    /* Initialise the geometry library. */

 /*    cxGeoInit(); */
 cxGeoMSInit();
 
    /* line counts the number of lines plotted. */

    line = 0;
}

void compute (
              cxGeometry **geoOut,
              int logx,
              int gridx,
	      float Xmin,
	      int CalcXmin,
	      float Xmax,
	      int CalcXmax,
              unsigned char *xlabel_,
              float xscale,
	      
              int logy,
              int gridy,
	      float Ymin,
	      int CalcYmin,
	      float Ymax,
	      int CalcYmax,
              unsigned char *ylabel_,
              float yscale,
	      
              unsigned char *title_,
              unsigned char *legend_,
              int dataselect)
{
  char *xlabel = (char*)xlabel_;
  char *ylabel = (char*)ylabel_;
  char *title = (char*)title_;
  char *legend = (char*)legend_;

  /* Numerical values for colours - this should probably be in an include. */

  /*    float red[3] = RED; */
    /*    float grn[3] = GRN; */
    /*    float blu[3] = BLU; */
    float yel[3] = YEL;
    /*    float mag[3] = MAG; */
    /*    float cya[3] = CYA; */
    float whi[3] = WHI;
    float blk[3] = BLK;

    /* Location of the plot. */
    float plotBottomLeft[2] = {-0.361, -0.2};
    float plotTopRight[2]   = {0.808, 0.523}; /* the golden ratio, to make the plot look nice. */
    /* Location of the legend. */

    float legBottomLeft[2], legTopRight[2];
    char message[50];

    float titleSize = 0.2;

    float *coordVal,*X, *Y, aspect, xrange, yrange;
    void *dataVal;
    long nDim, *dims, nDataVar, nCoordVar;
    cxCoordType coordType;
    cxPrimType primType;
    int i, nconn, jconn, *links, iplot, ivar, nvar, vDim, negx, negy;
    cxLattice **latList;
	float xmin =  FLT_MAX;
	float ymin =  FLT_MAX;
	float xmax = -FLT_MAX;
	float ymax = -FLT_MAX;

	/* Read the plotting options from the control panel. */

    getOptions(dataselect);

    /* Create a new geometry buffer and select it.  Start a new plot. */

    *geoOut = cxGeoNew();
    cxGeoBufferSelect(*geoOut);
    cxGeoRoot();
    cxGeoDelete();
    cxGeoPlotBegin();

    /* For each limit, determine whether we're calculating it from the data. */
    /* If so, then disable the input widget.  The limit is automatically */
    /* calculated in the call to cxGeoPlotDataAdd, below (actually, we */
    /* also calculate it from the data in order to adjust the limits on */
    /* the limits widgets.  Otherwise, enable the widget and set the limit. */

	if( CalcXmin ) {
		cxInWdgtDisable("X Min");
		negx = 0;
	} else {
		cxInWdgtEnable("X Min");
		cxGeoPlotFloatSet(CX_GEO_PLOT_XMIN, Xmin);
		negx = ( Xmin <= 0.0 );
	}

	if( CalcXmax )
		cxInWdgtDisable("X Max");
	else {
		cxInWdgtEnable("X Max");
		cxGeoPlotFloatSet(CX_GEO_PLOT_XMAX, Xmax);
	}

	if( CalcYmin ) {
		cxInWdgtDisable("Y Min");
		negy = 0;
	} else {
		cxInWdgtEnable("Y Min");
		cxGeoPlotFloatSet(CX_GEO_PLOT_YMIN, Ymin);
		negy = ( Ymin <= 0.0 );
	}

	if( CalcYmax )
		cxInWdgtDisable("Y Max");
	else {
		cxInWdgtEnable("Y Max");
		cxGeoPlotFloatSet(CX_GEO_PLOT_YMAX, Ymax);
	}

        /* Initialise counters. */

    line = 0;

    /* Get the number of connections to the lattice port, and get the array */
    /* of lattices which are on this port. */

    nconn = cxInputConnectsGet(cxInputPortOpen("Input Values"));
    cxInputDataGetV(cxInputPortOpen("Input Values"), (void ***)&latList);
    cxInputDataConnIDGetV(cxInputPortOpen("Input Values"), &links);

    /* Get each of the lattices in turn. */

    for( jconn=0; jconn<nconn; jconn++ ) {

      /* Get the data out of this input lattice. */

        cxLatPtrGet(latList[jconn], NULL, (void **)&dataVal,
			NULL, (void **)&coordVal);

        cxLatDescGet(latList[jconn], &nDim, &dims, NULL, &nDataVar,
            &primType, NULL, &nCoordVar, &coordType);

        /* line counts the number of lines plotted so far, up to a maximum of */
        /* MAXLINE (which is the number we have parameter ports for).  Check */
        /* that we're going to be able to plot all of the data in this lattice, */
        /* otherwise, adjust nvar, the number of lines we're going to plot. */

        if( line+nDataVar > MAXLINE ) {
            sprintf(message, "Can only plot %d lines", MAXLINE);
            cxModAlert(message);
            nvar = MAXLINE - line;
        } else
            nvar = nDataVar;

        /* Allocate space for X, an array containing the coordinates of each */
        /* node in the lattice. */

        vDim = (int)cxDimsProd(nDim, dims, nCoordVar) / nCoordVar;

        /* If it's a uniform lattice, calculate the coordinates explicitly. */
        /* Otherwise (perimeter or curvilinear) just point X at the coordinates. */

        if( coordType == cx_coord_uniform ) {
	    float step;
            X = (float *)malloc(sizeof(float) * vDim);
            step = (coordVal[1] - coordVal[0]) / (vDim-1);
            for( i=0; i<vDim; i++ )
                X[i] = i*step + coordVal[0];
        } else
            X = coordVal;

        /* Check for negative coordinates (we might have asked for a log X axis). */

        if( CalcXmin && !negx )
            negx = ( coordVal[0] <= 0.0 );

        /* Now loop over the data variables in the lattice. */
        Y = (float *)malloc(sizeof(float) * vDim);

        for( ivar=0; ivar<nvar; ivar++, line++ ) {

            for( i=0; i<vDim; i++ ) {
				double dBuf;
                switch (primType) {
                case cx_prim_byte:
                    dBuf = ((unsigned char *)dataVal)[i*nDataVar+ivar];
                    break;
                case cx_prim_short:
                    dBuf = ((short *)dataVal)[i*nDataVar+ivar];
                    break;
                case cx_prim_long:
                    dBuf = ((long *)dataVal)[i*nDataVar+ivar];
                    break;
                case cx_prim_float:
                    dBuf = ((float *)dataVal)[i*nDataVar+ivar];
                    break;
                case cx_prim_double:
                    dBuf = ((double *)dataVal)[i*nDataVar+ivar];
                    break;
                }
                Y[i]=(float)dBuf;

                /* Check for negative data (we might have asked for a log Y axis). */

                if( CalcYmin && !negy )
                    negy = ( Y[i] <= 0.0 );

				/* Update the limits. */

				if( X[i] < xmin)
					xmin = X[i];
				if( X[i] > xmax)
					xmax = X[i];
				if( Y[i] < ymin)
					ymin = Y[i];
				if( Y[i] > ymax)
					ymax = Y[i];

			}

            /* Add this data and coordinates to the plot, remember the connection */
            /* that it came in on, and set the attributes for this line. */

            iplot = cxGeoPlotDataAdd(vDim, X, Y);
            plot[line].id = links[jconn];

            setPlotDataOptions(line);

            /* Add the label for this data to the legend (whether or not */
            /* it's going to be displayed). */

            cxGeoPlotDataStrSet(CX_GEO_DATA_LABEL, plot[line].label);
        }
        free(Y);
        if (X != coordVal) free(X);
    }

    /* Now use the data limits to set the limits on the widgets */
    /* attached to the limit parameters (!) */

	xrange = xmax-xmin;
	yrange = ymax-ymin;
	cxInWdgtDblMinMaxSet("X Min", xmin-0.1*xrange, xmax+0.1*xrange);
	cxInWdgtDblMinMaxSet("X Max", xmin-0.1*xrange, xmax+0.1*xrange);
	cxInWdgtDblMinMaxSet("Y Min", ymin-0.1*yrange, ymax+0.1*yrange);
	cxInWdgtDblMinMaxSet("Y Max", ymin-0.1*yrange, ymax+0.1*yrange);
	if( CalcXmin )
		cxInWdgtDblSet("X Min", xmin);
	if( CalcXmax )
		cxInWdgtDblSet("X Max", xmax);
	if( CalcYmin )
		cxInWdgtDblSet("Y Min", ymin);
	if( CalcYmax )
		cxInWdgtDblSet("Y Max", ymax);

        /* Set the attributes for the plot. */

    cxGeoPlotStrSet(CX_GEO_PLOT_XAXIS_LABEL, xlabel);
    cxGeoPlotStrSet(CX_GEO_PLOT_YAXIS_LABEL, ylabel);

    aspect = (plotTopRight[1] - plotBottomLeft[1])/(plotTopRight[0] - plotBottomLeft[0]);
    cxGeoPlotFloatSet(CX_GEO_PLOT_XAXIS_SCALE, xscale*aspect);
    cxGeoPlotFloatSet(CX_GEO_PLOT_YAXIS_SCALE, yscale);
    cxGeoPlotColorSet(CX_GEO_PLOT_AXIS_COLOR, whi);
    cxGeoPlotOptionSet(CX_GEO_PLOT_XAXIS_ARROW, TRUE);
    cxGeoPlotOptionSet(CX_GEO_PLOT_YAXIS_ARROW, TRUE);
    cxGeoPlotOptionSet(CX_GEO_PLOT_XGRID_VISIBLE, gridx == 0 ? FALSE : TRUE);
    cxGeoPlotOptionSet(CX_GEO_PLOT_YGRID_VISIBLE, gridy == 0 ? FALSE : TRUE);
    cxGeoPlotFloatSet(CX_GEO_PLOT_AXIS_LINE_WIDTH, 2.0);
    cxGeoPlotFloatSet(CX_GEO_PLOT_GRID_LINE_WIDTH, 1.0);
    cxGeoPlotOptionSet(CX_GEO_PLOT_GRID_PATTERN, 0xf0f0);

    /* Log axes?  Ensure the values are > 0, otherwise switch back to linear axes. */

    if( logx && negx ) {
        cxModAlert("Non-positive X values detected - can't have log axis");
        cxGeoPlotOptionSet(CX_GEO_PLOT_XAXIS_TYPE, CX_GEO_PLOT_LINEAR_AXIS);
        cxInWdgtLongSet("LogX", 0);
    } else
        cxGeoPlotOptionSet(CX_GEO_PLOT_XAXIS_TYPE,
		logx == 0 ? CX_GEO_PLOT_LINEAR_AXIS : CX_GEO_PLOT_LOG_AXIS);

    if( logy && negy ) {
        cxModAlert("Non-positive Y values detected - can't have log axis");
        cxGeoPlotOptionSet(CX_GEO_PLOT_YAXIS_TYPE, CX_GEO_PLOT_LINEAR_AXIS);
        cxInWdgtLongSet("LogY", 0);
    } else
        cxGeoPlotOptionSet(CX_GEO_PLOT_YAXIS_TYPE,
		logy == 0 ? CX_GEO_PLOT_LINEAR_AXIS : CX_GEO_PLOT_LOG_AXIS);

    /* Add the legend, if necessary. */

    if( strlen(legend) > 0 ) {
        legBottomLeft[0] = -0.758-yscale*0.0723;
        legBottomLeft[1] = 0.089-line*0.0361;
        legTopRight[0] = -0.47-yscale*0.0723;
        legTopRight[1] = 0.234+line*0.0361;
        cxGeoPlotLegendAdd(legBottomLeft, legTopRight, legend);
    }
    cxGeoPlotColorSet(CX_GEO_PLOT_LEGEND_BACK_COLOR, blk);
    cxGeoPlotColorSet(CX_GEO_PLOT_LEGEND_BORDER_COLOR, whi);
    cxGeoPlotColorSet(CX_GEO_PLOT_LEGEND_TEXT_COLOR, whi);

    /* Define the position of the plot in 2D space. */

    cxGeoPlotDefine(plotBottomLeft, plotTopRight);

    /* Add the title to the plot, at the top, suitably centered (whether there's */
    /* a legend or not). */

    cxGeoPlotTextDefine(title, NULL, titleSize, CX_GEO_PLOT_TEXT_CENTER);
    /* Use enumerated type to keep compiler happy - JPW */
    cxGeoColorAdd(1, yel, CX_GEO_PER_DEFAULT);
    if( strlen(legend) > 0 )
        cxGeoTranslate(legBottomLeft[0] + 0.5*(plotTopRight[0] - legBottomLeft[0]),
		plotTopRight[1]+titleSize*0.9, 0.0);
    else
        cxGeoTranslate(plotBottomLeft[0] + 0.5*(plotTopRight[0] - plotBottomLeft[0]),
		plotTopRight[1]+titleSize*0.9, 0.0);

    /* Close the buffer and output the new geometry. */

    cxGeoBufferClose(*geoOut);
}

void getOptions(int select)
{
    int i;
    char portName[20], label[20];

    /* Read the values in from the parameter to give the display properties */
    /* of each curve. */

    for( i=0; i<MAXLINE; i++ ) {

        sprintf(portName, "Color %d", i+1);
        plot[i].colorindex = cxParamLongGet(cxInputDataGet(cxInputPortOpen(portName)));

        sprintf(portName, "Style %d", i+1);
        plot[i].drawingmode = cxParamLongGet(cxInputDataGet(cxInputPortOpen(portName)));

        sprintf(portName, "Label %d", i+1);
        strcpy(plot[i].label, cxParamStrGet(cxInputDataGet(cxInputPortOpen(portName))));

        /* Use the label read in (if any) to set the value for the entry on */
        /* the dataselect widget (provided the label isn't the default value) */
        /* - this gives a (presumably) more meaningful way of selecting this data. */

        sprintf(label, "Data %d", i+1);
        if( strlen(plot[i].label) > 0 )
            cxInWdgtChoiceLabelSet("Select Data", i, plot[i].label);

    }

    /* If we've selected a different data set, then show the widgets for */
    /* that data set. It's easiest to first hide them all, then show the */
    /* selected one. */

    if( cxInputDataChanged(cxInputPortOpen("Select Data")) ) {
        for( i=0; i<MAXLINE; i++ ) {
            sprintf(portName, "Color %d", i+1);
            cxInWdgtHide(portName);

            sprintf(portName, "Style %d", i+1);
            cxInWdgtHide(portName);

            sprintf(portName, "Label %d", i+1);
            cxInWdgtHide(portName);
        }

        /* Now show the port for the selected data. */

        sprintf(portName, "Color %d", select+1);
        cxInWdgtShow(portName);
        sprintf(portName, "Style %d", select+1);
        cxInWdgtShow(portName);
        sprintf(portName, "Label %d", select+1);
        cxInWdgtShow(portName);
    }
}

void setPlotDataOptions(int line)
{
	float color[MAXCOL][3] = { RED, GRN, BLU, YEL, CYA, MAG, WHI };

	switch (plot[line].drawingmode) {
        case 0:         /* solid line */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_POLYLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 1:         /* dashed line */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_POLYLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xff00);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 2:         /* dotted line */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_POLYLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xf0f0);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 3:         /* stairs */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_STAIRS);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 4:         /* curve */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_CURVE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 5:         /* points */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_NOLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, TRUE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 6:         /* points & line */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_POLYLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, TRUE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 7:         /* points & curve */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_CURVE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, TRUE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, FALSE);
        break;
        case 8:         /* filled line */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_POLYLINE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, TRUE);
        break;
	case 9:          /* filled curve */
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LSTYLE, CX_GEO_DATA_CURVE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_LINE_PATTERN, 0xffff);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_MARKERS, FALSE);
        cxGeoPlotDataOptionSet(CX_GEO_DATA_FILLED, TRUE);
        break;
    }

        /* Set the colour for this curve, depending on its mode. */

    if( plot[line].drawingmode != 5 )
        cxGeoPlotDataColorSet(CX_GEO_DATA_LINE_COLOR, color[plot[line].colorindex]);
    if( plot[line].drawingmode >= 5 && plot[line].drawingmode <= 7 )
        cxGeoPlotDataColorSet(CX_GEO_DATA_MARKER_COLOR, color[plot[line].colorindex]);
    if( plot[line].drawingmode >= 8 )
        cxGeoPlotDataColorSet(CX_GEO_DATA_FILL_COLOR, color[plot[line].colorindex]);

    cxGeoPlotDataFloatSet(CX_GEO_DATA_LINE_WIDTH, 2.0);

}

void disconnected(const char *name, int id)
{
    int i, k, n, index[MAXLINE];
    char portName[20], label[20];

    /* Disconnect hook function, called when one of the connections is broken. */
    /* We don't want to do anything unless it was the lattice input port that */
    /* was disconnected. */

    if( strcmp(name, "Input Values") ) return;

    /* We have to modify the plot parameters database, to remove the entry(s) for */
    /* the disconnected lattice.  Loop over all the entries, searching for those */
    /* that correspond to the disconnected lattice.  There may be more than one */
    /* of these, but they'll always be consecutive. */

    k = 0;
    for( i=0; i<line; i++ ) {
        if( plot[i].id == id ) {
            index[k] = i;
            k++;
        }
    }

    /* Loop over entries to be disconnected. */

    for( n=0; n<k; n++ ) {

      /* Step down the list from this entry, overwriting each entry with */
      /* that k further on (allowing for the end of the list). */

        for( i=index[n]; i<line; i++ ) {
            if( i+k < MAXLINE ) {

                plot[i] = plot[i+k];

                /* Update the control panel for this entry with the new values. */

                sprintf(portName, "Color %d", i+1);
                cxInWdgtLongSet(portName, plot[i].colorindex);

                sprintf(portName, "Style %d", i+1);
                cxInWdgtLongSet(portName, plot[i].drawingmode);

                /* Check to see if the new label is a default one.  If so, */
                /* update the counter to reflect its new position in the list. */

                sprintf(label, "Data %d", i+k+1);
                if( strcmp(plot[i].label, label) == 0 )
                    sprintf(plot[i].label, "Data %d", i+1);

                sprintf(portName, "Label %d", i+1);
                cxInWdgtStrSet(portName, plot[i].label);
			}
        }
    }

    /* For the rest of the list (between the end of the new occupied region */
    /* and the end of the list), reset the default entry values. */

    for( i=line-k; i<MAXLINE; i++ ) {

        sprintf(portName, "Style %d", i+1);
        plot[i].drawingmode = i;
        cxInWdgtLongSet(portName, plot[i].drawingmode);

        sprintf(portName, "Color %d", i+1);
        plot[i].colorindex = i;
        cxInWdgtLongSet(portName, plot[i].colorindex);

        sprintf(portName, "Label %d", i+1);
        sprintf(label, "Data %d", i+1);
        strcpy(plot[i].label, label);
        cxInWdgtStrSet(portName, plot[i].label);

    }

    /* Now fire the module again - this makes */
    /* the curve(s) from that lattice disappear from the plot. */

    cxFireASAP();
}