#include "UtilityCommon.h"
#include "../ProgramCommon/Define.h"
#include "SolarFileReader.h"
#include ".\TextFilter.h"
#ifdef _APPLY_NHN_FILTERFING
	#include "IAF_Export.h"
#endif//_APPLY_NHN_FILTERFING

namespace util {
;

struct TextTempBuffer;
struct TextTempBufferStack
{
    static const int kMaxDepths = 4;
    struct Buffer
    {
        Buffer()
            : text_length_(0),
              text_buffer_(NULL)
        {
        }
        ~Buffer()
        {
            if (text_buffer_)
            {
                delete [] text_buffer_;
                text_buffer_ = NULL;
            }
        }
        void Resize(size_t text_length)
        {
            if (text_length_ < text_length) {
                if (text_buffer_) {
                    delete [] text_buffer_;
                }
                text_length_ = text_length;
                text_buffer_ = new char[text_length_];
            }
        }

        //
        size_t text_length_;
        char* text_buffer_;
    private:
        __DISABLE_COPY(Buffer);
    };

    TextTempBufferStack()
        : depth_(0)
    {
    }
    ~TextTempBufferStack()
    {
    }

    Buffer* Push(size_t text_length)
    {
        if (depth_ >= _countof(buffers_)) {
            __debugbreak();
            return NULL;
        }
        Buffer* buffer = &buffers_[depth_++];
        buffer->Resize(text_length);
        return buffer;
    }

    void Pop()
    {
        if (depth_ <= 0) {
            __debugbreak();
            return;
        }
        --depth_;
    }

    int depth_;
    Buffer buffers_[kMaxDepths];
};

struct TextBufferTransaction
{
    TextBufferTransaction(TextTempBufferStack* buffer_stack, size_t text_length)
        : buffer_stack_(buffer_stack)
    {
        buffer_ = buffer_stack_->Push(text_length);
    }
    ~TextBufferTransaction()
    {
        buffer_stack_->Pop();
    }
    TextTempBufferStack::Buffer* buffer_;
    TextTempBufferStack* const buffer_stack_;
private:
    __DISABLE_COPY(TextBufferTransaction);
};

static TextTempBufferStack text_temp_buffer_stack_static_;

}; //end of namespace

#define	ISHANGUL(ch)	((ch) & 0x80)

ITextFilter::ITextFilter()
{
	Initialize();
	SetNationType();

    length_replace_string_ = 0;
    replace_string_ = NULL;
    replace_type_ = KReplace_By_Character;
    check_type_ = kCheckSubString;
}

ITextFilter::~ITextFilter()
{
	Release();

    length_replace_string_ = 0;
    SAFE_DELETE_ARRAY(replace_string_);
}

bool ITextFilter::CheckIncludeStringChina(const char * Text)
{
#ifdef _APPLY_NHN_FILTERFING
	//no operation
#else
	for ( unsigned char *lpszCheck = ( unsigned char*)Text; *lpszCheck; ++lpszCheck)
	{
		if ( 1 == _mbclen( lpszCheck))
		{	// ÇÑ ¹ÙÀÌÆ®
			if ( *lpszCheck < 0x21 || *lpszCheck > 0x7E)
			{
				return ( true);
			}
		}
		else
		{	// µÎ ¹ÙÀÌÆ®
			unsigned char *lpszTrail = lpszCheck + 1;
			if ( 0xB0 <= *lpszCheck && *lpszCheck <= 0xF7)
			{	// ÇÑÀÚ
				if ( 0xA1 <= *lpszTrail && *lpszTrail <= 0xFE)
				{	// ÇÑÀÚÀÓ
					if ( *lpszCheck == 0xD7 && 0xFA <= *lpszTrail)
					{	// ÀϺΠ¾ÈµÇ´Â Ư¼ö¹®ÀÚ
						return ( true);
					}
				}
				else
				{
					return ( true);
				}
			}
			else
			{
				return ( true);
			}

			++lpszCheck;
		}
	}
#endif//_APPLY_NHN_FILTERFING
	return false;
}
bool ITextFilter::CheckIncludeStringTaiwan(const char * Text)
{
#ifdef _APPLY_NHN_FILTERFING
	//no operation
#else
	for ( unsigned char *lpszCheck = ( unsigned char*)Text; *lpszCheck; ++lpszCheck)
	{
		if ( 1 == _mbclen( lpszCheck))
		{	// ÇÑ ¹ÙÀÌÆ®
			if ( *lpszCheck < 0x21 || *lpszCheck > 0x7E)
			{
				return ( true);
			}
		}
		else
		{	// µÎ ¹ÙÀÌÆ®
			unsigned char *lpszTrail = lpszCheck + 1;
			if ( 0xA4 <= *lpszCheck && *lpszCheck <= 0xF9)
			{	// ÇÑÀÚ
				if ( ( 0x40 <= *lpszTrail && *lpszTrail <= 0x7E) ||
					( 0xA1 <= *lpszTrail && *lpszTrail <= 0xFE))
				{	// ÇÑÀÚÀÓ
					if ( *lpszCheck == 0xF9 && 0xDD <= *lpszTrail)
					{	// ÀϺΠ¾ÈµÇ´Â Ư¼ö¹®ÀÚ
						return ( true);
					}
				}
				else
				{
					return ( true);
				}
			}
			else
			{
				return ( true);
			}

			++lpszCheck;
		}
	}
#endif//_APPLY_NHN_FILTERFING
	return false;
}

bool	ITextFilter::CheckIncludeStringJapan(const char * Text)
{
#ifdef _APPLY_NHN_FILTERFING
	//no operation
#else
    size_t length = strlen(Text);
    for (size_t n = 0; n < length; ++n)
    {
        unsigned char current_char = Text[n];
        unsigned char next_char = Text[n+1];
        switch (current_char)
        {
        case ' ' ://°ø¹é 
        case '\t' ://ÅÇÀº ¾ÈµÈ´Ù.
            return true;
        }

        if(current_char & 0x80)
        {
            if ( ((n+1) < length) &&
                (current_char == 0x81) && 
                (next_char == 0x40))
            {
                // ÇØ´ç¹®ÀÚ´Â Àü°¢¹®ÀÚÀÇ °ø¹éÀÌ´Ù. Çã¿ë¾ÈµÊ
                return true;
            }
            if (current_char >= 0xA0 && current_char <= 0xDF)
            {
                //ÀÌ¿µ¿ªÀº 2¹ÙÀÌÆ® Àü°¢ÀÌ ¾Æ´Ñ ¹Ý°¢¹®ÀÚ¿µ¿ªÀÌ´Ù. Çã¿ëÇϸç 1¹ÙÀÌÆ®¾¿ ³Ñ±ä´Ù.
                ;
            }
            else
            {
                // ±×¿Ü ÀÏ¾î ¹× ÇÑÀÚ´Â 2¹ÙÀÌÆ®
                n++;
            }
        }
        else if(isdigit(current_char))//¼ýÀÚ¸é 
        {
            ;
        }
        else if(isalpha(current_char))//¿µ¹®À̸é
        {
            ;
        }
        else //±âŸ 
        {
            return true;
        }
    }
#endif//_APPLY_NHN_FILTERFING
	return false;
}

bool ITextFilter::CheckIncludeStringRussia(const char * Text)
{
    const int kEnglishType = 0;
    const int kRussianType = 1;
    const int kMaxCheckSet = 1;

    STLX_SET<int> type_check_set;

    size_t string_lenth = strlen(Text);
    for (size_t index = 0 ; index < string_lenth; ++index)
    {
        // ÇѹÙÀÌÆ®¾¿ ¼øȸÇÏ¸ç ¹®ÀÚüũ
        switch (Text[index])
        {
        case ' ' ://°ø¹é 
        case '\t' ://ÅÇÀº ¾ÈµÈ´Ù.
            return true;
        }

        if (Text[index] & 0x80) // ·¯½Ã¾Æ¹®ÀÚ Ç¥½Ã
        {
            // ·¯½Ã¾Æ ¹®ÀÚÄÚµå ´ë¿ªÆø üũ
            unsigned char temp_char = Text[index];
            if (((temp_char >= 0xC0) && (temp_char <= 0xFF)) || 
                (temp_char == 0xA8) || 
                (temp_char == 0xB8))
            {
                type_check_set.insert(kRussianType);
            }
            else
            {
                // Çã¿ëÇÏÁö ¾Ê´Â ¹®ÀÚ ¹× ±âÈ£
                return true;
            }
        }
        else if(isdigit(Text[index]))
        {
            //¼ýÀÚ¸é Åë°ú
        }
        else if(isalpha(Text[index]))
        {
            //¿µ¹®À̸é Åë°ú
            type_check_set.insert(kEnglishType);
        }
        else
        {
            // ±âŸ ¹®ÀÚÀÇ °æ¿ì Çã¿ëÇÏÁö ¾ÊÀ½
            return true;
        }

        if (type_check_set.size() > kMaxCheckSet)
        {
            // ÇØ´ç »çÇ×ÀÇ °æ¿ì ¿µ¾î¿Í ·¯½Ã¾Æ¹®ÀÚÀÇ È¥¿ëµÈ ¹®ÀÚ¿­ÀÌ´Ù.
            // ·¯½Ã¾Æ ÇöÁö ¿ä«Š¿¡ ÀÇÇؼ­ ÇØ´ç »çÇ×Àº Çã¿ëÇÏÁö ¾ÊÀ½
            return true;
        }
    }
    return false;
}

bool  ITextFilter::CheckIncludeString(const char *szSrc)
{

#ifdef _APPLY_NHN_FILTERFING
		//no operation
#else
	for (int n = 0; n < (signed)strlen(szSrc); n++)
	{
		switch (szSrc[n])
		{
		case ' ' ://°ø¹é 
		case '\t' ://ÅÇÀº ¾ÈµÈ´Ù.
			return true;
		}

		if(szSrc[n]& 0x80)
		{

			unsigned char	cBuf1=		szSrc[n];
			unsigned char	cBuf2=		szSrc[n+1];
			unsigned short	wBuf=		(unsigned short)cBuf1<<8 | cBuf2;

            // 2¹ÙÀÌÆ®¹®ÀÚ´Â Çѱ۸¸ Çã¿ë [11/2/2010 iforall]
			if(wBuf >= 0xB0A1  &&  wBuf <= 0xC8FE)	//ÇÑ±Û 	
			{
				n++;
			}
            else
            {
                return true;
            }
			//else if(wBuf >= 0xCAA1  &&  wBuf <= 0xFDFE) //ÇÑÀÚ 
			//{
			//	return true;
			//}
			//else if(wBuf >= 0xA1A1  &&  wBuf <= 0xACFE) //2¹ÙÀÌÆ® Ư¼ö ¹®ÀÚ
			//{
			//	return true;
			//}
			//n++;
		}
		else if(isdigit(szSrc[n]))//¼ýÀÚ¸é 
		{
			;
		}
		else if(isalpha(szSrc[n]))//¿µ¹®À̸é
		{
			;
		}
		else //±âŸ 
		{
			return true;
		}
	}

#endif//_APPLY_NHN_FILTERFING
	return false;
}
//*****************************************************************************
//	¹®ÀÚ¿­¿¡¼­ white space¿Í tab À» Áö¿ì°í ¹®ÀÚ¸¸ ³²±ä´Ù.
//
//	Paremeters
//		char *szDest	: trim ½ÃŲ ³»¿ëÀ» ´ãÀ» Æ÷ÀÎÅÍ
//		char *szSrc		: trim ½Ãų ¹®ÀÚ¿­
//	Return Values
//		void
//	Remark
//		»èÁ¦ ´ë»ó : ' ' '\t' '\n' '\"'
//*****************************************************************************
void	ITextFilter::Trim(char *szDest, const char *szSrc)
{
    const size_t length = strlen(szSrc);
    size_t i = 0, n = 0;
    for (; n < length; ++n)
	{
		switch (szSrc[n])
		{
		case ' ' :
		case '\t' :
		case '\n' :
		//case '\"' :
			break;

		default :
			szDest[i] = szSrc[n];
			i++;
			break;
		}
	}
	szDest[i] = '\0';
}


//*****************************************************************************
//	¹®ÀÚ¿­¿¡¼­ ƯÁ¤ ±æÀ̸¸Å­¸¸ Àß¶ó³½ ½ºÆ®¸µÀ» ¸¸µç´Ù.
//
//	Paremeters
//		char *szDest	: Àß¶ó³½ ½ºÆ®¸µÀ» ´ãÀ» Æ÷ÀÎÅÍ
//		char *szSrc		: Àß¶ó³¾ ¹®ÀÚ¿­
//		int nLength		: Àß¶ó³¾ ±æÀÌ
//	Return Values
//		void
//	Remark
//		strncpy + ³Î¹®ÀÚ ³Ö±â ÀÇ ±â´É.
//		¸¸ÀÏ szSrcÀÇ ±æÀÌ°¡ nLengthº¸´Ù ÀÛÀ¸¸é szSrcÀÇ ±æÀ̸¸Å­ º¹»çÇÑ´Ù.
//*****************************************************************************
void	ITextFilter::GetStringPart(char *szDest, const char *szSrc, int nLength)
{
	if (strlen(szSrc) <= (size_t)nLength)
		strcpy(szDest, szSrc);
	else
	{
		memcpy(szDest, szSrc, nLength);
		szDest[nLength] = '\0';
	}
}

//*****************************************************************************
//	ÇÑ ¹®ÀÚ¿­¿¡¼­ ƯÁ¤ ¹®ÀÚ¿­ÀÇ À§Ä¡¸¦ ã¾Æ³½´Ù.
//
//	Paremeters
//		char *szStr		: °Ë»öÇÒ ¹®ÀÚ¿­ (ex : ABCDEFG)
//		char *szCharSet	: ã´Â ´ë»ó		(ex : EF)
//	Return Values
//		char*			: szChatSetÀÇ À§Ä¡ Æ÷ÀÎÅÍ. ¾øÀ¸¸é NULL.
//	Remark
//		strstr°ú ±â´É°ú »ç¿ë¹ýÀÌ °°À¸³ª ÇÑ±Û findÀÇ ¹®Á¦Á¡À» ÇØ°á
//*****************************************************************************
char* ITextFilter::FindString(char* szStr, const char* szCharSet )
{
    const size_t string_length = _tcslen(szStr);
    const size_t charset_length = _tcslen(szCharSet);
    if (string_length < charset_length) {
        return NULL;
    }
    util::TextBufferTransaction transaction(&util::text_temp_buffer_stack_static_,
                                            charset_length + 1);
    char* const l_szStr = transaction.buffer_->text_buffer_;

    for (size_t n = 0; n < string_length - charset_length + 1;)
    {
        memset(l_szStr, 0, charset_length + 1);
        GetStringPart(l_szStr, szStr + n, int(charset_length));

        if (m_NationType == FILTER_JAPAN ||
            m_NationType == FILTER_CHINA ||
            m_NationType == FILTER_TAIWAN) //Áß±¹µµ Àû¿ë
        {
            // lammy Àӽà ¼öÁ¤ : ÀϺ»¾î OS¿¡¼­ 0x8152 °ú 0x815bÀ» °°´Ù°í ó¸® ÇÏ´Â °æ¿ì°¡ ÀÖ´Ù.
            if (_tcscmp(l_szStr, szCharSet) == 0) {
                return szStr + n;
            }
        }
        else
        {
            if (CSTR_EQUAL == CompareString(m_lcid, NORM_IGNORECASE,
                                            l_szStr, int(_tcslen(l_szStr)),
                                            szCharSet, int(_tcslen(szCharSet))))
            {
                return szStr + n;
            }
        }

        if (ISHANGUL(szStr[n])) {
            n += 2;
        }
        else {
            ++n;
        }
    }

    return NULL;
}

char* ITextFilter::FindStringUseWildCard(char *szStr, const char *szCharSet, size_t iCharSetIndex)
{
    SlangTextInfo* wild_card_info = &(slang_text_info_list_[iCharSetIndex]);
    const size_t string_length = _tcslen(szStr);
    const size_t charset_length = _tcslen(szCharSet);
    if (string_length < charset_length)
    {
        return NULL;
    }
    util::TextBufferTransaction transaction(&util::text_temp_buffer_stack_static_,
        charset_length + 1);
    char* const l_szStr = transaction.buffer_->text_buffer_;

    const bool pre_wild_card = wild_card_info->pre_wild_card_;
    const bool post_wild_card = wild_card_info->post_wild_card_;

    // pre_wild_card ¿¡ µû¶ó ½ÃÀÛ À妽º °íÁ¤ ¹× ·çÇÁ ¼³Á¤
    // pst wild_card ¿¡ µû¶ó ´õ ¼øȸ°¡ ³²¾Æ ÀÖ´ÂÁö üũ
    size_t loop_count = (pre_wild_card == true) ? (string_length - charset_length + 1) : 1;
    for (size_t check_index = 0; check_index < loop_count; )
    {
        memset(l_szStr, 0, charset_length + 1);
        GetStringPart(l_szStr, szStr + check_index, int(charset_length));

        if (m_NationType == FILTER_JAPAN ||
            m_NationType == FILTER_CHINA ||
            m_NationType == FILTER_TAIWAN) //Áß±¹µµ Àû¿ë
        {
            // lammy Àӽà ¼öÁ¤ : ÀϺ»¾î OS¿¡¼­ 0x8152 °ú 0x815bÀ» °°´Ù°í ó¸® ÇÏ´Â °æ¿ì°¡ ÀÖ´Ù.
            if (_tcscmp(l_szStr, szCharSet) == 0)
            {
                if ((post_wild_card == true) || 
                    ((post_wild_card == false) && (szStr[check_index + charset_length] == '\0')))
                {
                    return szStr + check_index;
                }
            }
        }
        else
        {
            if (CSTR_EQUAL == CompareString(m_lcid, NORM_IGNORECASE,
                l_szStr, int(_tcslen(l_szStr)),
                szCharSet, int(_tcslen(szCharSet))))
            {
                if ((post_wild_card == true) || 
                    ((post_wild_card == false) && (szStr[check_index + charset_length] == '\0')))
                {
                    return szStr + check_index;
                }
            }
        }

        if (ISHANGUL(szStr[check_index])) {
            check_index += 2;
        }
        else {
            ++check_index;
        }
    }

    return NULL;
}

void ITextFilter::SetNationType( FILTER_NATION_TYPE Type )
{
	m_NationType = Type;

	switch( Type )
	{
	case FILTER_DEFAULT:
        m_lcid = MAKELCID( MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT ), SORT_DEFAULT );
        break;
	case FILTER_KOREA:
        m_lcid = MAKELCID( MAKELANGID( LANG_KOREAN, SUBLANG_DEFAULT ), SORT_DEFAULT );
        break;
	case FILTER_TAIWAN:
		m_lcid = MAKELCID( MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ), SORT_DEFAULT );
		break;

	case FILTER_CHINA:
		m_lcid = MAKELCID( MAKELANGID( LANG_CHINESE, SUBLANG_DEFAULT ), SORT_DEFAULT );
		break;
	case FILTER_JAPAN:
		m_lcid = MAKELCID( MAKELANGID( LANG_JAPANESE, SUBLANG_DEFAULT ), SORT_DEFAULT );
		break;
    case FILTER_RUSSIA:
        m_lcid = MAKELCID( MAKELANGID( LANG_RUSSIAN, SUBLANG_DEFAULT ), SORT_DEFAULT );
        break;
	}

}

void ITextFilter::SetReplaceString(const char* replace_string, FILTER_REPLACE_TYPE replace_type)
{
    if (replace_string == NULL)
    {
        length_replace_string_ = 0;
        SAFE_DELETE_ARRAY(replace_string_);
        replace_type_ = KReplace_By_Character;
    }

    length_replace_string_ = int(strlen(replace_string));
    SAFE_DELETE_ARRAY(replace_string_);
    replace_string_ = new char[length_replace_string_ + 1];
    strncpy(replace_string_, replace_string, length_replace_string_);
    replace_string_[length_replace_string_] = '\0';
    
    replace_type_ = replace_type;
}

//------------------------------------------------------------------------------
/** ÇÊÅ͸µ
*/
bool ITextFilter::IsHaveReplace(char* szSrc, char* szDest, int nDestSize) 
{
    __UNUSED(szDest); __UNUSED(nDestSize); // (WAVERIX) (090722) (ADD-IN)

#ifdef _GS_ADD_KEY_FILTERING
    if(!m_bNameFilter)
    {
        char* char_name = szSrc;
        for(const char* it = char_name; *it; ++it)
        {
            char chr = *it;
            if((chr<0 || chr>127))
            {
                //Å°º¸µåÇÊÅ͸µ(ÇѱÛorƯ¼ö¹®ÀÚ)°¡ µé¾îÀÖ´Ù..
                return true;
            }
        }
    }
#endif//_GS_ADD_KEY_FILTERING(Å°º¸µåÇÊÅ͸µ)

#ifdef _APPLY_NHN_FILTERFING
	//============================
	// NHN ÇÊÅ͸µ(IAF)»ç¿ë
	//============================
	int nRet = 0;
	if(!szDest)
	{
		char szTemp[1024];
		nRet = IAF::Filtering(szSrc,szTemp,sizeof(szTemp),(IAF::_enOption)m_bNameFilter);
	}
	else
	{	
		nRet = IAF::Filtering(szSrc,szDest,nDestSize,(IAF::_enOption)m_bNameFilter);
	}
#ifdef _DEBUG
	switch(nRet)
	{
	case -1: assert(!"szSrcÀÌ szDestº¸´Ù Å©´Ù"); break;
	case -2: assert(!"!¾Ë¼ö¾ø´Â¿¡·¯");			 break;
	}
#endif//_DEBUG
	return (nRet==1) ? (TRUE):(FALSE);
	
#else//_APPLY_NHN_FILTERFING
	//============================
	// NHN ÇÊÅ͸µ(IAF)¹Ì»ç¿ë
	//============================
    int length_replace = 0;
    char* replace_position = NULL;
    replace_position = GetReplaceTarget(&length_replace, szSrc);
    if (szDest == NULL || nDestSize < 1)
    {
        return (replace_position != NULL) ? true : false;
    }
    if (replace_position != NULL && length_replace != 0)
    {
        // ´ëÄ¡ÇÏÀÚ
        int source_length = int(strlen(szSrc));
        int replaced_count = 0;
        int dest_position = 0;
        char temp_charater = 0;
        for (int index = 0; index < source_length; ++index)
        {
            if ((replaced_count < length_replace) &&
                (&(szSrc[index]) == &(replace_position[replaced_count])))
            {
                // dest ±æÀÌ ÃÊ°ú½Ã ¸®ÅÏ
                if (dest_position >= nDestSize)
                {
                    szDest[dest_position-1] = '\0';
                    return true;
                }

                temp_charater = replace_position[replaced_count];
                if (temp_charater != ' ' &&
                    temp_charater != '\t' &&
                    temp_charater != '\n')
                {
                    for (int index_replace_string = 0;
                         index_replace_string < length_replace_string_;
                         ++index_replace_string)
                    {
                        szDest[dest_position] = replace_string_[index_replace_string];
                        ++dest_position;
                    }
                }
                else
                {
                    szDest[dest_position] = szSrc[index];
                    ++dest_position;
                }
                switch (replace_type_)
                {
                case KReplace_By_Character:
                    {
                        ++replaced_count;
                    }                    
                    break;
                case KReplace_By_Word:
                    {
                        replaced_count = length_replace;
                        index += (length_replace - 1);
                    }
                    break;
                }                
            }
            else
            {
                szDest[dest_position] = szSrc[index];
                ++dest_position;
            }            
        }
        return true;
    }
    return false;
#endif//_APPLY_NHN_FILTERFING(NHN ÇÊÅ͸µ)

}

//*****************************************************************************
//	µ¥ÀÌÅ͸¦ ÃʱâÈ­ÇÑ´Ù.
//
//	Paremeters
//		const char *szFName	: ºÒ·¯¿Ã ÆÄÀÏ À̸§
//	Return Values
//		void
//	Remark
//*****************************************************************************
void	CNSlangTextFilter::Clear()
{
    slang_text_info_list_.clear();
}

//*****************************************************************************
//	¿å DATA ÆÄÀÏÀ» ºÒ·¯¿Â´Ù.
//
//	Paremeters
//		const char *szFName	: ºÒ·¯¿Ã ÆÄÀÏ À̸§
//	Return Values
//		void
//	Remark
//*****************************************************************************
HRESULT	CNSlangTextFilter::Load(const char *szFName,bool bNameFilter)
{
	m_bNameFilter = bNameFilter;

	FILE *pFile = fopen(szFName, "r");
	if (pFile == NULL)
		return false;

	char l_szStr[1024];

    slang_text_info_list_.clear();

    STLX_STRING slang_full_text;
    STLX_STRING slang_text;

    int slang_text_index;
    int first_wild_index;
    int last_wild_index;
    bool pre_wild_card;
    bool post_wild_card;
    int slang_text_length;

	fseek(pFile, 0, 0);
	while (fgets(l_szStr, 1023, pFile) != NULL)
	{
		Trim(l_szStr, l_szStr);
		if (l_szStr[0] != '/' && l_szStr[1] != '/' &&strlen(l_szStr) != 0)
		{
			{
                slang_full_text = l_szStr;

                if (check_type_ == kCheckSubString)
                {
                    pre_wild_card = true;
                    post_wild_card = true;
                    slang_text = slang_full_text;
                }
                else
                {
                    slang_text_index = (int)slang_full_text.find_first_not_of('*');
                    first_wild_index = (int)slang_full_text.find_first_of('*');
                    last_wild_index = (int)slang_full_text.find_last_of('*');
                    pre_wild_card = (first_wild_index < slang_text_index) && (first_wild_index != -1);
                    post_wild_card = last_wild_index > slang_text_index;
                    slang_text_length = (int)(post_wild_card ? last_wild_index - slang_text_index : slang_full_text.length() - slang_text_index);
                    slang_text = slang_full_text.substr(slang_text_index, slang_text_length);
                }

                slang_text_info_list_.push_back(SlangTextInfo(slang_text, pre_wild_card, post_wild_card));
			}
		}
	}
	fclose(pFile);
	return true;
}

//*****************************************************************************
//	¿å DATA ÆÄÀÏÀ» ÆÑÆÄÀÏ¿¡¼­ ºÒ·¯¿Â´Ù.
//
//	Paremeters
//		const char *szFName	: ºÒ·¯¿Ã ÆÄÀÏ À̸§
//	Return Values
//		void
//	Remark
//*****************************************************************************

HRESULT	CNSlangTextFilter::LoadFromPack(const char *szFName,bool bNameFilter)
{
	m_bNameFilter = bNameFilter;

	util::SolarFileReader sr;

	BOOL bResult = sr.OpenFileFromPack("Data\\Resource.wpk", szFName, SEPERATOR_ONLY_NEWLINE);
	if(!bResult)
		return FALSE;

	char pToken[SLANG_LENGTH_MAX];

    slang_text_info_list_.clear();

    STLX_STRING slang_full_text;
    STLX_STRING slang_text;

    int slang_text_index;
    int first_wild_index;
    int last_wild_index;
    bool pre_wild_card;
    bool post_wild_card;
    int slang_text_length;

	eTOKEN_TYPE ettType;
	while (true)
	{
		ettType = sr.GetNextTokenType( TOKEN_STRING );
        if (ettType == TOKEN_END)
        {
            break;
        }
		strncpy( pToken, sr.GetTokenString(), SLANG_LENGTH_MAX );

        slang_full_text = pToken;

        if (check_type_ == kCheckSubString)
        {
            pre_wild_card = true;
            post_wild_card = true;
            slang_text = slang_full_text;
        }
        else
        {
            slang_text_index = (int)slang_full_text.find_first_not_of('*');
            first_wild_index = (int)slang_full_text.find_first_of('*');
            last_wild_index = (int)slang_full_text.find_last_of('*');
            pre_wild_card = (first_wild_index < slang_text_index) && (first_wild_index != -1);
            post_wild_card = last_wild_index > slang_text_index;
            slang_text_length = (int)(post_wild_card ? last_wild_index - slang_text_index : slang_full_text.length() - slang_text_index);
            slang_text = slang_full_text.substr(slang_text_index, slang_text_length);
        }

        slang_text_info_list_.push_back(SlangTextInfo(slang_text, pre_wild_card, post_wild_card));
	}

	sr.CloseFile();

	return TRUE;
}

//*****************************************************************************
//	LOAD¿¡¼­ ºÎ¸¥ dataµéÀ» Æı«½ÃŲ´Ù.
//
//	Paremeters
//		void
//	Return Values
//		void
//	Remark
//*****************************************************************************
HRESULT	CNSlangTextFilter::Destroy()
{
	if (!IsInit())
		return false;

	m_xInit = false;
    Clear();
	return true;
}

//*****************************************************************************
//	¼Ò½º¿¡¼­ ġȯÇÒ ´ë»óÀ» ã¾Æ³½´Ù.
//
//	Paremeters
//		int *nLength		: ġȯ ´ë»óÀÇ ±æÀ̸¦ ¹ÞÀ» Æ÷ÀÎÅÍ
//		const char *szSrc	: ġȯ ´ë»óÀ» ãÀ» ¹®ÀÚ¿­
//	Return Values
//		char*				: ġȯ ´ë»óÀÇ À§Ä¡
//	Remark
//		ġȯ ´ë»óÀÌ ¾øÀ¸¸é nLength¿¡´Â 0ÀÌ µé¾î°¡°í NULLÀÌ ¹ÝȯµÈ´Ù.
//*****************************************************************************
char*	CNSlangTextFilter::GetReplaceTarget(int *nLength, char *szSrc)
{
	if (!IsInit())
		return NULL;
    util::TextBufferTransaction transaction(&util::text_temp_buffer_stack_static_,
                                            _tcslen(szSrc) + 1);
    char* const l_szStr = transaction.buffer_->text_buffer_;

    const char* slang_text = NULL;
    char* target_text = NULL;
    size_t slang_info_num = slang_text_info_list_.size();

	Trim(l_szStr, szSrc);
	for (size_t n = 0; n < slang_info_num; n++)
	{
        slang_text = slang_text_info_list_[n].slang_text_.c_str();
        target_text = FindStringUseWildCard(l_szStr, slang_text, n);

		if (target_text != NULL)
		{
			int l_nTargetPos = static_cast<int>(target_text - l_szStr);
			int l_nOffsetSpaceNumber = 0, l_nTargetSpaceNumber = 0;
            int l_nOffset = 0;
            int i = 0;
			for (; ; i++)
			{
				if (szSrc[i] == ' ' || szSrc[i] == '\t' || szSrc[i] == '\n')
					l_nOffsetSpaceNumber++;
				else
				{
					if (l_nOffset >= l_nTargetPos)
						break;
					l_nOffset++;
				}
			}
            const int slang_target_length = static_cast<int>(strlen(slang_text));
			for (l_nOffset = 0; l_nOffset < slang_target_length; ++i)
			{
				if (szSrc[i] == ' ' || szSrc[i] == '\t' || szSrc[i] == '\n')
					l_nTargetSpaceNumber++;
				else
					l_nOffset++;
			}

			if (nLength != NULL)
				*nLength = slang_target_length + l_nTargetSpaceNumber;

			return (szSrc + l_nTargetPos + l_nOffsetSpaceNumber);
		}
	}
	return NULL;
}