#include <stdlib.h>
#include <stdio.h>
#include "CLO.h"
#include <string.h>

#ifdef WIN32
#include "getopt.h"
#endif


// Static Class Variables
CLO* CLO::clolist[MAXOPTIONS];
int  CLO::clolistlen=0;
char CLO::optionString[1024];

/***************************************************************************
                              C L O : : C L O 
***************************************************************************/
CLO::CLO(char *option, char *descript)
{
  optionarg=1; // does this option have arguments?
  optionchar=option[0]; // which character is this option
  verifyUniqueOptionChar();
  strcpy(optionname,option+1);
  // printf ("Addding %c %s %d\n",optionchar,optionname, clolistlen);
  strcpy(optiondescript,descript);
  clolist[clolistlen]=this; // add to the list of current options
  clolistlen++;
}

/***************************************************************************
           C L O : : V E R I F Y U N I Q U E O P T I O N C H A R 
***************************************************************************/
void CLO::verifyUniqueOptionChar()
{
  // Get the list of all options used so far
  char *optstr=getOptionString();

  while (strchr(optstr,optionchar)!=NULL)
    {
      optionchar++;
      if (optionchar=='z'+1 || optionchar=='Z'+1)
	optionchar='A';
    }
}

/***************************************************************************
                        C L O : : S H O W U S A G E 
***************************************************************************/
void CLO::showusage(char *execname)
{
  int i;

  printf("\nUsage: %s [options]\n\n",execname);
  
  for ( i=0;i<clolistlen;i++)
    {
      
      if (clolist[i]->optionarg)
	{
	  printf("  -%c <%s=%s> : %s\n",clolist[i]->optionchar,
		 clolist[i]->optionname,clolist[i]->optiondefaultval,
		 clolist[i]->optiondescript);
	}
      else
	{
	  printf("  -%c : %s\n",clolist[i]->optionchar,
		 clolist[i]->optiondescript); 
	}
      
    }
  printf("\n");
  exit(2);
}

/***************************************************************************
                        C L O : : P A R S E A R G S 
***************************************************************************/
int CLO::parseArgs(int argc, char **argv)

{
  getOptionString();

  extern char *optarg;
  extern int optind;
  int c;
  int i;
  
  while ((c = getopt(argc, argv, optionString)) != -1)
    {
      int foundoption=0;
      for ( i=0;i<clolistlen;i++)
	{
	  if (clolist[i]->optionchar==c)
	    {
	      clolist[i]->setOption(optarg);
	      foundoption=1;
	    }
	}
       
      if(!foundoption)
	showusage(argv[0]);
    }

  return optind;
}

/***************************************************************************
                 * C L O : : G E T O P T I O N S T R I N G 
***************************************************************************/
char *CLO::getOptionString()

{
  int i;
  int count=0;
  optionString[0]='\0';
  
  for ( i=0;i<clolistlen;i++,count++)
    {
      optionString[count]=clolist[i]->optionchar;
      if (clolist[i]->optionarg)
	{
	  count++;
	  optionString[count]=':';
	}
    }
  optionString[count]='\0';
  return optionString;
}



// float
CLOfloat::CLOfloat(float nval, char *option, char *descript):CLO(option,descript)
{val=nval; sprintf(optiondefaultval,"%f",nval);}
float CLOfloat::operator=(float foo) {val=foo; return val;}
float CLOfloat::operator=(CLOfloat &foo) {val=foo.val; return val;}
CLOfloat::operator float() {return val;}
void CLOfloat::setOption(char *optarg) {val=atof(optarg);}

// int
CLOint::CLOint(int nval, char *option, char *descript=""):CLO(option,descript)
{val=nval; sprintf(optiondefaultval,"%d",nval);}
int CLOint::operator=(int foo) {val=foo; return val;}
int CLOint::operator=(CLOint &foo) {val=foo.val; return val;}
CLOint::operator int() {return val;}
void CLOint::setOption(char *optarg) {val=atoi(optarg);}

//char255
CLOchar255::CLOchar255(char * nval, char *option, char *descript=""):CLO(option,descript)
{strcpy(val,nval);strcpy(optiondefaultval,nval);}
CLOchar255::operator char*() {return val;}
void CLOchar255::setOption(char *optarg) {strcpy(val,optarg);}

//flag
CLOflag::CLOflag(char *option, char *descript=""):CLO(option,descript)
{val=0; optionarg=0;}
int CLOflag::operator=(int foo) {val=foo; return val;}
int CLOflag::operator=(CLOflag &foo) {val=foo.val; return val;}
CLOflag::operator int() {return val;}
void CLOflag::setOption(char *optarg) {val=1;}