/*

 *

 *

 *

 */

#ifndef PLATFORMSTRING_H

#define PLATFORMSTRING_H

#include <string>

#include <list>

#include <stdio.h>

#include <stdlib.h>

#include "jni.h"

#include "Platform.h"

struct WideString {

    size_t length;

    wchar_t* data;

    WideString() { length = 0; data = NULL; }

};

struct MultibyteString {

    size_t length;

    char* data;

    MultibyteString() { length = 0; data = NULL; }

};

template <typename T>

class DynamicBuffer {

private:

    T* FData;

    size_t FSize;

public:

    DynamicBuffer(size_t Size) {

        FSize = 0;

        FData = NULL;

        Resize(Size);

    }

    ~DynamicBuffer() {

        delete[] FData;

    }

    T* GetData() { return FData; }

    size_t GetSize() { return FSize; }

    void Resize(size_t Size) {

        FSize = Size;

        if (FData != NULL) {

            delete[] FData;

            FData = NULL;

        }

        if (FSize != 0) {

            FData = new T[FSize];

            Zero();

        }

    }

    void Zero() {

        memset(FData, 0, FSize * sizeof(T));

    }

    T& operator[](size_t index) {

        return FData[index];

    }

};

#ifdef MAC

// StringToFileSystemString is a stack object. It's usage is simply inline to convert a

// TString to a file system string. Example:

//

// return dlopen(StringToFileSystemString(FileName), RTLD_LAZY);

//

class StringToFileSystemString {

    // Prohibit Heap-Based StringToFileSystemString

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

private:

    TCHAR* FData;

    bool FRelease;

public:

    StringToFileSystemString(const TString &value);

    ~StringToFileSystemString();

    operator TCHAR* ();

};

// FileSystemStringToString is a stack object. It's usage is simply inline to convert a

// file system string to a TString. Example:

//

// DynamicBuffer<TCHAR> buffer(MAX_PATH);

// if (readlink("/proc/self/exe", buffer.GetData(), MAX_PATH) != -1)

//    result = FileSystemStringToString(buffer.GetData());

//

class FileSystemStringToString {

    // Prohibit Heap-Based FileSystemStringToString

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

private:

    TString FData;

public:

    FileSystemStringToString(const TCHAR* value);

    operator TString ();

};

#endif //MAC

#ifdef LINUX

#define StringToFileSystemString PlatformString

#define FileSystemStringToString PlatformString

#endif //LINUX

class PlatformString {

private:

    char* FData; // Stored as UTF-8

    size_t FLength;

    wchar_t* FWideTStringToFree;

    void initialize();

    // Caller must free result using delete[].

    static void CopyString(char *Destination, size_t NumberOfElements, const char *Source);

    // Caller must free result using delete[].

    static void CopyString(wchar_t *Destination, size_t NumberOfElements, const wchar_t *Source);

    static WideString MultibyteStringToWideString(const char* value);

    static MultibyteString WideStringToMultibyteString(const wchar_t* value);

// Prohibit Heap-Based PlatformStrings

private:

    static void *operator new(size_t size);

    static void operator delete(void *ptr);

public:

    PlatformString(void);

    PlatformString(const PlatformString &value);

    PlatformString(const char* value);

    PlatformString(const wchar_t* value);

    PlatformString(const std::string &value);

    PlatformString(const std::wstring &value);

    PlatformString(JNIEnv *env, jstring value);

    PlatformString(size_t Value);

    static TString Format(const TString value, ...);

    ~PlatformString(void);

    size_t length();

    char* c_str();

    char* toMultibyte();

    wchar_t* toWideString();

    std::wstring toUnicodeString();

    std::string toStdString();

    jstring toJString(JNIEnv *env);

    TCHAR* toPlatformString();

    TString toString();

    operator char* ();

    operator wchar_t* ();

    operator std::wstring ();

    // Caller must free result using delete[].

    static char* duplicate(const char* Value);

    // Caller must free result using delete[].

    static wchar_t* duplicate(const wchar_t* Value);

};

#endif //PLATFORMSTRING_H