#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "tsm_getopt.h"

// Structure to keep all global variables in one place.
struct {
        float fval;
        const char *stringval;
        const char *mandatorystring;
        int ival;
        int optionalflag;
        float mandatoryfloat;
} globals={
        3.14159,                // Default value for fval
        "where in the world",   // Default value for stringval
        NULL,                   // Mandatory, NULL if not set for error
        0,                      // Default value for ival
        0,                      // default value for optionalflag
        0.0/0.0,              // mandatory, defaults to invalid 0/0 if not set
};

const opt options[]={
        // "fval" for "--fval" argument,
        // 'f' for '-f' argument,
        // 1 since it takes one argument,
        // a pointer to a float number,
        // "%f" to read one float,
        // and "Float Value" to print as help text.
        {"fval", 'f', 1, &globals.fval, "%f", "Float value"},
        // Similar, but an integer number.
        {"ival", 'i', 1, &globals.ival, "%d", "Integer value"},
        // A string.  Needs a pointer to a char *(not the char * itself).
        {"sval", 's', 1, &globals.stringval, NULL, "String Value"},
        {"mstr", 'm', 1, &globals.mandatorystring, NULL, "Mandatory string"},
        // An option with no parameters.
        // Changes globals.optionalflag from 0 to 1 if set.
        {"optionalflag", 'o', 0, &globals.optionalflag, NULL, "optional flag"},
        // Need this as the last thing in the list, to tell when the list ends
        {"mfloat", 'l', 1, &globals.mandatoryfloat, "%f", "Mandatory float"},
        {NULL},
};

int main(int argc, char *argv[])
{
        if(argc < 2) // No arguments
        {
                tsm_usage(argc, argv, options);
                exit(1);
        }

        if(tsm_getopt(argc, argv, options) < 0)
        {
                tsm_usage(argc, argv, options);
                exit(1);
        }

        // Check any mandatory arguments
        if(globals.mandatorystring == NULL)
        {
                printf("mandatorystring not set\n");
                exit(1);
        }

        if(globals.ival == 0)
        {
                printf("ival not set\n");
                exit(1);
        }

        if(isnan(globals.mandatoryfloat))
        {
                printf("mfloat not set\n");
                exit(1);
        }

        // Arguments should now be ready.
        printf("fval = %f\n", globals.fval);
        printf("stringval = %s\n", globals.stringval);
        printf("mandatorystring = %s\n", globals.mandatorystring);
        printf("ival = %d\n", globals.ival);
        printf("optionalflag = %d\n", globals.optionalflag);
        printf("mandatoryfloat = %f\n", globals.mandatoryfloat);
        return(0);
}

/* tsm_getopt.c */
#include <stdio.h>
#include <string.h>
#include "tsm_getopt.h"

static int tsm_findarg(const char *str, const opt options[]);

static int tsm_findarg(const char *str, const opt options[])
{
        int n;
        if(str[1] == '\0')
                return(-1);

        for(n=0; options[n].lname != NULL; n++)
        {
                // "-s"
                if((options[n].sname) &&
                        (str[1] == options[n].sname) &&
                        (str[2] == '\0'))
                        return(n);

                // "-s=..."
                if((options[n].sname) &&
                        (str[1] == options[n].sname) &&
                        (str[2] == '='))
                        return(n);

                // "--sval" or "--sval=..."
                if(str[1] == '-')
                if(strncmp(str+2, options[n].lname, strlen(options[n].lname))==0)
                if((str[2+strlen(options[n].lname)]=='\0')||
                   (str[2+strlen(options[n].lname)]=='='))
                        return(n);
        }

        return(-1);
}

int tsm_usage(int argc, char *argv[], const opt options[])
{
        int n;

        fprintf(stderr, "Usage:  %s\n", argv[0]);

        for(n=0; options[n].lname != NULL; n++)
        {
                fprintf(stderr, "\t--%s", options[n].lname);
                if(options[n].sname)
                        fprintf(stderr,"(-%c)", options[n].sname);
                if(options[n].usage)
                        fprintf(stderr, "\t%s", options[n].usage);
                fprintf(stderr, "\n");
        }
}

int tsm_getopt(int argc, char *argv[], const opt options[])
{
        int arg=1;
        while(arg < argc)
        {
                int which;
                if(strcmp(argv[arg], "--") == 0)
                        return(arg+2);
                else if(argv[arg][0] == '-')
                {
                        which=tsm_findarg(argv[arg], options);
                        if(which < 0)
                        {
                                fprintf(stderr, "invalid option '%s'\n",
                                        argv[arg]);
                                return(-1);
                        }

                        if(options[which].args)
                        {
                                // Handle -s=asdf or --sval=asdf
                                char *eq=strchr(argv[arg], '=');
                                char *argstr=NULL;

                                if(eq != NULL)
                                {
                                        eq++;
                                        if(eq[0] == '\0') eq=NULL;
                                }

                                if(((argc - arg) < 2)&&(eq==NULL))
                                {
                                        fprintf(stderr, "Need argument for %s\n",
                                                argv[arg]);
                                        return(-1);
                                }

                                if(eq) argstr=eq;
                                else    argstr=argv[arg+1];

                                // Store if possible
                                if(options[which].val)
                                {
                                        if(options[which].cmdstr)
                                        {
                                                if(sscanf(argstr,
                                                        options[which].cmdstr,
                                                        options[which].val) != 1)
                                                {
                                                        fprintf(stderr, "Invalid value "
                                                                "'%s' for option '%s'\n",
                                                                argv[arg], argv[arg+1]);
                                                        return(-1);
                                                }
                                        }
                                        else
                                                *((char **)options[which].val)=argstr;

                                        if(eq == NULL)  arg++;
                                }
                        }
                        else if(options[which].val != NULL)
                        {
                                // flag if possible
                                *((int *)options[which].val)=1;
                        }

                        arg++;
                }
                else
                        return(arg);
        }

        return(arg);
}

/* tsm_getopt.h */
#ifndef __TSM_GETOPT_H__
#define __TSM_GETOPT_H__

typedef struct opt
{
        const char      *lname;         // Long option, mandatory.
        unsigned char   sname;          // Short option, optional.
        int             args;           // Has arguments.
                                                // When cmdstr is NULL, stores
                                                // pointer to arg in *val
                                                // when cmdstr isn't NULL,
                                                // scanf's string into val
        void            *val;           // What to store
        const char      *cmdstr;        // Command string for scanf
        const char      *usage;         // Usage description
} opt;

#ifdef __cplusplus
extern "C" {
#endif

// Parse commandline parameters.  Returns index of first unparsed value.
int tsm_getopt(int argc, char *argv[], const opt options[]);
// Print usage for optional parameters
int tsm_usage(int argc, char *argv[], const opt options[]);

#ifdef __cplusplus
}
#endif

#endif/*__TSM_GETOPT_H__*/