/*  PCSX2 - PS2 Emulator for PCs
 *  Copyright (C) 2002-2010  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 *  PURPOSE.  See the GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along with PCSX2.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <wx/tokenzr.h>
#include "common/Dependencies.h"
#include "common/SafeArray.h"
#include "common/ScopedAlloc.h"

#if _WIN32
#define WX_STR(str) (str.wc_str())
#else
// Stupid wx3.0 doesn't support c_str for vararg function
#define WX_STR(str) (static_cast<const char *>(str.c_str()))
#endif

// --------------------------------------------------------------------------------------
//  pxToUTF8
// --------------------------------------------------------------------------------------
// Converts a string to UTF8 and provides an interface for getting its length.
class pxToUTF8
{
    DeclareNoncopyableObject(pxToUTF8);

protected:
    wxCharBuffer m_result;
    int m_length;

public:
    explicit pxToUTF8(const wxString &src)
        : m_result(src.ToUTF8())
    {
        m_length = -1;
    }

    size_t Length()
    {
        if (-1 == m_length)
            m_length = strlen(m_result);
        return m_length;
    }

    void Convert(const wxString &src)
    {
        m_result = src.ToUTF8();
        m_length = -1;
    }

    const char *data() const { return m_result; }

    operator const char *() const
    {
        return m_result.data();
    }
};

extern void px_fputs(FILE *fp, const char *src);

// wxWidgets lacks one of its own...
extern const wxRect wxDefaultRect;

extern void SplitString(wxArrayString &dest, const wxString &src, const wxString &delims, wxStringTokenizerMode mode = wxTOKEN_RET_EMPTY_ALL);
extern wxString JoinString(const wxArrayString &src, const wxString &separator);
extern wxString JoinString(const wxChar **src, const wxString &separator);

extern wxString ToString(const wxPoint &src, const wxString &separator = L",");
extern wxString ToString(const wxSize &src, const wxString &separator = L",");
extern wxString ToString(const wxRect &src, const wxString &separator = L",");

extern bool TryParse(wxPoint &dest, const wxStringTokenizer &parts);
extern bool TryParse(wxSize &dest, const wxStringTokenizer &parts);

extern bool TryParse(wxPoint &dest, const wxString &src, const wxPoint &defval = wxDefaultPosition, const wxString &separators = L",");
extern bool TryParse(wxSize &dest, const wxString &src, const wxSize &defval = wxDefaultSize, const wxString &separators = L",");
extern bool TryParse(wxRect &dest, const wxString &src, const wxRect &defval = wxDefaultRect, const wxString &separators = L",");

// --------------------------------------------------------------------------------------
//  ParsedAssignmentString
// --------------------------------------------------------------------------------------
// This class is a simple helper for parsing INI-style assignments, in the typical form of:
//    variable = value
//    filename = SomeString.txt
//    integer  = 15
//
// This parser supports both '//' and ';' at the head of a line as indicators of a commented
// line, and such a line will return empty strings for l- and r-value.
//
// No type handling is performed -- the user must manually parse strings into integers, etc.
// For advanced "fully functional" ini file parsing, consider using wxFileConfig instead.
//
struct ParsedAssignmentString
{
    wxString lvalue;
    wxString rvalue;
    bool IsComment;

    ParsedAssignmentString(const wxString &src);
};

// ======================================================================================
//  FastFormatAscii / FastFormatUnicode  (overview!)
// ======================================================================================
// Fast formatting of ASCII or Unicode text.  These classes uses a series of thread-local
// format buffers that are allocated only once and grown to accommodate string formatting
// needs.  Because the buffers are thread-local, no thread synch objects are required in
// order to format strings, allowing for multi-threaded string formatting operations to be
// performed with maximum efficiency.  This class also reduces the overhead typically required
// to allocate string buffers off the heap.
//
// Drawbacks:
//  * Some overhead is added to the creation and destruction of threads, however since thread
//    construction is a typically slow process, and often avoided to begin with, this should
//    be a sound trade-off.
//
// Notes:
//  * conversion to wxString requires a heap allocation.
//  * FastFormatUnicode can accept either UTF8 or UTF16/32 (wchar_t) input, but FastFormatAscii
//    accepts Ascii/UTF8 only.
//

typedef ScopedAlignedAlloc<char, 16> CharBufferType;
// --------------------------------------------------------------------------------------
//  FastFormatAscii
// --------------------------------------------------------------------------------------

class FastFormatAscii
{
protected:
    CharBufferType m_dest;

public:
    FastFormatAscii();
    ~FastFormatAscii() = default;
    FastFormatAscii &Write(const char *fmt, ...);
    FastFormatAscii &WriteV(const char *fmt, va_list argptr);

    void Clear();
    bool IsEmpty() const;

    const char *c_str() const { return m_dest.GetPtr(); }
    operator const char *() const { return m_dest.GetPtr(); }

    const wxString GetString() const;
    //operator wxString() const;

    FastFormatAscii &operator+=(const wxString &s)
    {
        Write("%s", WX_STR(s));
        return *this;
    }

    FastFormatAscii &operator+=(const wxChar *psz)
    {
        Write("%ls", psz);
        return *this;
    }

    FastFormatAscii &operator+=(const char *psz)
    {
        Write("%s", psz);
        return *this;
    }
};

// --------------------------------------------------------------------------------------
//  FastFormatUnicode
// --------------------------------------------------------------------------------------
class FastFormatUnicode
{
protected:
    CharBufferType m_dest;
    uint m_Length;

public:
    FastFormatUnicode();
    ~FastFormatUnicode() = default;

    FastFormatUnicode &Write(const char *fmt, ...);
    FastFormatUnicode &Write(const wxChar *fmt, ...);
    FastFormatUnicode &Write(const wxString fmt, ...);
    FastFormatUnicode &WriteV(const char *fmt, va_list argptr);
    FastFormatUnicode &WriteV(const wxChar *fmt, va_list argptr);

    void Clear();
    bool IsEmpty() const;
    uint Length() const { return m_Length; }

    FastFormatUnicode &ToUpper();
    FastFormatUnicode &ToLower();

    const wxChar *c_str() const { return (const wxChar *)m_dest.GetPtr(); }
    operator const wxChar *() const { return (const wxChar *)m_dest.GetPtr(); }
    operator wxString() const { return (const wxChar *)m_dest.GetPtr(); }

    FastFormatUnicode &operator+=(const wxString &s)
    {
        Write(L"%s", WX_STR(s));
        return *this;
    }

    FastFormatUnicode &operator+=(const wxChar *psz)
    {
        Write(L"%s", psz);
        return *this;
    }

    FastFormatUnicode &operator+=(const char *psz);
};

extern bool pxParseAssignmentString(const wxString &src, wxString &ldest, wxString &rdest);

#define pxsFmt FastFormatUnicode().Write
#define pxsFmtV FastFormatUnicode().WriteV

#define pxsPtr(ptr) pxsFmt("0x%08X", (ptr)).c_str()

extern wxString &operator+=(wxString &str1, const FastFormatUnicode &str2);
extern wxString operator+(const wxString &str1, const FastFormatUnicode &str2);
extern wxString operator+(const wxChar *str1, const FastFormatUnicode &str2);
extern wxString operator+(const FastFormatUnicode &str1, const wxString &str2);
extern wxString operator+(const FastFormatUnicode &str1, const wxChar *str2);