///////////////////////////////////////////////////////////////////////////////
// Name:        wx/cmdargs.h
// Purpose:     declaration of wxCmdLineArgsArray helper class
// Author:      Vadim Zeitlin
// Created:     2007-11-12
// Copyright:   (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

#ifndef _WX_CMDARGS_H_
#define _WX_CMDARGS_H_

#include "wx/arrstr.h"

// ----------------------------------------------------------------------------
// wxCmdLineArgsArray: helper class used by wxApp::argv
// ----------------------------------------------------------------------------

#if wxUSE_UNICODE

// this class is used instead of either "char **" or "wchar_t **" (neither of
// which would be backwards compatible with all the existing code) for argv
// field of wxApp
//
// as it's used for compatibility, it tries to look as much as traditional
// (char **) argv as possible, in particular it provides implicit conversions
// to "char **" and also array-like operator[]
class WXDLLIMPEXP_BASE wxCmdLineArgsArray
{
public:
    wxCmdLineArgsArray() { m_argsA = NULL; m_argsW = NULL; }

    template <typename T>
    void Init(int argc, T **argv)
    {
        FreeArgs();

        m_args.clear();
        m_args.reserve(argc);

        for ( int i = 0; i < argc; i++ )
        {
            m_args.push_back(argv[i]);
        }
    }

    operator char**() const
    {
        if ( !m_argsA )
        {
            const size_t count = m_args.size();
            m_argsA = new char *[count + 1];
            for ( size_t n = 0; n < count; n++ )
                m_argsA[n] = wxStrdup(m_args[n].ToAscii());

            m_argsA[count] = NULL;
        }

        return m_argsA;
    }

    operator wchar_t**() const
    {
        if ( !m_argsW )
        {
            const size_t count = m_args.size();
            m_argsW = new wchar_t *[count + 1];
            for ( size_t n = 0; n < count; n++ )
                m_argsW[n] = wxStrdup(m_args[n].wc_str());

            m_argsW[count] = NULL;
        }

        return m_argsW;
    }

    // existing code does checks like "if ( argv )" and we want it to continue
    // to compile, so provide this conversion even if it is pretty dangerous
    operator bool() const
    {
        return !m_args.empty();
    }

    // and the same for "if ( !argv )" checks
    bool operator!() const
    {
        return m_args.empty();
    }

    wxString operator[](size_t n) const
    {
        return m_args[n];
    }

    // we must provide this overload for g++ 3.4 which can't choose between
    // our operator[](size_t) and ::operator[](char**, int) otherwise
    wxString operator[](int n) const
    {
        return m_args[n];
    }


    // convenience methods, i.e. not existing only for backwards compatibility

    // do we have any arguments at all?
    bool IsEmpty() const { return m_args.empty(); }

    // access the arguments as a convenient array of wxStrings
    const wxArrayString& GetArguments() const { return m_args; }

    ~wxCmdLineArgsArray()
    {
        FreeArgs();
    }

private:
    template <typename T>
    void Free(T**& args)
    {
        if ( !args )
            return;

        const size_t count = m_args.size();
        for ( size_t n = 0; n < count; n++ )
            free(args[n]);

        delete [] args;
        args = NULL;
    }

    void FreeArgs()
    {
        Free(m_argsA);
        Free(m_argsW);
    }

    wxArrayString m_args;
    mutable char **m_argsA;
    mutable wchar_t **m_argsW;

    wxDECLARE_NO_COPY_CLASS(wxCmdLineArgsArray);
};

// provide global operator overload for compatibility with the existing code
// doing things like "if ( condition && argv )"
inline bool operator&&(bool cond, const wxCmdLineArgsArray& array)
{
    return cond && !array.IsEmpty();
}

#endif // wxUSE_UNICODE

#endif // _WX_CMDARGS_H_

