//-----------------------------------------------------------------------------
// Torque Game Engine 
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------

#include "PlatformMacCarb/platformMacCarb.h"
#include "platform/platform.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <CoreFoundation/CoreFoundation.h>
#include "console/console.h"
#include "platform/profiler.h"

char *dStrdup_r(const char *src, const char *file, dsize_t line)
{
   char *buffer = (char *) dMalloc_r(dStrlen(src) + 1, file, line);
   dStrcpy(buffer, src);
   return buffer;
}

char *dStrnew(const char *src)
{
   char *buffer = new char[dStrlen(src) + 1];
   dStrcpy(buffer, src);
   return buffer;
}

char* dStrcat(char *dst, const char *src)
{
   return strcat(dst,src);
}   

char* dStrncat(char *dst, const char *src, dsize_t len)
{
   return strncat(dst,src,len);
}

// concatenates a list of src's onto the end of dst
// the list of src's MUST be terminated by a NULL parameter
// dStrcatl(dst, sizeof(dst), src1, src2, NULL);
char* dStrcatl(char *dst, dsize_t dstSize, ...)
{
   const char* src;
   char *p = dst;

   AssertFatal(dstSize > 0, "dStrcatl: destination size is set zero");
   dstSize--;  // leave room for string termination

   // find end of dst
   while (dstSize && *p++)                    
      dstSize--;   
   
   va_list args;
   va_start(args, dstSize);

   // concatenate each src to end of dst
   while ( (src = va_arg(args, const char*)) != NULL )
      while( dstSize && *src )
      {
         *p++ = *src++;
         dstSize--;   
      }

   va_end(args);

   // make sure the string is terminated 
   *p = 0;

   return dst;
}   


// copy a list of src's into dst
// the list of src's MUST be terminated by a NULL parameter
// dStrccpyl(dst, sizeof(dst), src1, src2, NULL);
char* dStrcpyl(char *dst, dsize_t dstSize, ...)
{
   const char* src;
   char *p = dst;

   AssertFatal(dstSize > 0, "dStrcpyl: destination size is set zero");
   dstSize--;  // leave room for string termination

   va_list args;
   va_start(args, dstSize);

   // concatenate each src to end of dst
   while ( (src = va_arg(args, const char*)) != NULL )
      while( dstSize && *src )
      {
         *p++ = *src++;
         dstSize--;   
      }

   va_end(args);

   // make sure the string is terminated 
   *p = 0;

   return dst;
}   


int dStrcmp(const char *str1, const char *str2)
{
   return strcmp(str1, str2);   
}

int dStrcmp( const UTF16 *str1, const UTF16 *str2)
{
   int ret;
   const UTF16 *a, *b;
   a = str1;
   b = str2;

   while( *a && *b && (ret = *a - *b) == 0)
      a++, b++;

   return ret;
}  

 
int dStricmp(const char *str1, const char *str2)
{
   char c1, c2;
   while (1)
   {
      c1 = tolower(*str1++);
      c2 = tolower(*str2++);
      if (c1 < c2) return -1;
      if (c1 > c2) return 1;
      if (c1 == 0) return 0;
   }
}  

int dStrncmp(const char *str1, const char *str2, dsize_t len)
{
   return strncmp(str1, str2, len);   
}  
 
int dStrnicmp(const char *str1, const char *str2, dsize_t len)
{
   S32 i;
   char c1, c2;
   for (i=0; i<len; i++)
   {
      c1 = tolower(*str1++);
      c2 = tolower(*str2++);
      if (c1 < c2) return -1;
      if (c1 > c2) return 1;
      if (!c1) return 0;
     }
   return 0;
}   


char* dStrcpy(char *dst, const char *src)
{
   return strcpy(dst,src);
}   

char* dStrncpy(char *dst, const char *src, dsize_t len)
{
   return strncpy(dst,src,len);
}   

dsize_t dStrlen(const char *str)
{
   return strlen(str);
}   

/*dsize_t dStrlenUTF8_fast(const UTF8 *str)
{
   // we do not run this through the operating system, because this method may be faster.
   int c = 0;
   for(; str; str = getNextUTF8Char(str))
      c++;

   return c;
}
*/
/*dsize_t dStrlenUTF8(const UTF8 *str)
{
   CFStringRef cfstr;
   U32         cfstrlen;
   
   if(!str)
      return 0;
      
   cfstr = CFStringCreateWithCString( kCFAllocatorDefault, (char*)str, kCFStringEncodingUTF8);
   if(!cfstr)
      return 0;
   cfstrlen = CFStringGetLength(cfstr);
   CFRelease(cfstr);
   
   return cfstrlen;

}
*/
/*dsize_t dStrlen(const UTF16 *str)
{
   int i=0;
   while(str[i] != 0x0000) i++;
   
   return i;

   // slower than just counting wchars, but makes sure surrogate pairs are dealt with correctly.
   CFStringRef cfstr;
   U32         cfstrlen;
   
   cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (char*)str, kCFStringEncodingUnicode);
   cfstrlen = CFStringGetLength(cfstr);
   CFRelease(cfstr);
   
   return cfstrlen;
}
*/

char* dStrupr(char *str)
{
   char* saveStr = str;
   while (*str)
   {
      *str = toupper(*str);
      str++;
   }
   return saveStr;
}   


char* dStrlwr(char *str)
{
   char* saveStr = str;
   while (*str)
   {
      *str = tolower(*str);
      str++;
   }
   return saveStr;
}   


char* dStrchr(char *str, int c)
{
   return strchr(str,c);
}   


const char* dStrchr(const char *str, int c)
{
   return strchr(str,c);
}   

const char* dStrrchr(const char *str, int c)
{
   return strrchr(str,c);
}   


char* dStrrchr(char *str, int c)
{
   return strrchr(str,c);
}   

dsize_t dStrspn(const char *str, const char *set)
{
   return(strspn(str, set));
}

dsize_t dStrcspn(const char *str, const char *set)
{
   return strcspn(str, set);
}   


char* dStrstr(char *str1, char *str2)
{
   return strstr(str1,str2);
}

char* dStrstr(const char *str1, const char *str2)
{
   return strstr(str1,str2);
}   

char* dStrtok(char *str, const char *sep)
{
   return strtok(str, sep);
}


int dAtoi(const char *str)
{
   return atoi(str);   
}  

 
float dAtof(const char *str)
{
   return atof(str);   
}   

bool dAtob(const char *str)
{
   return !dStricmp(str, "true") || !dStricmp(str, "1") || (0!=dAtoi(str));
}   

bool dIsalnum(const char c)
{
   return isalnum(c);
}

bool dIsalpha(const char c)
{
   return(isalpha(c));
}

bool dIsspace(const char c)
{
   return(isspace(c));
}

bool dIsdigit(const char c)
{
   return(isdigit(c));
}

void dPrintf(const char *format, ...)
{
   va_list args;
   va_start(args, format);
   vprintf(format, args);
}   

int dVprintf(const char *format, void *arglist)
{
   S32 len = vprintf(format, (char*)arglist);

   // to-do
   // The intended behavior is to zero-terminate and not allow the overflow
   return (len);
}   

int dSprintf(char *buffer, dsize_t /*bufferSize*/, const char *format, ...)
{
   va_list args;
   va_start(args, format);
   S32 len = vsprintf(buffer, format, args);

#warning "need to added zero-term + overflow handling"
   // to-do
   // The intended behavior is to zero-terminate and not allow the overflow
   return (len);
}   


int dVsprintf(char *buffer, dsize_t /*bufferSize*/, const char *format, void *arglist)
{
   S32 len = vsprintf(buffer, format, (char*)arglist);

#warning "need to added zero-term + overflow handling"
   // to-do
   // The intended behavior is to zero-terminate and not allow the overflow
   return (len);
}   


int dSscanf(const char *buffer, const char *format, ...)
{
   va_list args;
   va_start(args, format);
//   return __vsscanf(buffer, format, args);   
   return vsscanf(buffer, format, args);   
}   

int dFflushStdout()
{
   return fflush(stdout);
}

int dFflushStderr()
{
   return fflush(stderr);
}

void dQsort(void *base, U32 nelem, U32 width, int (QSORT_CALLBACK *fcmp)(const void *, const void *))
{
   qsort(base, nelem, width, fcmp);
}   


//---------------------------------------------------------------------------
// Mac Strinng conversion routines
U8* str2p(const char *str)
{
   static U8 buffer[256];
   str2p(str, buffer);
   return buffer;
}


U8* str2p(const char *str, U8 *p)
{
   AssertFatal(dStrlen(str) <= 255, "str2p:: Max Pascal String length exceeded (max=255).");
   U8 *dst = p+1;
   U8 *src = (U8*)str;
   *p = 0;
   while(*src != '\0')
   {
      *dst++ = *src++;
      (*p) += 1;
   }
   return p;
}


char* p2str(U8 *p)
{
   static char buffer[256];
   p2str(p, buffer);
   return buffer;
}


char* p2str(U8 *p, char *dst_str)
{
   U8 len = *p++;
   char *src = (char*)p;
   char *dst = dst_str;
   while (len--)
   {
      *dst++ = *src++;
   }
   *dst = '\0';
   return dst_str;
}

//------------------------------------------------------------------------------
// Unicode string conversions
//------------------------------------------------------------------------------
/*UTF8 * convertUTF16toUTF8(const UTF16 *string, UTF8 *buffer, U32 bufsize)
{
   PROFILE_START(convertUTF16toUTF8);
   // use a CFString to convert the unicode string.
   // CFStrings use a UTF16 based backing store.
   // the last kCFAllocatorNull parameter is a deallocator for the string passed in.
   //  we pass the Null allocator so that string will not be klobbered.
   // note: on 10.4+, another constant, kCFStringEncodingUTF16 is available, and
   //  it is an alias for kCFStringEncodingUnicode.
   //  see: http://developer.apple.com/documentation/CoreFoundation/Reference/CFStringRef/Reference/chapter_2.2_section_1.html 
   bool        ok;
   CFStringRef cfstr;
   
   U32 len = dStrlen(string);
   cfstr = CFStringCreateWithCharacters( kCFAllocatorDefault, string, len);
   //cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (const char*)string, kCFStringEncodingUnicode);
   AssertFatal(cfstr != NULL, "Unicode string conversion failed - couldn't make the CFString!");

   ok = CFStringGetCString( cfstr, (char*)buffer, bufsize, kCFStringEncodingUTF8);
   CFRelease(cfstr);
   
   AssertWarn( ok, "Unicode string conversion failed in convertUTF16toUTF8()");
   if( !ok ) {
      PROFILE_END();
      return NULL;
   }
      
   buffer[bufsize-1] = 0x00;
   
   PROFILE_END();
   return buffer;
}


//------------------------------------------------------------------------------
UTF16 * convertUTF8toUTF16(const UTF8 *string, UTF16 *buffer, U32 bufsize)
{
   // see above notes in convertUTF16toUTF8() for an explanation of the following.
   // what we do here is exactly the same process as above, but in reverse.
   PROFILE_START(convertUTF8toUTF16);
   bool        ok;
   CFStringRef cfstr;   
   if( !string || string[0] == '\0' )
      goto returnNull;
      
   cfstr = CFStringCreateWithCString(kCFAllocatorDefault, (char*)string, kCFStringEncodingUTF8);
   if(!cfstr)
      goto returnNull;
   
   ok = CFStringGetCString( cfstr, (char*)buffer, bufsize*sizeof(UTF16), kCFStringEncodingUnicode);
   CFRelease(cfstr);
   
   AssertWarn( ok, "Unicode string conversion failed or buffer was too small in convertUTF8toUTF16()");
   if( !ok )
      goto returnNull;
         
   buffer[bufsize-1] = 0x000;

   PROFILE_END();
   return buffer;

returnNull:
   PROFILE_END();
   return NULL;
}
*/