/*
 * StringConverter.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */



#pragma once

#include <sol\Object.h>
#include <sol\StringT.h>

/**
 */
namespace SOL {

class StringConverter :public Object {

public:
    StringConverter() {
    }

public:
    // char -> char
    bool convert(const char* mbstring, __out StringT<char>& string)
    {
        bool rc = false;
        if (mbstring) {
            //return a copy of mbstring
            string = mbstring;
            rc = true;
        }
        return rc;
    }

public:
    // char -> wchar_t
    bool convert(const char* mbstring, __out StringT<wchar_t>& string)
    {
        return toWideChar(mbstring, string);
    }

public:
    // wchar_t -> char
    bool convert(const wchar_t* wcstring, __out StringT<char>& string)
    {
        return toMultiByte(wcstring, string);
    }

public:
    // wchar_t -> wchar_t
    bool convert(const wchar_t* wcstring, __out StringT<wchar_t>& string)
    {
        bool rc = false;
        if (wcstring) {
            //return a copy of mbstring
            string = wcstring;
            rc = true;
        }
        return rc;
    }


public:
    /**
     * MultiByteString -> WideCharString(Unicode)
     */
    wchar_t* toWideChar(const char* mbstring) {
        wchar_t* wcstring = NULL;

        if (mbstring == NULL) {
            return wcstring;
        }
        
        int cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, 0); 
        if (cb >0) {
            wcstring = new wchar_t[cb];
            wcstring[0] = Zero;
            MultiByteToWideChar(CP_ACP, 0, mbstring, -1, wcstring, cb); 
        }
        return wcstring;
    }

public:
    /**
     * WideCharString -> WideCharString(Unicode)
     */
    wchar_t* toWideChar(const wchar_t* wstring) {
        wchar_t* wcstring = NULL;

        if (wstring == NULL) {
            return wcstring;
        }

        //Simply return a duplicate wchar_t string.
        wcstring = _strdup(wstring);

        return wcstring;
    }

public:
    /**
     * MultiByteString -> WideCharString(Unicode)
     */
    //2009/10/10
    bool toWideChar(__in const char* mbstring, __out StringT<wchar_t>& stringw) {
        bool rc = false;

        if (mbstring == NULL) {
            return rc;
        }
        
        int cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, 0); 
        if (cb >0) {
            wchar_t* wcstring = NULL;

            wcstring = new wchar_t[cb];
            wcstring[0] = Zero;
            MultiByteToWideChar(CP_ACP, 0, mbstring, -1, wcstring, cb);
            stringw.shallowCopy(wcstring);
            rc = true;
        }
        return rc;
    }

public:
    /**
     * WideCharString(Unicode) -> MultiByteString 
     */
    char* toMultiByte(const wchar_t* wcstring) {

        char* mbstring = NULL;

        if (wcstring == NULL) {
            return mbstring;
        }
        
        int cb = WideCharToMultiByte(CP_ACP, 0, wcstring, -1, NULL, 0, NULL, NULL);
        
        if (cb > 0) {
            mbstring = new char[cb];
            mbstring[0] = Zero;
            WideCharToMultiByte(CP_ACP, 0, wcstring, -1, mbstring, cb, NULL, NULL);
        }
        return mbstring;
    }

public:
    /**
     * MultiByteString(Unicode) -> MultiByteString 
     */
    char* toMultiByte(const char* cstring) {

        char* mbstring = NULL;

        if (cstring == NULL) {
            return mbstring;
        }

        //Simply return a duplicate char string.
        mbstring = _strdup(cstring);

        return mbstring;
    }



public:
    /**
     * WideCharString(Unicode) -> MultiByteString 
     */
    //2009/10/10
    bool toMultiByte(__in const wchar_t* wcstring, __out StringT<char>& stringt) {

        bool rc = false;

        if (wcstring == NULL) {
            return rc;
        }
        
        int cb = WideCharToMultiByte(CP_ACP, 0, wcstring, -1, NULL, 0, NULL, NULL);
        
        if (cb > 0) {
            char* mbstring = new char[cb];
            mbstring[0] = Zero;
            WideCharToMultiByte(CP_ACP, 0, wcstring, -1, mbstring, cb, NULL, NULL);
            
            stringt.shallowCopy(mbstring);

            rc = true;
        }
        return rc;
    }


public:
    /**
     * MultiByteString -> BSTR
     */
    BSTR toBSTR(const char* mbstring) {
    
         BSTR bstring = NULL;
    
        if (mbstring == NULL) {
            return bstring;
        }

        int  cb = MultiByteToWideChar(CP_ACP, 0, mbstring, -1, NULL, NULL) -1;
         bstring = SysAllocStringLen(NULL, cb);
        if (bstring != NULL) {
            MultiByteToWideChar(CP_ACP, 0, mbstring, -1, bstring, cb);
        }
        return bstring;
    }

public:
    //2009/06/18
    BSTR toBSTR(const wchar_t* wcstring)
    {
        BSTR bstring = NULL;
        if (wcstring == NULL) {
            return bstring;
        }
  
        bstring = SysAllocStringLen(wcstring, wcslen(wcstring));

        return bstring;
    }
};

}