#include "platform/nstring.hpp"
#include "string.h"
#include "wchar.h"
#include "stdlib.h"

size_t nstring::length(const wchar_t* pstr,int MaxCount)
{
    return !pstr? 0 :  MaxCount? wcsnlen(pstr,MaxCount): wcslen(pstr);
}

size_t nstring::length(const char* pstr,int MaxCount)
{
    return !pstr? 0 :  MaxCount? strnlen(pstr,MaxCount): strlen(pstr);
}

wchar_t* nstring::clone(const wchar_t* psrc)
{
    return !psrc? nullptr: _wcsdup(psrc);
}

char* nstring::clone(const char* psrc)
{
    return !psrc? nullptr: _strdup(psrc);
}

size_t nstring::find(const wchar_t* psrc, const wchar_t* substr,int pos)
{
    return !psrc || !substr ? -1 : wcsstr(psrc+pos,substr)? wcsstr(psrc+pos,substr) - psrc : -1;  
}

size_t nstring::find(const char* psrc, const char* substr,int pos)
{
    return !psrc || !substr ? -1 : strstr(psrc+pos,substr)? strstr(psrc+pos,substr) - psrc : -1;  
}

const wchar_t* nstring::str(const wchar_t* psrc, const wchar_t* substr)
{
    return !psrc?nullptr:!substr?nullptr:wcsstr(psrc,substr);
}

const char* nstring::str(const char* psrc, const char* substr)
{
    return !psrc?nullptr:!substr?nullptr:strstr(psrc,substr);
}
wchar_t * nstring::set(wchar_t * psrc, int val)
{
    return _wcsset(psrc,val);
}

char * nstring::set(char * psrc, int val)
{
    return _strset(psrc,val);
}

wchar_t* nstring::ncpy(wchar_t* pdest, const wchar_t* psrc,int nlen)
{
    return !pdest? nullptr : !psrc?pdest: wcsncpy(pdest,psrc,nlen);
}
char* nstring::ncpy(char* pdest, const char* psrc,int nlen)
{
    return !pdest? nullptr : !psrc?pdest: strncpy(pdest,psrc,nlen);
}

wchar_t* nstring::cpy(wchar_t* pdest, const wchar_t* psrc)
{
    return !pdest? nullptr : !psrc?pdest: wcscpy(pdest,psrc);
}
char* nstring::cpy(char* pdest, const char* psrc)
{
    return !pdest? nullptr : !psrc?pdest: strcpy(pdest,psrc);
}


int nstring::cmp(const wchar_t* pstr1,const wchar_t* pstr2,int MaxCount)
{
    return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1:MaxCount? wcsncmp(pstr1,pstr2,MaxCount): wcscmp(pstr1,pstr2);
}

int nstring::cmp(const char* pstr1,const char* pstr2,int MaxCount)
{
    return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1:MaxCount? strncmp(pstr1,pstr2,MaxCount): strcmp(pstr1,pstr2);
}


int nstring::icmp(const wchar_t* pstr1,const wchar_t* pstr2,int MaxCount)
{
     return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1:MaxCount? _wcsnicmp(pstr1,pstr2,MaxCount): _wcsicmp(pstr1,pstr2);
}

int nstring::icmp(const char* pstr1,const char* pstr2,int MaxCount)
{
    return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1:MaxCount? _strnicmp(pstr1,pstr2,MaxCount): _stricmp(pstr1,pstr2);
}

wchar_t* nstring::cat(wchar_t* pdest, wchar_t* psrc,int MaxCount)
{
   return !pdest? nullptr:!psrc? pdest: MaxCount? wcsncat(pdest,psrc,MaxCount): wcscat(pdest,psrc);
}

char* nstring::cat(char* pdest, char* psrc,int MaxCount)
{
     return !pdest? nullptr:!psrc? pdest: MaxCount? strncat(pdest,psrc,MaxCount): strcat(pdest,psrc);
}

const wchar_t* nstring::chr(const wchar_t* psrc, int val)
{
    return !psrc?nullptr: wcschr(psrc,val);
}

const char* nstring::chr(const char* psrc, int val)
{
    return !psrc?nullptr: strchr(psrc,val);
}

int nstring::coll(const wchar_t* pstr1,const wchar_t* pstr2)
{
     return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1: wcscoll(pstr1,pstr2);
}

int nstring::coll(const char* pstr1,const char* pstr2)
{
    return !pstr1 && !pstr2? 0: !pstr1? 1:!pstr2?-1: strcoll(pstr1,pstr2);
}

size_t nstring::cspn(const wchar_t *_Str,const wchar_t *_Control)
{
    return !_Str||!_Control?-1: wcscspn(_Str,_Control);
}

size_t nstring::cspn(const char *_Str,const char *_Control)
{
    return !_Str||!_Control?-1: strcspn(_Str,_Control);
}

wchar_t * nstring::error(const wchar_t *_ErrMsg)
{
    return !_ErrMsg?nullptr: __wcserror(_ErrMsg);
}

char * nstring::error(const char *_ErrMsg)
{
    return !_ErrMsg?nullptr: _strerror(_ErrMsg);
}

wchar_t * nstring::toLower(wchar_t *_Str)
{
    return !_Str?nullptr: _wcslwr(_Str);
}

wchar_t * nstring::toUpper(wchar_t *_Str)
{
    return !_Str?nullptr: _wcsupr(_Str);
}

char* nstring::toLower(char* _Str)
{
    return !_Str ? nullptr : _strlwr(_Str);
}

char* nstring::toUpper(char* _Str)
{
    return !_Str ? nullptr : _strupr(_Str);
}

const wchar_t * nstring::pbrk(const wchar_t *_Str,const wchar_t *_Control)
{
    return !_Str||!_Control?nullptr:!_Str?nullptr:!_Control?nullptr: wcspbrk(_Str,_Control);
}

const char * nstring::pbrk(const char *_Str,const char *_Control)
{
    return !_Str||!_Control?nullptr:!_Str?nullptr:!_Control?nullptr: strpbrk(_Str,_Control);
}

wchar_t * nstring::rev(wchar_t *_Str)
{
    return !_Str?nullptr: _wcsrev(_Str);
}

char * nstring::rev(char *_Str)
{
    return !_Str?nullptr: _strrev(_Str);
}

int nstring::toInt(wchar_t *_Str)
{
    return !_Str?0:_wtol(_Str);
}
int nstring::toInt64(wchar_t* _Str)
{
    return !_Str ? 0 : _wtoll(_Str);
}
double nstring::toDouble(wchar_t* _Str)
{
    return !_Str ? 0 : ::_wtof(_Str);
}

int nstring::toInt(char *_Str)
{
    return !_Str?0:atol(_Str);
}
int nstring::toInt64(char* _Str)
{
    return !_Str ? 0 : atoll(_Str);
}
double nstring::toDouble(char* _Str)
{
    return !_Str ? 0 : atof(_Str);
}

wchar_t * nstring::toWStr(int val)
{
    wchar_t buf[64];
    _ltow_s(val,buf,10);
    return _wcsdup(buf);
}

wchar_t * nstring::toWStr(double val)
{
    wchar_t buf[64];
    swprintf_s(buf,L"%f",val);
    return _wcsdup(buf);
}

wchar_t * nstring::toWStr(int val,wchar_t* buffer, int maxLen)
{
    _ltow_s(val,buffer,maxLen,10);
    return buffer;
}

wchar_t * nstring::toWStr(double val,wchar_t* buffer, int maxLen)
{
    swprintf_s(buffer,maxLen,L"%f",val);
    return buffer;
}

wchar_t* nstring::toWStr(LPARAM val)
{
    wchar_t buf[64];
    //swprintf_s(buf,L"%l64d",(__int64)val);
    _i64tow_s((long long)val, buf, 64, 10);
    return _wcsdup(buf);
}
wchar_t* nstring::toWStr(LPARAM val,wchar_t* buffer, int maxLen)
{
    _i64tow_s((long long)val, buffer, maxLen, 10);
    //swprintf_s(buffer,maxLen,L"%l64d",(__int64)val);
    return buffer;
}

wchar_t* nstring::trim(wchar_t* pstr)
{
    if (!pstr)return 0;
    wchar_t* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    p = _wcsdup(p);
    int nlen = (int)wcslen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}

wchar_t* nstring::ltrim(wchar_t* pstr)
{
    if (!pstr)return 0;
    wchar_t* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    return _wcsdup(p);;
}

wchar_t* nstring::rtrim(wchar_t* pstr)
{
    if (!pstr)return 0;
    wchar_t* p = _wcsdup(pstr);
    int nlen = (int)wcslen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}

char* nstring::trim(char* pstr)
{
    if (!pstr)return 0;
    char* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    p = _strdup(p);
    int nlen = (int)strlen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}

char* nstring::ltrim(char* pstr)
{
    if (!pstr)return 0;
    char* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    return _strdup(p);;
}

char* nstring::rtrim(char* pstr)
{
    if (!pstr)return 0;
    char* p = _strdup(pstr);
    int nlen = (int)strlen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}

wchar_t* nstring::trim_(wchar_t* pstr,wchar_t* dest)
{
    if (!pstr)return 0;
    wchar_t* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    wcscpy(dest,p);
    p = dest;
    int nlen = (int)wcslen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}

wchar_t* nstring::ltrim_(wchar_t* pstr, wchar_t* dest)
{
    if (!pstr)return 0;
    wchar_t* p = pstr;
    while (p && p[0] == ' ' || p[0] == '\t' || p[0] == '\n')p++;
    wcscpy(dest, p);
    return dest;
}

wchar_t* nstring::rtrim_(wchar_t* pstr, wchar_t* dest)
{
    if (!pstr)return 0;
    wchar_t* p = dest;
    int nlen = (int)wcslen(p);
    while (nlen > 1 && p[nlen - 1] == ' ' || p[nlen - 1] == '\t' || p[nlen - 1] == '\n')nlen--;
    p[nlen] = 0;
    return p;
}