#include "convert_uni_and_utf.h"

/****************** unicode를 utf로 변환시키는 부분 시작 *****************/
// UTF-8이나 UTF-7로 변환할 배열의 앞 3바이트에 0xEF, 0xBB, 0xBF를 넣기
// UTF-8이나 UTF-7로 변환됐을때 필요한 부분 같음
unsigned char * init_utf(unsigned char *q, int i)
{
	memset(q, 0x00, i*2);

	*q = 0xEF;
	*(q + 1) = 0xBB;
	*(q + 2) = 0xBF;

	q += 3;

	return q;
}

// UNICODE가 little endian 인지 big endian인지 확인
int confirm_unicode(unsigned char *p)
{
	if( (*p == 0xFF) && (*(p+1) == 0xFE) )
		return LITTLE_ENDIAN;
	else 
		return BIG_ENDIAN;
}

// p에 있는 2바이트를 합해서 하나의 unsigned char 를 리턴
// 이때 flag로 little_endian인지 big-endian인지 확인해서 합하기.
unsigned short make_syllable(unsigned char *p, int flag)
{
	int k;
	if( flag == LITTLE_ENDIAN ) {
		k = ((unsigned short)*(p+1) << 8);
		k = k | (unsigned short)*p;
	}
	else {
		k = ((unsigned short)*p << 8);
		k = k | (unsigned short)*(p+1);
	}

	return k;
}

// k의 영역을 확인(Unicode의 영역에 따라서 utf로 변환기 달라짐)해서 q에 넣기
int make_utf(unsigned char *q, unsigned short k, int flag)
{
	// unicode가
	// 0x0000이면서 변환 방식이 UTF-7인 경우
	if( (flag == UTF_7) && (k == 0x0000) ) {
		*q = *q | 0xC0;
		*q = *q | (unsigned char)((k & 0x07C0) >> 6);
		
		*(q+1) = *(q+1) | 0x80;
		*(q+1) = *(q+1) | (unsigned char)(k & 0x003F);
		
		return CONVERT_TWO;
	}
	// 0x0000이면서 변환 방식이 UTF-8인 경우
	else if( (flag == UTF_8) && (k == 0x0000) ) {
		*q = (unsigned char)k;
		return CONVERT_ONE;
	}
	// 0x0001부터 0x007F까지
	else if( (k > 0x0000) && (k <= 0x007F) ) {
		*q = (unsigned char)k;
		return CONVERT_ONE;
	}
	// 0x0081부터 0x07FF까지
	else if( (k >= 0x0080) && (k <= 0x07FF) ) {
		*q = *q | 0xC0;
		*q = *q | (unsigned char)((k & 0x07C0) >> 6);
		
		*(q+1) = *(q+1) | 0x80;
		*(q+1) = *(q+1) | (unsigned char)(k & 0x003F);
		
		return CONVERT_TWO;
	}
	// 0x0800부터 0xFFFF까지
	else if( (k >= 0x0800) && (k <= 0xFFFF) ) {
		*q = *q | 0xE0;
		*q = *q | (unsigned char)((k & 0xF000) >> 12);
				
		*(q+1) = *(q+1) | 0x80;
		*(q+1) = *(q+1) | (unsigned char)((k & 0x0FC0) >> 6);
				
		*(q+2) = *(q+2) | 0x80;
		*(q+2) = *(q+2) | (unsigned char)(k & 0x003F);
		
		return CONVERT_THREE;
	}
	// 0x00010000 이상은 제외
	else {
	}

	return CONVERT_FAIL;
}

/*
 * int uni2utf(unsigned char *p, unsigned char *q, int, int)
 *
 * 첫번째 인수는 UNICODE가 들어 있는 unsigned char 형 배열의 주소
 * 두번째 인수는 UTF-8이 들어 갈 unsigned char 형 배열의 주소
 * 세번째 인수는 첫번째 인수의 크기(UNICODE가 들어있는 크기)
 * 네번째 인수는 변환 방식(UTF-7 or UTF-8)
 * 
 * 리턴값 : 변환된 UTF-8의 길이
 *
 */
int uni2utf(unsigned char *unicode, unsigned char *utf, int i, int flag)
{
	int t, j;

	unsigned char *p, *q;
	unsigned short k;
	
	p = unicode;
	q = utf;

	q = init_utf(q, i);

	// a -> 61 00
	if( confirm_unicode(p) == LITTLE_ENDIAN) {
		for(t = 2; t < i; t += 2) {
			k = make_syllable((p+t), LITTLE_ENDIAN);
			j = make_utf(q, k, flag);
			q += j;
		}
	}
	// a -> 00 61
	else {
		for(t = 2; t < i; t += 2) {
			k = make_syllable((p+t), BIG_ENDIAN);
			j = make_utf(q, k, flag);
			q += j;
		}
	}

	return q-utf;
}
/****************** unicode를 utf로 변환시키는 부분 끝 *****************/



/****************** utf를 unicode로 변환시키는 부분 시작 *****************/

// unicode로 변환할 배열의 앞 2바이트에 0xFF, 0xFE를 넣기
// 0xFE, 0xFF를 넣을 수도 있지만, 이렇게 넣으면 big-endian 방식임
unsigned char * init_uni(unsigned char *q, int i)
{
	memset(q, 0x00, i*2);

	*q = 0xFF;
	*(q + 1) = 0xFE;

	q += 2;
	
	return q;
}

// utf-8의 맨 앞 3바이트에 0xEF, 0xBB, 0xBF 가 있는 것 같음
// 있으면 3바이트를 제외
unsigned char * confirm_utf(unsigned char *p, int *i)
{
	if( (*p == 0xEF) && (*(p + 1) == 0xBB) && (*(p + 2) == 0xBF) ) {
		p += 3;
		*i -= 3;
	}

	return p;
}

/*
 * int utf2uni(unsigned *, unsigned *, int)
 *
 * 첫번째 인수는 UTF-8이 들어 있는 unsigned char 형 배열의 주소
 * 두번째 인수는 변환된 UNICODE가 들어 갈 unsigned char 형 배열의 주소
 * 세번째 인수는 첫번째 인수의 크기(UNICODE가 들어있는 크기)
 *
 * 첫번째 바이트를 확인후에 1바이트나 2 ~ 3 바이트씩 처리
 *
 * 리턴값 : 변환된 UNICODE의 길이
 *
 */
int utf2uni(unsigned char *utf, unsigned char *uni, int i)
{
	int t;
	
	unsigned char *p, *q;
	unsigned char k;
	
	p = utf;
	q = uni;

	q = init_uni(q, i);

	p = confirm_utf(p, &i);
	
	for( t = 0; t < i; ) {
		// 첫 바이트를 읽어서 0x80, 0xC0, 0xE0으로 각각 & 연산해서 1바이트를 읽을 지 2~3바이트를 읽을 지 결정.
		// 단, 2 바이트를 읽어야 하는 경우 0xC0만으로 & 연산을 할 경우 3 바이트를 읽어야 하는 부분도 처리가 되므로
		// 0xE0가 아닌 경우를 포함

		// 1 바이트를 읽어야 하는 부분
		if( (*p & 0x80) == 0x00 ) {
			// 0xFE, 0xFF 방식이면 다음 두개의 문을 변경
			*q = *p;
			*(q + 1) = 0x00;
			p++;
			t += 1;
		}
		// 2 바이트를 읽어야 하는 부분
		else if( ((*p & 0xC0) == 0xC0) && ((*p & 0xE0) != 0xE0)) {
			*q = (*p & 0x1C) >> 2;
			*(q + 1) = (*p & 0x03) << 6;
			*(q + 1) = *(q + 1) | (*(p + 1) & 0x3F);

			// 0xFE, 0xFF 방식이면 필요 없음
			k = *(q + 1);
			*(q + 1) = *q;
			*q = k;
			//

			p += 2;
			t += 2;
		}
		// 3 바이트를 읽어야 하는 부분
		else if( (*p & 0xE0) == 0xE0 ) {
			*q = *p << 4;
			*q = *q | ((*(p + 1) & 0x3C) >> 2);

			*(q + 1) = (*(p + 1) & 0x03) << 6;
			*(q + 1) = *(q + 1) | (*(p + 2) & 0x3F);

			// 0xFE, 0xFF 방식이면 필요 없음
			k = *(q + 1);
			*(q + 1) = *q;
			*q = k;
			//

			p += 3;
			t += 3;
		}
		// 여기서 4 바이트 이상은 제외
		else {
		}
		q += 2;
	}

	return q-uni;
}
/****************** utf를 unicode로 변환시키는 부분 시작 *****************/


// unicode 변환과 관계 없음
long fileSize(const char *file)
{
	FILE *fp = fopen(file, "rb");
	long len;
    
	if (fp != NULL)
	{
		if (fseek(fp, 0L, 2) != -1)
			len = ftell(fp);
		fclose(fp);
	}

	return len;
}

// Unicode와 UTF-8은 windows 2000의 메모장에 있은 인코딩 방식으로
// 각각을 저장한 후에 그 것을 읽어서 테스트 한 것임.
void main()
{
	FILE *fp, *stream;
	unsigned char *buffer;
	unsigned char *tmp_buffer;
	int i, t;

	i = (int)fileSize(UNICODE_FILE);

	buffer = malloc(i);
	tmp_buffer = malloc(i*2);

	// Unicode로 된 파일을 읽을 경우 binary모드로 읽어야 함
	// 아니면 0x0D, 0x0A가 달라질 수 있음.
	fp = fopen(UNICODE_FILE, "rb");
	if(!fp) {
		printf("file open fail\n");
		return;
	}

	i = fread(buffer, sizeof(unsigned char), i, fp);

	t = uni2utf(buffer, tmp_buffer, i, UTF_8);

	fclose(fp);

	fp = fopen("tmp.txt", "wb");
	if(!fp) {
		printf("file open fail\n");
		return;
	}

	fwrite(tmp_buffer, sizeof(unsigned char), t, fp);

	free(buffer);
	free(tmp_buffer);
	fclose(fp);
	// **************** UNICODE to UTF-8 변환 부분 끝 ****************

	i = (int)fileSize(UTF_8_FILE);

	buffer = malloc(i);
	tmp_buffer = malloc(i*2);

	// Unicode로 된 파일을 읽을 경우 binary모드로 읽어야 함
	// 아니면 0x0D, 0x0A가 달라질 수 있음.
	stream = fopen(UTF_8_FILE, "rb");
	if(!stream) {
		printf("file open fail\n");
		return;
	}

	i = fread(buffer, sizeof(unsigned char), i, stream);
	
	t = utf2uni(buffer, tmp_buffer, i);

	fclose(stream);

	stream = fopen("tmp1.txt", "wb");
	if(!stream) {
		printf("file open fail\n");
		return;
	}

	fwrite(tmp_buffer, sizeof(unsigned char), t, stream);

	free(buffer);
	free(tmp_buffer);
	fclose(stream);
	// **************** UTF-8 to UNICODE 변환 부분 끝 ****************

	return;
}