///////////////////////////////////////////////////////////////////////////////

// Name:        wx/cmdline.h

// Purpose:     wxCmdLineParser and related classes for parsing the command

//              line options

// Author:      Vadim Zeitlin

// Created:     04.01.00

// Copyright:   (c) 2000 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

// Licence:     wxWindows licence

///////////////////////////////////////////////////////////////////////////////

#ifndef _WX_CMDLINE_H_

#define _WX_CMDLINE_H_

#include "wx/defs.h"

#include "wx/string.h"

#include "wx/arrstr.h"

#include "wx/cmdargs.h"

// determines ConvertStringToArgs() behaviour

enum wxCmdLineSplitType

{

    wxCMD_LINE_SPLIT_DOS,

    wxCMD_LINE_SPLIT_UNIX

};

#if wxUSE_CMDLINE_PARSER

class WXDLLIMPEXP_FWD_BASE wxCmdLineParser;

class WXDLLIMPEXP_FWD_BASE wxDateTime;

// ----------------------------------------------------------------------------

// constants

// ----------------------------------------------------------------------------

// by default, options are optional (sic) and each call to AddParam() allows

// one more parameter - this may be changed by giving non-default flags to it

enum wxCmdLineEntryFlags

{

    wxCMD_LINE_OPTION_MANDATORY = 0x01, // this option must be given

    wxCMD_LINE_PARAM_OPTIONAL   = 0x02, // the parameter may be omitted

    wxCMD_LINE_PARAM_MULTIPLE   = 0x04, // the parameter may be repeated

    wxCMD_LINE_OPTION_HELP      = 0x08, // this option is a help request

    wxCMD_LINE_NEEDS_SEPARATOR  = 0x10, // must have sep before the value

    wxCMD_LINE_SWITCH_NEGATABLE = 0x20, // this switch can be negated (e.g. /S-)

    wxCMD_LINE_HIDDEN           = 0x40  // this switch is not listed by Usage()

};

// an option value or parameter may be a string (the most common case), a

// number or a date

enum wxCmdLineParamType

{

    wxCMD_LINE_VAL_STRING,  // should be 0 (default)

    wxCMD_LINE_VAL_NUMBER,

    wxCMD_LINE_VAL_DATE,

    wxCMD_LINE_VAL_DOUBLE,

    wxCMD_LINE_VAL_NONE

};

// for constructing the cmd line description using Init()

enum wxCmdLineEntryType

{

    wxCMD_LINE_SWITCH,

    wxCMD_LINE_OPTION,

    wxCMD_LINE_PARAM,

    wxCMD_LINE_USAGE_TEXT,

    wxCMD_LINE_NONE         // to terminate the list

};

// Possible return values of wxCmdLineParser::FoundSwitch()

enum wxCmdLineSwitchState

{

    wxCMD_SWITCH_OFF = -1,  // Found but turned off/negated.

    wxCMD_SWITCH_NOT_FOUND, // Not found at all.

    wxCMD_SWITCH_ON         // Found in normal state.

};

// Constants determining how (and if) to wrap the usage message

constexpr int wxCMD_LINE_WRAP_AUTO = -1;

constexpr int wxCMD_LINE_WRAP_NONE = 0;

// ----------------------------------------------------------------------------

// wxCmdLineEntryDesc is a description of one command line

// switch/option/parameter

// ----------------------------------------------------------------------------

struct wxCmdLineEntryDesc

{

    wxCmdLineEntryType kind;

    const char *shortName;

    const char *longName;

    const char *description;

    wxCmdLineParamType type;

    int flags;

};

// the list of wxCmdLineEntryDesc objects should be terminated with this one

#define wxCMD_LINE_DESC_END \

        { wxCMD_LINE_NONE, nullptr, nullptr, nullptr, wxCMD_LINE_VAL_NONE, 0x0 }

// ----------------------------------------------------------------------------

// wxCmdLineArg contains the value for one command line argument

// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxCmdLineArg

{

public:

    virtual ~wxCmdLineArg() = default;

    virtual double GetDoubleVal() const = 0;

    virtual long GetLongVal() const = 0;

    virtual const wxString& GetStrVal() const = 0;

#if wxUSE_DATETIME

    virtual const wxDateTime& GetDateVal() const = 0;

#endif // wxUSE_DATETIME

    virtual bool IsNegated() const = 0;

    virtual wxCmdLineEntryType GetKind() const = 0;

    virtual wxString GetShortName() const = 0;

    virtual wxString GetLongName() const = 0;

    virtual wxCmdLineParamType GetType() const = 0;

};

// ----------------------------------------------------------------------------

// wxCmdLineArgs is a container of command line arguments actually parsed and

// allows enumerating them using the standard iterator-based approach.

// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxCmdLineArgs

{

public:

    class WXDLLIMPEXP_BASE const_iterator

    {

    public:

        typedef int difference_type;

        typedef wxCmdLineArg value_type;

        typedef const wxCmdLineArg* pointer;

        typedef const wxCmdLineArg& reference;

        typedef std::bidirectional_iterator_tag iterator_category;

        const_iterator() : m_parser(nullptr), m_index(0) {}

        reference operator *() const;

        pointer operator ->() const;

        const_iterator &operator ++ ();

        const_iterator operator ++ (int);

        const_iterator &operator -- ();

        const_iterator operator -- (int);

        bool operator == (const const_iterator &other) const {

            return m_parser==other.m_parser && m_index==other.m_index;

        }

        bool operator != (const const_iterator &other) const {

            return !operator==(other);

        }

    private:

        const_iterator (const wxCmdLineParser& parser, size_t index)

            : m_parser(&parser), m_index(index) {

        }

        const wxCmdLineParser* m_parser;

        size_t m_index;

        friend class wxCmdLineArgs;

    };

    wxCmdLineArgs (const wxCmdLineParser& parser) : m_parser(parser) {}

    const_iterator begin() const { return const_iterator(m_parser, 0); }

    const_iterator end() const { return const_iterator(m_parser, size()); }

    size_t size() const;

private:

    const wxCmdLineParser& m_parser;

    wxDECLARE_NO_ASSIGN_DEF_COPY(wxCmdLineArgs);

};

// ----------------------------------------------------------------------------

// wxCmdLineParser is a class for parsing command line.

//

// It has the following features:

//

// 1. distinguishes options, switches and parameters; allows option grouping

// 2. allows both short and long options

// 3. automatically generates the usage message from the cmd line description

// 4. does type checks on the options values (number, date, ...)

//

// To use it you should:

//

// 1. construct it giving it the cmd line to parse and optionally its desc

// 2. construct the cmd line description using AddXXX() if not done in (1)

// 3. call Parse()

// 4. use GetXXX() to retrieve the parsed info

// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxCmdLineParser

{

public:

    // ctors and initializers

    // ----------------------

    // default ctor or ctor giving the cmd line in either Unix or Win form

    wxCmdLineParser() { Init(); }

    wxCmdLineParser(int argc, char **argv) { Init(); SetCmdLine(argc, argv); }

    wxCmdLineParser(int argc, wxChar **argv) { Init(); SetCmdLine(argc, argv); }

    wxCmdLineParser(int argc, const wxCmdLineArgsArray& argv)

        { Init(); SetCmdLine(argc, argv); }

    wxCmdLineParser(const wxString& cmdline) { Init(); SetCmdLine(cmdline); }

    // the same as above, but also gives the cmd line description - otherwise,

    // use AddXXX() later

    wxCmdLineParser(const wxCmdLineEntryDesc *desc)

        { Init(); SetDesc(desc); }

    wxCmdLineParser(const wxCmdLineEntryDesc *desc, int argc, char **argv)

        { Init(); SetCmdLine(argc, argv); SetDesc(desc); }

    wxCmdLineParser(const wxCmdLineEntryDesc *desc, int argc, wxChar **argv)

        { Init(); SetCmdLine(argc, argv); SetDesc(desc); }

    wxCmdLineParser(const wxCmdLineEntryDesc *desc,

                    int argc,

                    const wxCmdLineArgsArray& argv)

        { Init(); SetCmdLine(argc, argv); SetDesc(desc); }

    wxCmdLineParser(const wxCmdLineEntryDesc *desc, const wxString& cmdline)

        { Init(); SetCmdLine(cmdline); SetDesc(desc); }

    // set cmd line to parse after using one of the ctors which don't do it

    void SetCmdLine(int argc, char **argv);

    void SetCmdLine(int argc, wxChar **argv);

    void SetCmdLine(int argc, const wxCmdLineArgsArray& argv);

    void SetCmdLine(const wxString& cmdline);

    // not virtual, don't use this class polymorphically

    ~wxCmdLineParser();

    // set different parser options

    // ----------------------------

    // by default, '-' is switch char under Unix, '-' or '/' under Win:

    // switchChars contains all characters with which an option or switch may

    // start

    void SetSwitchChars(const wxString& switchChars);

    // long options are not POSIX-compliant, this option allows to disable them

    void EnableLongOptions(bool enable = true);

    void DisableLongOptions() { EnableLongOptions(false); }

    bool AreLongOptionsEnabled() const;

    // extra text may be shown by Usage() method if set by this function

    void SetLogo(const wxString& logo);

    // set the brief usage string instead of constructing it automatically

    void SetUsageSynopsis(const wxString& synopsis);

    // construct the cmd line description

    // ----------------------------------

    // take the cmd line description from the wxCMD_LINE_NONE terminated table

    void SetDesc(const wxCmdLineEntryDesc *desc);

    // a switch: i.e. an option without value

    void AddSwitch(const wxString& name, const wxString& lng = wxEmptyString,

                   const wxString& desc = wxEmptyString,

                   int flags = 0);

    void AddLongSwitch(const wxString& lng,

                       const wxString& desc = wxEmptyString,

                       int flags = 0)

    {

        AddSwitch(wxString(), lng, desc, flags);

    }

    // an option taking a value of the given type

    void AddOption(const wxString& name, const wxString& lng = wxEmptyString,

                   const wxString& desc = wxEmptyString,

                   wxCmdLineParamType type = wxCMD_LINE_VAL_STRING,

                   int flags = 0);

    void AddLongOption(const wxString& lng,

                       const wxString& desc = wxEmptyString,

                       wxCmdLineParamType type = wxCMD_LINE_VAL_STRING,

                       int flags = 0)

    {

        AddOption(wxString(), lng, desc, type, flags);

    }

    // a parameter

    void AddParam(const wxString& desc = wxEmptyString,

                  wxCmdLineParamType type = wxCMD_LINE_VAL_STRING,

                  int flags = 0);

    // add an explanatory text to be shown to the user in help

    void AddUsageText(const wxString& text);

    // actions

    // -------

    // parse the command line, return 0 if ok, -1 if "-h" or "--help" option

    // was encountered and the help message was given or a positive value if a

    // syntax error occurred

    //

    // if showUsage is true, Usage() is called in case of syntax error or if

    // help was requested and if wrapColumn is not 0, the usage message is

    // wrapped at the specified column, which will be the terminal width for

    // its default value

    int Parse(bool showUsage = true, int wrapColumn = wxCMD_LINE_WRAP_AUTO);

    // give the usage message describing all program options

    void Usage(int wrapColumn = wxCMD_LINE_WRAP_AUTO) const;

    // return the usage string, call Usage() to directly show it to the user

    wxString GetUsageString(int wrapColumn = wxCMD_LINE_WRAP_AUTO) const;

    // get the command line arguments

    // ------------------------------

    // returns true if the given switch was found

    bool Found(const wxString& name) const;

    // Returns wxCMD_SWITCH_NOT_FOUND if the switch was not found at all,

    // wxCMD_SWITCH_ON if it was found in normal state and wxCMD_SWITCH_OFF if

    // it was found but negated (i.e. followed by "-", this can only happen for

    // the switches with wxCMD_LINE_SWITCH_NEGATABLE flag).

    wxCmdLineSwitchState FoundSwitch(const wxString& name) const;

    // returns true if an option taking a string value was found and stores the

    // value in the provided pointer

    bool Found(const wxString& name, wxString *value) const;

    // returns true if an option taking an integer value was found and stores

    // the value in the provided pointer

    bool Found(const wxString& name, long *value) const;

    // returns true if an option taking a double value was found and stores

    // the value in the provided pointer

    bool Found(const wxString& name, double *value) const;

#if wxUSE_DATETIME

    // returns true if an option taking a date value was found and stores the

    // value in the provided pointer

    bool Found(const wxString& name, wxDateTime *value) const;

#endif // wxUSE_DATETIME

    // gets the number of parameters found

    size_t GetParamCount() const;

    // gets the value of Nth parameter (as string only for now)

    wxString GetParam(size_t n = 0u) const;

    // returns a reference to the container of all command line arguments

    wxCmdLineArgs GetArguments() const { return wxCmdLineArgs(*this); }

    // Resets switches and options

    void Reset();

    // break down the command line in arguments

    static wxArrayString

    ConvertStringToArgs(const wxString& cmdline,

                        wxCmdLineSplitType type = wxCMD_LINE_SPLIT_DOS);

private:

    // common part of all ctors

    void Init();

    struct wxCmdLineParserData *m_data;

    friend class wxCmdLineArgs;

    friend class wxCmdLineArgs::const_iterator;

    wxDECLARE_NO_COPY_CLASS(wxCmdLineParser);

};

#else // !wxUSE_CMDLINE_PARSER

// this function is always available (even if !wxUSE_CMDLINE_PARSER) because it

// is used by wxWin itself under Windows

class WXDLLIMPEXP_BASE wxCmdLineParser

{

public:

    static wxArrayString

    ConvertStringToArgs(const wxString& cmdline,

                        wxCmdLineSplitType type = wxCMD_LINE_SPLIT_DOS);

};

#endif // wxUSE_CMDLINE_PARSER/!wxUSE_CMDLINE_PARSER

#endif // _WX_CMDLINE_H_