#include <common.h>
#include <dbext.h>  /* NAME_LIST_ENTRY_TYPE */
#include <ioserv.h> /* TYPE_STRING, op_get_param() */
#include "map.h"
#include "vecplot.h"

int read_xy(FILE * fp, XY_TYPE * xy, int code)
{
   char buf[80];
   switch (code)
   {
      case COORDINATE:  /* x,y */
         if (fscanf(fp, " %lf,%lf", &(xy->x), &(xy->y)) != 2)
            return (1);
         sprintf(buf, " %f,%f ", xy->x, xy->y);
         break;
      case SCALE:    /* x by y */
         if (fscanf(fp, " %lf by %lf", &(xy->x), &(xy->y)) != 2)
            return (1);
         sprintf(buf, " %f by %f ", xy->x, xy->y);
         break;
      default:
         fprintf(stderr, "\n ERROR: Unrecognized delimiter\n");
         return (1);
   }
   report_msg(buf);
   return (0);
}

int read_range(FILE *fp, RANGE_INTERVAL *range, int code)
{
   char buf[80];

   if (fscanf(fp, " %lf to %lf by %lf", &(range->min), &(range->max),
              &(range->step)) != 3)
   {
      fprintf(stderr, "\n ERROR: reading lon/lat range\n");
      return (1);
   }
   sprintf(buf, " %f to %f by %f", range->min, range->max, range->step);
   if (range->step == 0.0)
   {
      fprintf(stderr, "\n ERROR: invalid step size\n");
      return (1);
   }
   if (code == LONGITUDE)
   {
      if (range->max < range->min)
         range->max += 360.0;
   }
   range->span = range->max - range->min;
   report_msg(buf);
   return (0);
}

int read_files(FILE * fpcnt, char vecfiles[MAXNUMFILES][80], int code)
{
   int i = 0, finished = 0;
   int nscan, eof;

   while (!finished)
   {
      nscan = fscanf(fpcnt, " %80s", vecfiles[i]);
      eof = feof(fpcnt);	/* Without this check, we get a segmentation
                                 * fault on eof! */
      if (code == 1 || nscan != 1 || !strcmp(vecfiles[i], "end") ||
          i == (MAXNUMFILES - 1) || eof)
         finished = 1;
      i++;
   }
   if (code == 1)
   {
      strcpy(vecfiles[1], "end");
   }
   check_error(eof, "EOF reached while reading vecfiles: is the list missing 'end'?");
   if (i == MAXNUMFILES)
   {
      fprintf(stderr, " ERROR:  Too many vector input files. Max. is %d \n ", MAXNUMFILES);
      exit(-1);
   }
   return (0);
}

/* Partition decides how many parts a given length should be divided into.
   The width argument is the size in paper inches of this given length.
   Initially, the function finds the largest power of 10, il, that yields
   an integral factor, ifactor, such that ifactor * 10^il = length.
   (It should always find something since 1 is 10^0.)  If this yields
   too few partitions (as defined by too_sparse in v.h), then we
   drop down to the next lower power.  The check for too_dense is done
   when we get back to the calling routine (as this facilitates finding
   a nice long-tick interval). */

int partition(length, width)
double length, width;
{
   double l, factor;
   int il, ifactor;

   if (length == 0.0)
      return(0);
   l = log10(length);
   il = l;
   do
   {
      factor = length / pow(10.0, 1.0*il);
      ifactor = factor;
      il = il - 1;
   }
   while (!equal(factor, ifactor) || too_sparse(width/ifactor));
   return(ifactor);
}

double frem(double num, double den)
{
   long int inum, iden, quotient;

   inum = round_val(num * 1000000L);
   iden = round_val(den * 1000000L);
   quotient = inum / iden;
   return ((inum - quotient * iden) / 1000000.0);
}


int get_decimal_length(double value)
{
   int dec_len = 0;

   while (1)
   {
      if (value - (int) value < 0.000001)
         return dec_len;  /* only way out! */
      value *= 10.0;
      dec_len++;
   }
}



int clear_labels(FILE * fp, LABEL_TYPE **arg, int code)
{
   LABEL_TYPE *temp, *label;

   label = *arg;
   *arg = NULL;

   while (label)
   {
      temp = label->next;
      free(label);
      label = temp;
   }

   return 0;
}