/////////////////////////////////////////////////////////////////////////////// 
// Copyright (C) 2002-2016, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2016 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
///////////////////////////////////////////////////////////////////////////////


#ifndef __ODCHARCONVERTER_H__
#define __ODCHARCONVERTER_H__

#include "OdaCommon.h"
#include "OdCharMapper.h"
#include "OdArray.h"

/** \details
  
    <group TD_Namespaces>
*/
namespace OdCharConverter
{
  template <class CharType> inline bool isDigit(CharType ch)
  {
    return (ch >= '0' && ch <= '9');
  }

  template <class CharType> inline bool isHexDigit(CharType ch)
  {
    return (ch >= '0' && ch <= '9') ||
          (ch >= 'a' && ch <= 'f') ||
          (ch >= 'A' && ch <= 'F');
  }

  template <class CharType> inline bool checkDigits(const CharType* ptr, int numDigits, bool hex = true)
  {
    for (int i = 0; i < numDigits; i++)
    {
      if ( !(hex ? isHexDigit(ptr[i]) : isDigit(ptr[i])) )
      {
        return false;
      }
    }
    return true;
  }

  template <class CharType> inline char isCIForMIF(const CharType* ptr)
  {
    if (*ptr == '\\')
    {
      CharType ch2 = *++ptr;
      if (*ptr++ == '+')
      {
        if ((ch2 == 'U' || ch2 == 'u') && checkDigits(ptr, 4))
          return 'u';
        
        if ((ch2 == 'M' || ch2 == 'm') && (*ptr >= '1' && *ptr <= '5') && checkDigits(++ptr, 4))
          return 'm';
      }
    }
    return '\0';
  }

  template <class CharType> inline bool isCIF(const CharType* ptr)
  {
    if ( !ptr )
      return false;
    return (ptr[0] == '\\' && ( ptr[1] == 'U' || ptr[1] == 'u' ) && ptr[2] == '+' && 
      checkDigits(&ptr[3], 4) );
  }

  template <class CharType> inline bool isMIF(const CharType* ptr)
  {
    if ( !ptr )
      return false;
    return (ptr[0] == '\\' && ( ptr[1] == 'M' || ptr[1] == 'm' ) && ptr[2] == '+' && 
      checkDigits(&ptr[4], 4) && ptr[3] >= '1' && ptr[3] <= '5');
  }

  template <class CharType> inline unsigned int hexValue(const CharType c)
  {
    if (c >= '0' && c <= '9') return(c - '0');
    if (c >= 'A' && c <= 'F') return(c - 'A' + 10);
    if (c >= 'a' && c <= 'f') return(c - 'a' + 10);
    return(0);
  }

  inline int getMIFIndex(OdCodePageId id )
  {
    switch(id)
    {
      case CP_ANSI_932:
      case CP_DOS932:      return '1';
      case CP_ANSI_950:    
      case CP_BIG5:        return '2';
      case CP_ANSI_949:    
      case CP_KSC5601:     return '3';
      case CP_ANSI_1361:   
      case CP_JOHAB:       return '4';
      case CP_ANSI_936:    
      case CP_GB2312:      return '5';
      default:             return '0';
    }
  }

  template <class CharType> inline int getMIFString(OdChar val, OdCodePageId cp, CharType* dstBuf, int size)
  {
    if ( size < 8 )
      return 0;  
    dstBuf[0] = '\\';
    dstBuf[1] = 'M';
    dstBuf[2] = '+';
    dstBuf[3] = (CharType)getMIFIndex(cp);
    for( int i = 0; i < 4; i++ )
    {
      CharType byteVal = (CharType)(val & 0x0f);
      dstBuf[7 - i] = CharType((byteVal <= 9) ? ('0' + byteVal) : ('A' - 10 + byteVal));
      val >>= 4;
    }
    return 8;
  }

  template <class CharType> inline int getCIFString(OdUInt16 val, CharType* dstBuf, int size)
  {
    if ( size < 7 )
      return 0;  
    dstBuf[0] = '\\';
    dstBuf[1] = 'U';
    dstBuf[2] = '+';
    for( int i = 0; i < 4; i++ )
    {
      CharType byteVal = (CharType)(val & 0x0f);
      dstBuf[6 - i] = CharType((byteVal <= 9) ? ('0' + byteVal) : ('A' - 10 + byteVal));
      val >>= 4;
    }
    return 7;
  }

  template <class CharType> inline OdCodePageId getMIFCodepage(CharType cp)
  {
    switch(cp)
    {
      case '1':    return CP_ANSI_932;
      case '2':    return CP_ANSI_950;
      case '3':    return CP_ANSI_949;
      case '4':    return CP_ANSI_1361;
      case '5':    return CP_ANSI_936;
      default:     return CP_UNDEFINED;
    }
  }

  template <class CharType> inline  bool parseMIFString(CharType* srcBuf, OdChar& val, OdCodePageId& cp)
  {
    if ( !isMIF<CharType>(srcBuf) )
      return false;

    cp = getMIFCodepage(srcBuf[3]);
    val = OdChar(
        (hexValue(srcBuf[4]) << 12)
      + (hexValue(srcBuf[5]) << 8)
      + (hexValue(srcBuf[6]) << 4)
      + hexValue(srcBuf[7]));
    return true;
  }

  template <class CharType> inline bool parseCIFString(CharType* srcBuf, OdChar& val)
  {
    if ( !isCIF<CharType>(srcBuf) )
      return false;

    val = OdChar(
        (hexValue(srcBuf[3]) << 12)
      + (hexValue(srcBuf[4]) << 8)
      + (hexValue(srcBuf[5]) << 4)
      + hexValue(srcBuf[6]));
    return true;
  }

  inline bool isMBCBCodepage(OdCodePageId id)
  {
    return id == CP_ANSI_932 ||
      id == CP_ANSI_936 ||
      id == CP_ANSI_949 ||
      id == CP_ANSI_950 ||
      id == CP_ANSI_1361 ||
      id == CP_BIG5 ||
      id == CP_JOHAB ||
      id == CP_GB2312 ||
      id == CP_KSC5601 ||
      id == CP_DOS932;
  }

  inline bool isMIFCodepage(OdCodePageId id)
  {
    return isMBCBCodepage(id);
  }


  inline OdCodePageId checkTheSameCP(OdCodePageId cp)
  {
    switch (cp)
    {
      case CP_DOS932:  return CP_ANSI_932;
      case CP_BIG5:    return CP_ANSI_950;
      case CP_KSC5601: return CP_ANSI_949;
      case CP_GB2312:  return CP_ANSI_936;
      case CP_JOHAB:   return CP_ANSI_1361;
      default:break;
    }
    return cp;
  }
}

#endif // __ODCHARCONVERTER_H__