/* (C) 2003 XDA Developers  itsme@xs4all.nl
 *
 * $Header$
 */
#ifndef __ARGS_H__

#ifndef _WIN32
#define _strtoi64 strtoll
#endif
#define HANDLEULOPTION(var, type) (argv[i][2] ? var= (type)strtoul(argv[i]+2, 0, 0) : i+1<argc ? var= (type)strtoul(argv[++i], 0, 0) : 0)
#define HANDLELLOPTION(var, type) (argv[i][2] ? var= (type)_strtoi64(argv[i]+2, 0, 0) : i+1<argc ? var= (type)_strtoi64(argv[++i], 0, 0) : 0)
#define HANDLESTROPTION(var) (argv[i][2] ? var= argv[i]+2 : (i+1<argc) ? var= argv[++i] : 0)

// use these when arg is a ptr to the arg string.
#define HANDLEULOPTION2(var, type) (*arg ? var= (type)strtoul(arg, 0, 0) : i+1<argc ? var= (type)strtoul(argv[++i], 0, 0) : 0)
#define HANDLESTROPTION2(var) (*arg ? var= arg : i+1<argc ? var= argv[++i] : 0)

// use these when args is a StringList
#define HANDLESTLSTRCOMBIOPTION(var) (arg[2] ? !(var= arg.substr(2)).empty() : i+1 != args.end() ? !(var= *(++i)).empty() : 0)
#define HANDLESTLSTROPTION(var) (i+1 != args.end() ? !(var= *(++i)).empty() : 0)
#define HANDLESTLULOPTION(var,type) (arg[2] ? var= (type)strtoul(ToString(arg.substr(2)).c_str(),0,0) : i+1 != args.end() ? var= (type)strtoul(ToString(*(++i)).c_str(),0,0) : 0)
#define HANDLESTLLLOPTION(var,type) (arg[2] ? var= (type)_strtoi64(ToString(arg.substr(2)).c_str(),0,0) : i+1 != args.end() ? var= (type)_strtoi64(ToString(*(++i)).c_str(),0,0) : 0)

#include <string>
#include <stdlib.h>
#include "vectorutils.h"
#include "stringutils.h"

template<typename T>
void parsearg(const char*arg, T& value)
{
    value= static_cast<T>(strtol(arg, 0, 0));
}

template<>
void parsearg<std::string>(const char*arg, std::string& value)
{
    value= arg;
}
template<>
void parsearg<ByteVector>(const char*arg, ByteVector& value)
{
    hex2binary(std::string(arg), value);
}
template<typename T>
void parsecsvarg(const char*arg, std::vector<T>& list)
{
    const char *p= arg;
    while (*p) {
        char *q;
        T value= static_cast<T>(strtol(p, &q, 0));
        if (p==q)
            break;
        list.push_back(value);
        // note: not actually checking for comma.
        p= q+1;
    }
}


//////////////////////////////////////////////////////////////////////////////
// void getarg(..., T& value)   style functions
//////////////////////////////////////////////////////////////////////////////
template<typename T>
void getarg(char **argv, int& i, int argc, T& value)
{
    if (argv[i][2]) {
        parsearg(argv[i]+2, value);
    }
    else if (++i<argc) {
        parsearg(argv[i], value);
    }
    else {
        throw "missing arg";
    }
}
template<typename T>
void getarg(StringList::iterator &i, StringList::iterator end, T& value)
{
    if ((*i).size()>2 && (*i).c_str()[2]) {
        parsearg((*i).c_str()+2, value);
    }
    else if (++i!=end) {
        parsearg((*i).c_str(), value);
    }
    else {
        throw "missing arg";
    }
}

//////////////////////////////////////////////////////////////////////////////
//  return csv list arguments
//////////////////////////////////////////////////////////////////////////////
template<typename T>
void getcsvarg(char **argv, int& i, int argc, std::vector<T>& list)
{
    if (argv[i][2]) {
        parsecsvarg(argv[i]+2, list);
    }
    else if (++i<argc) {
        parsecsvarg(argv[i], list);
    }
    else {
        throw "missing arg";
    }
}

template<typename T>
void getcsvarg(StringList::iterator &i, StringList::iterator end, std::vector<T>& list)
{
    if ((*i).size()>2 && (*i).c_str()[2]) {
        parsecsvarg((*i).c_str()+2, list);
    }
    else if (++i!=end) {
        parsecsvarg((*i).c_str(), list);
    }
    else {
        throw "missing arg";
    }
}

//////////////////////////////////////////////////////////////////////////////
//  return hex list arguments as binary
//////////////////////////////////////////////////////////////////////////////
template<typename T>
void gethexarg(char **argv, int& i, int argc, T& list)
{
    if (argv[i][2]) {
        hex2binary(std::string(argv[i]+2), list);
    }
    else if (++i<argc) {
        hex2binary(std::string(argv[i]), list);
    }
    else {
        throw "missing arg";
    }
}

template<typename T>
void gethexarg(StringList::iterator &i, StringList::iterator end, T& list)
{
    if ((*i).size()>2 && (*i).c_str()[2]) {
        hex2binary((*i).c_str()+2, list);
    }
    else if (++i!=end) {
        parsehexarg((*i).c_str(), list);
        hex2binary((*i).c_str(), list);
    }
    else {
        throw "missing arg";
    }
}


/*
    try {
    for (int i=1 ; i<argc ; i++)
    {
        if (argv[i][0]=='-') switch(argv[i][1])
        {
            case 'n': getarg(argv, i, argc, keynumber); break;
            case 'k': getarg(argv, i, argc, keystring); break;
            default: throw "unknown option";
        }
        else if (data.empty()) {
            data= hex2binary(argv[i]);
        }
        else {
            throw "too many args\n";
        }
    }
    }
    catch(const char*msg)
    {
        printf("%s\n", msg);
        usage();
        return 1;
    }
    catch(...)
    {
        usage();
        return 1;
    }
*/

//////////////////////////////////////////////////////////////////////////////
// T get<type>arg(argv,i,argc)   style functions
//////////////////////////////////////////////////////////////////////////////

inline std::string getstrarg(char **argv, int& i, int argc)
{
    std::string str;
    getarg(argv, i, argc, str);
    return str;
}
inline uint64_t getuintarg(char **argv, int& i, int argc)
{
    uint64_t val;
    getarg(argv, i, argc, val);
    return val;
}
inline int64_t getintarg(char **argv, int& i, int argc)
{
    int64_t val;
    getarg(argv, i, argc, val);
    return val;
}
inline ByteVector gethexarg(char **argv, int& i, int argc)
{
    ByteVector bytes;
    gethexarg(argv, i, argc, bytes);
    return bytes;
}
inline DwordVector getnumsarg(char **argv, int& i, int argc)
{
    DwordVector dwords;
    getcsvarg(argv, i, argc, dwords);
    return dwords;
}

#define __ARGS_H__
#endif