package com.eactive.eai.transformer.function.util;

import java.math.BigInteger;

import com.eactive.eai.transformer.util.IConv;

public class CodeConversion
{
	
//	public static void main(String[] args) {
//		byte[] bytes = null;
//		
//		if(args.length < 2) {
//			System.out.println("Usage : java CodeConversion [data] [cmd] ");
//			System.out.println("COMMAND : COMP, COMP3, SE, GE ");
//			System.out.println("Example : java CodeConversion 123 COMP "); 
//			return;
//		}
//		
//		try {
//			if( "COMP".equals(args[1]) ) {
//				bytes = ascToComp(args[0]);
//				
//				System.out.println("HOST COMP[" + new String(bytes)+"]");
//				System.out.println("UNIX COMP[" + compToAsc(bytes)+"]");
//			}
//			else if( "COMP3".equals(args[1]) ) {
//			
//				bytes = ascToComp3(args[0]);
//				System.out.println("HOST COMP3[" + new String(bytes)+"]");
//				System.out.println("UNIX COMP3[" + comp3ToAsc(bytes)+"]");
//			}
//			else if( "SE".equals(args[1]) ) {
//				
//				bytes = ascToSE(args[0].getBytes());
//				System.out.println("HOST SE[" + new String(bytes)+"]");
//				System.out.println("UNIX ASC[" + new String(seToAsc(bytes))+"]");				
//			}
//			else if( "GE".equals(args[1]) ) {
//				// Graphic
//				bytes = ascToGE(args[0].getBytes());
//				System.out.println("HOST GE[" + new String(bytes)+"]");
//				System.out.println("UNIX ASC[" + new String(geToAsc(bytes))+"]");
//			}
//			else if( "ME".equals(args[1]) ) {
//				// Mixed 
//				bytes = ascToSE(args[0].getBytes());
//				System.out.println("HOST ME[" + new String(bytes)+"]");
//				System.out.println("UNIX ASC[" + new String(meToAsc(bytes))+"]");
//			}
//			
//			byte[] sByte = args[0].getBytes();
//			System.out.println("[ Source Bytes ]");
//			for(int i=0; i< sByte.length; i++) {
//				System.out.println("Byte["+i+"] = "+ printBit(sByte[i]) );
//			}
//			
//			System.out.println("[ Converted Bytes ]");
//			for(int i=0; i< bytes.length; i++) {
//				System.out.println("Byte["+i+"] = "+ printBit(bytes[i]) );
//			}			
//		}
//		catch(Exception e) {
//			System.out.println(e.toString());
//		}
//	}
	
	
	public static String printBit(byte bt) {
		String bitStr = "";
		for(int i=0; i<8; i++) {
			if( (bt & (0x80 >> i )) != 0x00) bitStr +="1";
			else  bitStr +="0";
		}
		return bitStr;
	}
	
	
	public CodeConversion() {
		super();
	}
	
	
	//-------------------------------------------------------------
	// Host COMP Type 과 ASCII 간의 변환 메소드
	// 예) PIC S9(4) USAGE COMP.
	//-------------------------------------------------------------		
	// 9(1-4) 2Byte
	// 9(5-9) 4Byte	
	/**
    * String을 HOST COMP로 변환한다.
    *
    * @param src 숫자형식의 String
    *
    * @return byte[] COMP 형의 byte Array
    * @exception Exception
    */
    public static byte[] ascToComp(byte[] src) throws Exception {
    	return ascToComp(new String(src));
    }
    
	public static byte[] ascToComp(String src) throws Exception {
			
		byte[] comp = null;
		
		try {
			if( "+".equals(src.substring(0,1)) ) src = src.substring(1);
			
			int sLen = src.length();
			
			if(sLen > 9) {
				throw new Exception("Maximun COMP Length Over["+src+"]");
			}
			
			int iKey = new Integer(src).intValue();
			
			// System.out.println("HEX[0x"+ Integer.toHexString(iKey)+"]");
			
			if(sLen < 5) {
				int lower = iKey & 0xff;
				int upper = iKey >> 8 & 0xff;
				
				comp = new byte[2];					
				comp[0] = new Integer(upper).byteValue();
				comp[1] = new Integer(lower).byteValue();
			}
			else {
				int byte1 = iKey >> 24 & 0xffff;
				int byte2 = iKey >> 16 & 0xffff;
				int byte3 = iKey >>  8 & 0xffff;
				int byte4 = iKey & 0xffff;			
				comp = new byte[4];					
				comp[0] = new Integer(byte1).byteValue();
				comp[1] = new Integer(byte2).byteValue();
				comp[2] = new Integer(byte3).byteValue();
				comp[3] = new Integer(byte4).byteValue();
				
			}	
		} catch(Exception e) {
			throw new Exception(e.getMessage());
		}
		return comp;
	}

	
	/**
    * HOST COMP를 String으로 변환한다.
    *
    * @param data byte[] COMP 형의 byte Array
    *
    * @return src 숫자형식의 String
    */
    
	public static String compToAsc(byte[] data) {
		BigInteger bint = new BigInteger(data);
		return bint.toString();
	}
	public static byte[] compToAscB(byte[] data) {
		return (compToAsc(data)).getBytes();
	}
	//-------------------------------------------------------------
	// Host COMP-3 Type 과 ASCII 간의 변환 메소드
	// 예) PIC S9(15)V USAGE COMP-3.
	//-------------------------------------------------------------		
	
	/**
    * Packed-Decimal을 숫자형식의 String으로 변환한다.
    *
    * @param src 숫자형식의 String으로 변환할 byte배열
	*
    * @return String 숫자형식의 String
    */    
    public static String comp3ToAsc(byte[] src) {
        
        boolean isMinus = false;
        StringBuffer sf = new StringBuffer();
        
        int end = src.length;

        for (int i=0; i<end; i++) {
            byte b = src[i];
            int lower = b & 0x0f;
            int upper = b >> 4 & 0x0f;  

            if (i == end-1) {
                sf.append(upper);
                if (lower == COMP3_MINUS) {
                    isMinus = true;
                }
            } else {
                sf.append((upper + "" + lower));    
            }                       
        }

        String str = sf.toString();  

        if (isMinus) {
            str = "-" + str;
        }
        else {
        	str = "+" + str;
        }
        return str;         
    }
    
    public static byte[] comp3ToAscB(byte[] src) {
    	return (comp3ToAsc(src)).getBytes();
    }
    /**
    * String을 Packed-Decimal을 숫자형식으로 변환한다.
    *
    * @param src 숫자형식의 bytes
    *
    * @return bytes
    * @exception Exception  
    */
    // 예
    // S9(5)V USAGE COMP-3. 일경우
    // UNIX 12345 ->   1/2 3/4 5/+   -> 0001/0010 0011/0100 0101/1111
    // UNIX +12345 ->  1/2 3/4 5/-   -> 0001/0010 0011/0100 0101/1101
    // UNIX -12345 ->  1/2 3/4 5/-   -> 0001/0010 0011/0100 0101/1101
    public static byte[] ascToComp3(byte[] src) throws Exception {
    	return ascToComp3(new String(src));
    }
    
    public static byte[] ascToComp3(String src) throws Exception {
		int srcSize = src.length();
		int byteSize = 0;
		int pos = 0;
		String bit = "";
		byte sByte = COMP3_UNSIGN;
		
		bit = src.substring(0,1);
		
    	if( "-".equals(bit) ) {
    		sByte = COMP3_MINUS;
    		byteSize = ((srcSize-1)/2)+1;
    	}
    	else if( "+".equals(bit) ) {
			sByte = COMP3_PLUS;
			byteSize = ((srcSize-1)/2)+1;
		}
		else {
			byteSize = (srcSize/2)+1;
		}
		
        byte[] comp3bytes = new byte[byteSize];
        
        // byte 초기화
        for( int i=0; i<(byteSize-1); i++ ) comp3bytes[i] = 0x00;
        
        //-----------------------------
        // 부호 설정 및 첫자리 처리
        //-----------------------------
        bit = src.substring(srcSize-1);
    	pos = Integer.parseInt(bit);
		
		comp3bytes[byteSize-1] = COMP3_UBYTES[pos];		
		comp3bytes[byteSize-1] = (byte)(comp3bytes[byteSize-1] | sByte);
    	
    	if(sByte == COMP3_UNSIGN) {
    		src = src.substring(0,srcSize-1);    		
    	}
    	else {
    		src = src.substring(1,srcSize-1);    		
    	}
    	
    	//-----------------------------
    	
    	srcSize = src.length();		
        
        int bPos = 0;        
        int cPos = byteSize-2;
        	
        for( int i=0; i<srcSize; i++ ) {
        	bPos = srcSize-i;
        	bit = src.substring(bPos-1,bPos);
    		try {
    			pos = Integer.parseInt(bit);
    		} catch(Exception e) {
    			throw e;	
    		}
// System.out.println("bPos["+bPos+"] bit["+bit+"] pos["+pos+"] cPos["+cPos+"]");	
    		
    		if(i%2 == 0) {
    			comp3bytes[cPos] = (byte)(comp3bytes[cPos] | COMP3_LBYTES[pos]);
    		}
    		else {
    			comp3bytes[cPos] = (byte)(comp3bytes[cPos] | COMP3_UBYTES[pos]);
    			cPos--;
    		}    		
    	}
        return comp3bytes;
    }
    
    //-------------------------------------------------------------
	// Host EBCDIC 과 ASCII 간의 변환 메소드
	// 예) PIC X(04) : Single, Double, Graphic
	//-------------------------------------------------------------
	public static byte[] appendHostZero(byte[] source, int fixedLength) throws Exception {
		
		byte[] sBytes = new byte[fixedLength];
		
		int spaces = fixedLength - source.length;
		
		if(spaces > 0) {
			for(int i = 0; i <spaces ; i++) {
				sBytes[i] = H_ZERO;
			}
			System.arraycopy(source, 0, sBytes, spaces, source.length);			
		}
		else if(spaces < 0) {
			System.arraycopy(source, -spaces, sBytes, 0, fixedLength);			
		}
		else {
			sBytes = source;
		}
							
		return sBytes;
	}
	public static byte[] appendUnixZero(byte[] source, int fixedLength) throws Exception {
		
		byte[] sBytes = new byte[fixedLength];
		
		int spaces = fixedLength - source.length;
		
		if(spaces > 0) {
			for(int i = 0; i <spaces ; i++) {
				sBytes[i] = U_ZERO;
			}
			System.arraycopy(source, 0, sBytes, spaces, source.length);			
		}
		else if(spaces < 0) {
			System.arraycopy(source, -spaces, sBytes, 0, fixedLength);			
		}
		else {
			sBytes = source;
		}				
		return sBytes;
	}
	
	public static byte[] appendUnixSpace(byte[] source, int fixedLength) throws Exception {
		
		byte[] sBytes = new byte[fixedLength];
		
		if(source.length > fixedLength) {
			System.arraycopy(source, 0, sBytes, 0, fixedLength);
		}
		else {
			System.arraycopy(source, 0, sBytes, 0, source.length);
			for(int i = source.length; i < fixedLength; i++) {
				sBytes[i] = U_SPACE;
			}
		}				
		return sBytes;
	}
	
	/**
     * EBCDIC byte를 특정 길이로 변환하며 여분은 SPACE로 채운다.
     *
     * @param source EBCDIC bytes[]
     * @param fixedLength 요청 byte 길이
     *
     * @return EBCDIC bytes[]
     * @exception Exception
     */
	public static byte[] appendHostSpace(byte[] source, int fixedLength) throws Exception {
		
		byte[] sBytes = new byte[fixedLength];
		
		if(source.length > fixedLength) {
			System.arraycopy(source, 0, sBytes, 0, fixedLength);
		}
		else {
			System.arraycopy(source, 0, sBytes, 0, source.length);
			for(int i = source.length; i < fixedLength; i++) {
				sBytes[i] = H_SPACE;
			}
		}				
		return sBytes;
	}
	
	/**
     * ASCII byte를 특정 길이로 변환하며 여분은 SPACE로 채운다.
     *
     * @param source ASCII bytes[]
     * @param fixedLength 요청 byte 길이
     *
     * @return ASCII bytes[]
     * @exception Exception
     */
	public static byte[] appendAsciiSpace(byte[] source, int fixedLength) throws Exception {
		
		byte[] sBytes = new byte[fixedLength];
		
		if(source.length > fixedLength) {
			System.arraycopy(source, 0, sBytes, 0, fixedLength);
		}
		else {
			System.arraycopy(source, 0, sBytes, 0, source.length);
			for(int i = source.length; i < fixedLength; i++) {
				sBytes[i] = U_SPACE;
			}
		}				
		return sBytes;
	}
	
	/**
     * ASCII를 Single EBCDIC로 변환한다..
     *
     * @param source Single ASCII bytes[]
     *
     * @return Single EBCDIC bytes[]
     * @exception Exception
     */
	public static byte[] ascToSE(byte[] source) throws Exception {
		String sStr   = new String(source);
		byte[] sBytes = null;
		try {
			//-------------------------------------------------
            // 2007.03.07 : SUN BMT Version : 2007.05.09 적용
            //-------------------------------------------------
            //sBytes = sStr.getBytes("cp933");
            sBytes = IConv.asciiToEBCDIC(sStr);
            //-------------------------------------------------
            
		}
		catch(Exception e) {
			throw e;
		}
		return sBytes;
	}
	
	/**
     * ASCII를 특정 길이의 Single EBCDIC로 변환한다..
     *
     * @param source Single ASCII bytes[]
     * @param fixedLength ASCII byte 길이
     *
     * @return Single EBCDIC bytes[]
     * @exception Exception
     */
	public static byte[] ascToSE(byte[] source, int fixedLength) throws Exception {
		
		byte[] tmpBytes = ascToSE(source);
		return appendHostSpace(tmpBytes, fixedLength);
	}
	
	/**
     * ASCII를 특정 길이의 Single EBCDIC로 변환한다..
     *
     * @param source Single ASCII bytes[]
     * @param fixedLength ASCII byte 길이
     *
     * @return Single EBCDIC bytes[]
     * @exception Exception
     */
	public static byte[] ascToSE9(byte[] source, int fixedLength) throws Exception {
		
		byte[] tmpBytes = ascToSE(source);
		return appendHostZero(tmpBytes, fixedLength);
	}
	/**
     * Single EBCDIC을 ASCII로 변환한다..
     *
     * @param source Single EBCDIC bytes[]
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] seToAsc(byte[] source) throws Exception {
		try {
			//-------------------------------------------------
            // 2007.03.07 : SUN BMT Version : 2007.05.09 적용
            //-------------------------------------------------
            //String sStr = new String(source,"cp933");
            String sStr = IConv.ebcdicToASCII(source);
			//-------------------------------------------------
            return sStr.getBytes();
		} catch(Exception e) {
			throw e;
		}
	}
	
	/**
     * Single EBCDIC을 특정 길이의 ASCII로 변환한다..
     *
     * @param source Single EBCDIC bytes[]
     * @param fixedLength ASCII byte 길이
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] seToAsc(byte[] source, int fixedLength) throws Exception {
		byte[] tmpBytes = seToAsc(source);
		return appendAsciiSpace(tmpBytes, fixedLength);
	}
	
	/**
     * ASCII(반자)를 Graphic EBCDIC로 변환한다..
     *
     * @param source ASCII bytes[]
     *
     * @return Graphic bytes[]
     * @exception Exception
     */	
	public static byte[] ascToGE(byte[] source) throws Exception {
		
		String sealSource = simpleToSeal(new String(source));
		byte[] sealBytes = sealSource.getBytes();	
		byte[] seBytes = ascToSE(sealBytes);
		
		// SO-SI Length는 제외한다.
		byte[] gBytes = new byte[seBytes.length - 2];
		System.arraycopy(seBytes, 1, gBytes, 0, gBytes.length);
		return gBytes;
	}
	
	/**
     * Graphic EBCDIC을 ASCII(반자)로 변환한다..
     *
     * @param source Graphic bytes[]
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] geToAsc(byte[] source) throws Exception {
		
		byte[] seBytes = new byte[source.length + 2];
		seBytes[0] = H_SO;
		seBytes[seBytes.length-1] = H_SI;
		
		System.arraycopy(source, 0, seBytes, 1, seBytes.length - 2);
		String sealString = new String(seToAsc(seBytes));
		String simpSource = sealToSimple(sealString);
		return simpSource.getBytes();
		
	}
	
	/**
     * Mixed EBCDIC을 ASCII(반자)로 변환한다. 
     * SO-SI를 blank로 변환
     * 전자를 반자로 변환
     * @param source Graphic bytes[]
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] meToAsc(byte[] source) {
		try {
			byte[] seBytes = new byte[source.length * 2];
			int sPos = 0;
			for(int i=0; i<source.length; i++) {
				if(source[i] == H_SO) {
					seBytes[sPos] = H_SPACE;
					sPos++;
					seBytes[sPos] = source[i];
				}
				else if(source[i] == H_SI) {
					seBytes[sPos] = source[i];
					sPos++;
					seBytes[sPos] = H_SPACE;
				}
				else {
					seBytes[sPos] = source[i];
				}
				sPos++;
			}
			//System.out.println("sPos = "+sPos);
			
			byte[] newBytes = new byte[sPos];
			
			System.arraycopy(seBytes, 0, newBytes, 0, newBytes.length);
			String sealString = new String(seToAsc(newBytes));
			String simpSource = sealToSimple(sealString);
			return simpSource.getBytes();
		} catch(Exception e) {
			return source;
		}
	}
	
	/**
     * Mixed EBCDIC을 ASCII로 변환한다. 
     * SO-SI를 그대로 유지한다.
     *
     * @param source Graphic bytes[]
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] meToAsc2(byte[] source) {
		try {
//			String ascWithSOSI = IConv.ebcdicToASCIIWithSOSI(source);
			// XML 보기시 문제가 있으므로 Space 로 치환하는 메소드로 변경
			String ascWithSOSI = IConv.ebcdicToASCIISOSISpaceEX(source);			
			return ascWithSOSI.getBytes();
		} catch(Exception e) {
			return source;
		}
	}	
	
    /**
     * Mixed EBCDIC을 SOSI를 SPACE로 치환한 ASCII로 변환한다. 
     * SO-SI를 blank로 변환
     *
     * @param source Graphic bytes[]
     *
     * @return ASCII bytes[]
     * @exception Exception
     */	
	public static byte[] meToMixedAsc(byte[] source) throws Exception {
		
		byte[] seBytes = new byte[source.length * 2];
		int sPos = 0;
		for(int i=0; i<source.length; i++) {
			if(source[i] == H_SO) {
				seBytes[sPos] = H_SPACE;
				sPos++;
				seBytes[sPos] = source[i];
			}
			else if(source[i] == H_SI) {
				seBytes[sPos] = source[i];
				sPos++;
				seBytes[sPos] = H_SPACE;
			}
			else {
				seBytes[sPos] = source[i];
			}
			sPos++;
		}
		//System.out.println("sPos = "+sPos);
		
		byte[] newBytes = new byte[sPos];
		
		System.arraycopy(seBytes, 0, newBytes, 0, newBytes.length);
		String sealString = new String(seToAsc(newBytes));
		return sealString.getBytes();
	}
	//-------------------------------------------------------------
	// 전자(Seal) 반자(Simple) 변환
	//-------------------------------------------------------------		
	/*
		- 변환 규칙
		0x20 : SPACE
		0x21 ~ 0x7e : '!' ~ '~' 로 전자/반자 변환이 가능
		            : 전자 = 반자 + 65248(0xfee0)만큼의 차이가 난다.
		              이를 기준으로 전자/반자 변환을 수행한다.
    */
        
	/**
    * 전자 숫자,영문자와 공백을 반자로 변환한다.
    *
    * @param seal 전자 String
    *
    * @return 반자 String
    */
	public static String sealToSimple(String seal) {
		String single = null;
		int sLength = seal.length();
		char[] cArray = new char[sLength];
		
		seal.getChars(0, sLength, cArray, 0);
		
		for (int i = 0; i < sLength; i++) {
			if (cArray[i] > 0xff00 && cArray[i] <= 0xff5e) {
				cArray[i] -= 0xfee0;
			}
			else if (cArray[i] == 0x3000) {
				cArray[i] = 0x20;
			}
		}
		single = new String(cArray);
		return single;	
	}
	
	/**
    * 소수점이 있는 ASCII 숫자형 문자를 EBCDIC HOST Format으로 변환한다.
    * 12.3 - 6,3 -> 012300
    * @param decimalNumber ASCII 숫자형문자
    * @param totalLength 전체길이
    * @param decimalLength 소수부의 길이
    * @return HOST EBCDIC 숫자형 문자
    */
	
	public static byte[] toHostDecimalFormat(byte[] decimalNumber, int totalLength, int decimalLength) throws Exception{
		
		String formatString = "";
		String s = new String(decimalNumber).trim();
		
		boolean isMinus = false;
		
		String ascNum = "";
		if( s.startsWith("-") ) {
			ascNum = s.substring(1);
			isMinus = true;
		}
		else if( s.startsWith("+") ) {
			ascNum = s.substring(1);
		}
		else {
			ascNum = s;
		}
		
		// 부호처리
		int intLength = totalLength - decimalLength;
		if(isMinus) {
			intLength = intLength - 1;
		}
		
		String[] splitedNumber = ascNum.split("\\.");
		
		if(decimalNumber.length > (totalLength+1)) {
			throw new Exception("문자길이가  정의한 포맷길이("+totalLength+")보다  큽니다.");
		}
		
		if(intLength < splitedNumber[0].length()) {
			throw new Exception("정수부("+splitedNumber[0]+")의 길이가 정의한 포맷길이("+intLength+")보다  큽니다.");
		}
		// 소수점이 없음
		if(splitedNumber.length == 1) {
			if(intLength >= decimalNumber.length) {
				for(int i=0; i<(intLength-splitedNumber[0].length()); i++) {
					formatString = formatString + "0";
				}
				formatString = formatString + splitedNumber[0];
				for(int i=0; i<decimalLength; i++) {
					formatString = formatString + "0";
				}
			}
			else {
				throw new Exception("정수부의 길이가 정의한 포맷길이("+intLength+")보다 큽니다."); 
			}
		}
		// 소수점이 있음
		else if(splitedNumber.length == 2) {
			
			if(decimalLength < splitedNumber[1].length()) {
				throw new Exception("소수부("+splitedNumber[1]+")의 길이가 정의한 포맷길이("+decimalLength+")보다 큽니다.");
			}
			
			for(int i=0; i<(intLength-splitedNumber[0].length()); i++) {
				formatString = formatString + "0";
			}
			formatString = formatString + splitedNumber[0];
			formatString = formatString + splitedNumber[1];
			
			for(int i=0; i<(decimalLength-splitedNumber[1].length()); i++) {
				formatString = formatString + "0";
			}
		}
		else {
			throw new Exception("숫자에 소수점이 하나이상 존재합니다.");
		}
		
		// 음수일 경우에만 부호를 추가한다
		if(isMinus) {
			formatString = "-" + formatString;
		}
		
		return IConv.asciiToEBCDIC(formatString);
	}
	
	/**
    * 소수점이 있는 EBCDIC 숫자형 문자를 ASCII 소수점으로 변환한다.
    * 012300 - 6,3 -> 12.3 
    * @param ebcdicNumber EBCDIC 숫자형문자
    * @param totalLength 전체길이
    * @param decimalLength 소수부의 길이
    * @return ASCII 소수점 문자
    */
	public static byte[] toUnixDecimalFormat(byte[] ebcdicNumber, int totalLength, int decimalLength) throws Exception{
		
		String formatString = "";
		String s = IConv.ebcdicToASCII(ebcdicNumber);
		
		boolean isMinus = false;
		
		String ascNum = "";
		if( s.startsWith("-") ) {
			ascNum = s.substring(1);
			isMinus = true;
		}
		else if( s.startsWith("+") ) {
			ascNum = s.substring(1);
		}
		else {
			ascNum = s;
		}
		
		// 부호처리
		int intLength = totalLength - decimalLength;
		if(isMinus) {
			intLength = intLength - 1;
		}
		
		formatString = ascNum.substring(0,intLength);
		formatString = formatString +".";
		formatString = formatString + ascNum.substring(intLength);
		
		// remove front padding zero
		int pos = 0;
		while(pos <intLength) {
			if(formatString.charAt(pos) != '0') break;
			pos++;
		}
		
		if(pos > 0) {
			formatString = formatString.substring(pos);
		}	
		
		// remove trail padding zero or point
		pos = formatString.length() -1;
		while(pos > 0) {
			if(formatString.charAt(pos) != '0' && formatString.charAt(pos) != '.') break;
			pos--;
		}
		if(pos < formatString.length()) {
			formatString = formatString.substring(0, pos+1);
		}
		
		if(isMinus) {
			formatString = "-" + formatString;
		}
		
		return formatString.getBytes();
	}

	/**
    * 전자 숫자,영문자와 공백을 반자로 변환한다.
    *
    * @param seal 전자 String
    *
    * @return 반자 String
    */
	public static byte[] sealToSimple(byte[] seal) {
		String tmp=sealToSimple(new String(seal));
		return tmp.getBytes();	
	}
	
	/**
     * 반자 숫자,영문자와 공백을 전자로 변환한다.
     *
     * @param simple 반자 String
     *
     * @return 전자 String
     */	
	public static String simpleToSeal(String simple) {
	
		String seal = null;
	
		int sLength = simple.length();
	
		char[] cArray = new char[sLength];
		simple.getChars(0, sLength, cArray, 0);
		
		for (int i = 0; i < sLength; i++) {
			if (cArray[i] > 0x20 && cArray[i] <= 0x7e) {
				cArray[i] += 0xfee0;
			}
			else if (cArray[i] == 0x20) {
				cArray[i] = 0x3000;
			}
		}
		seal = new String(cArray);
	
		return seal;
	}
	
	
	
	/**
     * 반자 숫자,영문자와 공백을 전자로 변환한다.
     *
     * @param simple 반자 String
     *
     * @return 전자 String
     */	
	public static byte[] simpleToSeal(byte[] seal) {
		String tmp=simpleToSeal(new String(seal));
		return tmp.getBytes();
	}
	
	/**
     * 반자 숫자,영문자와 공백을 전자로 변환한다.
     * SO-SI 길이를 제외한 길이만큼 전자 SPACE를 패딩하거나
     * 전자길이만큼 잘라낸다.
     * @param simple 반자 String
     * @param length 전자변환 후의 전문길이
     *
     * @return 전자 String
     */	
	public static String simpleToSeal(String simple, int length) {
	
		//------------------------------------------------
		// 전문길이를 계산한다.
		//------------------------------------------------
		int sLength = simple.length();
		int slenfix = length / 2;
		int diff = slenfix - sLength;
		
		if( diff < 0) {
			simple = simple.substring(0, slenfix);
		}
		else if( diff > 0) {
			StringBuffer sb = new StringBuffer();
			sb.append(simple);
			for(int i=0; i<diff; i++) {
				sb.append(" ");
			}
			simple = sb.toString();
		}
		//------------------------------------------------
		return simpleToSeal(simple);
		
	}
	
	/**
     * 반자 숫자,영문자와 공백을 전자로 변환한다.
     * SO-SI 길이를 제외한 길이만큼 전자 SPACE를 패딩하거나
     * 전자길이만큼 잘라낸다.
     * @param simple 반자 String
     * @param length 전자변환 후의 전문길이
     *
     * @return 전자 String
     */	
	public static byte[] simpleToSeal(byte[] seal, int length) {
		String tmp=simpleToSeal(new String(seal), length);
		return tmp.getBytes();
	}
	
	public static byte   U_SPACE  = (byte)0x20;
	public static byte   U_ZERO   = (byte)0x30;
		
    public static byte   H_SO     = (byte)0x0E;
    public static byte   H_SI     = (byte)0x0F;
    public static byte   H_SPACE  = (byte)0x40;
    public static byte   H_ZERO   = (byte)0xF0;
    
    public static byte[] COMP3_UBYTES = new byte[10];
    public static byte[] COMP3_LBYTES = new byte[10];
    public static byte   COMP3_PLUS   = (byte)0x0C;
	public static byte   COMP3_MINUS  = (byte)0x0D;
	public static byte   COMP3_UNSIGN  = (byte)0x0F;
	static {
		COMP3_UBYTES[0] = (byte)0x00;
		COMP3_UBYTES[1] = (byte)0x10;
		COMP3_UBYTES[2] = (byte)0x20;
		COMP3_UBYTES[3] = (byte)0x30;
		COMP3_UBYTES[4] = (byte)0x40;
		COMP3_UBYTES[5] = (byte)0x50;
		COMP3_UBYTES[6] = (byte)0x60;
		COMP3_UBYTES[7] = (byte)0x70;
		COMP3_UBYTES[8] = (byte)0x80;
		COMP3_UBYTES[9] = (byte)0x90;		
		COMP3_LBYTES[0] = (byte)0x00;
		COMP3_LBYTES[1] = (byte)0x01;
		COMP3_LBYTES[2] = (byte)0x02;
		COMP3_LBYTES[3] = (byte)0x03;
		COMP3_LBYTES[4] = (byte)0x04;
		COMP3_LBYTES[5] = (byte)0x05;
		COMP3_LBYTES[6] = (byte)0x06;
		COMP3_LBYTES[7] = (byte)0x07;
		COMP3_LBYTES[8] = (byte)0x08;
		COMP3_LBYTES[9] = (byte)0x09;
	}	
}