/**
 * HTML 안에 있는 객체(INPUT, SELECT 등)의 value 를 얻는다.
 *
 * <예>
 *	일반적인 객체들 :
 *		var strValue = getValue(document.form1.input1);
 *		alert(strValue);
 *
 *	SELECT 객체 :
 *		var strValue = getValue(document.form1.select1);
 *		alert(strValue);
 *
 *	MULTIPLE 속성이 있는 SELECT 객체 :
 *		var aValue = getValue(docment.form1.select2);
 *		for (var i = 0; i < aValue.length; i++) {
 *			alert(aValue[i]);
 *		}
 *
 * @param obj HTML 객체
 * @return 객체의 value 속성 값
 * 
 */
function getValue(obj) {
   var rValue = null;
   switch(obj.tagName.toUpperCase()) {
      case "SELECT" :
         if(obj.multiple) {
            var aValues = new Array();
            var x = 0;
            for(var i = 0; i < obj.length; i++) {
               if(obj.options[i].selected) {
                  aValues[x++] = obj.options[i].value;
               }
            }
            return aValues;
         }
         else {
            if(obj.selectedIndex >= 0) {
               rValue = obj.options[obj.selectedIndex].value;
            }
	        if(rValue == "none") {
    	    	rValue = null;
        	}
         }

         break;
      default : 
        rValue = obj.value;
         break;
   }
   if(rValue == null || rValue == "undefined") {
      rValue = "";
   }
   return rValue;
}

/**
 * 객체의 value 나 문자열의 값이 있는지 확인함.
 * 문자열의 길이가 0이면 false이다.
 *
 * @param obj 문자열을 확인할 객체 또는 문자열
 * @return 뭔가가 있으면 true, 아니면 false
 *
 */

function chkStr(obj) {
   var x =(obj == "[object]" ? getValue(obj) : obj);
   return(x.length > 0 ? true : false);
}

/**
 * 객체의 value 나 숫자, 문자열을 검사하여 숫자인지 확인함
 *
 * @param obj 숫자인지 확인할 객체 또는 숫자, 문자
 * @return 숫자이면 true, 아니면 false
 *
 */

function chkNum(obj) {
   var x =(obj == "[object]" ? getValue(obj) : obj);
   if(x.length <= 0) {
      return false;
   }
   return !isNaN(x);
}


/**
 * 문자열의 byte 단위의 길이를 구한다.
 *
 * @param s byte 단위의 길이를 구할 문자열
 * @return byte 단위 길이
 *
 */

function getByte(s) {
    var sum = 0;
    var len = s.length;
    for (var i=0; i<len; i++) {
        var ch = s.substring(i, i + 1);
        var en = escape(ch);
        if ( en.length <= 4 ) {
            sum++;
        } else {
            sum += 2;
        }
    }
    return sum;
}


var firstInvalidObject = null;

/**
 * HTML 의 FORM 객체를 받아서 그 안에 있는 모든 객체들의 값을 확인함.
 * 각 객체들의 값들이 적합한 값을 갖지 않았을 경우 메시지를 출력함.
 *
 * HTML tag에 속성을 추가한다.
 *  DTYPE : 값의 유형 ( S = 문자, N = 숫자, D = 날짜, F = 파일이름) - 필수 속성
 *  DFMAXLENGTH : DTYPE 이 F 인 경우 경로를 제외한 순수파일이름의 허용길이
 *  DNULL : 값이 null 일 수 있는지. (Y = null 허용, N = null 허용하지 않음; 실질적으로는 NULL이 아니고 입력을 안했다는 의미임) - 선택적; default=Y
 *  DSIZE : 문자 또는 숫자 값의 길이, 이 값을 설정하면 항상 이 값의 길이만큼 입력이 되어야 함, 설정하지 않으면 길이를 제한하지 않음 - 선택적; default=N/A
 *  MAXLENTH : 값의 최대 길이, 이 값을 설정하면 이 값보다 적거나 같은 길이만큼의 자료가 입력이 되어야 함. 설정하지 않으면 길이를 제한하지 않음 - 선택적; default=N/A
 *  DCOND : 값의 허용 범위를 설정함. - 선택적; default=N/A
 *		예1) 100 보다 크고 200 보다 작은 값은? >,100,&&,<,200
 *		예2) "abc" 보다 크거나 같고, "xyz"보다 작거나 같은 값은? >=,abc,&&,<=,xyz
 *		예3) 1000 보다 큰 값은? >,1000
 *	
 *  DETC : 특수문자가 있는 체크함. 이 값을 "C" 로 설정하면 특수문자가 있는지 체크한다. - 선택적; default=N/A
 *	DFOCUS : 이값이 N 이면 해당 필드가 VALIDATION 체크에 실패하여도 FOCUS 를 가지지 않음 (HIDDEN 필드의 경우 FOCUS 줄 때 스크립트 오류발생)
 */
function validateFormItems(obj) {
	firstInvalidObject = null;
	var rStr = doValidate(obj);
	if ( rStr != "" && firstInvalidObject != null) {
		if (firstInvalidObject.focus != null) firstInvalidObject.focus();
		if (firstInvalidObject.select != null) firstInvalidObject.select();
   }

	return rStr;
}

function doValidate(obj) {
   var rStr = "";
   var o = obj.children;
   if(o == null || o != "[object]" || o == "undefined") {
      return rStr;
   }

   var rTmp;
   var isFocus;
   for(var i = 0; i < o.length; i++) {
      var dType = o[i].getAttribute("DTYPE");
      
      // 객체가 textarea, textfield 인 경우 좌우trim을 객체에 값을 셋팅한다.
      if ( (o[i].tagName=="INPUT" && o[i].type=="text" ) || o[i].tagName=="TEXTAREA" ) {
         o[i].value = alltrim(o[i].value);
      }
      
      if(dType != null && dType != "undefined") {
         rTmp = checkFieldValid(o[i], dType);
         if (rTmp != "" && firstInvalidObject == null){ 
			isFocus = o[i].getAttribute("DFOCUS");
			if ( isFocus == null || isFocus != "N" ) firstInvalidObject = o[i]; 
         }
         rStr += rTmp;
      }
      rStr += doValidate(o[i]);
   }

   return rStr;
}

/**
 * 단일 Form 객체의 validation을 확인한다.
 * @param obj validation을 확인할 Form 객체
 */
function checkValid(obj) {
	if(obj == null || obj == "undefined") {
		return "";
	}
    
    var rStr = "";
    var dType = obj.getAttribute("DTYPE");
    if(dType != null && dType != "undefined") {
        rStr = checkFieldValid(obj, dType);
    }

	if (rStr != "") obj.focus();
	return rStr;
}

/**
 * FORM 의 객체의 유형(문자, 숫자)에 따라 그 객체의 값을 점검한다.
 * 1. NULL 값을 허용하지 않는 필드에서 NULL 또는 빈문자열이 있는지 점검한다.
 * 2. 조건(>, <, ==, <=, >=, &&, || 등)에 따른 값의 범위를 점검한다.
 * 3. 필드의 값이 가질 수 있는 최대 길이를 점검한다.
 * 4. 숫자의 경우 입력 값이 숫자인지 점검한다.
 * 5. 날짜의 경우 입력 값이 날짜유형인지 점검한다.
 *
 * @param obj 값을 점검할 FORM 객체.
 * @param dType 객체의 유형값 (S = 문자열, N = 숫자).
 * @return 객체의 값이 점검을 통과하지 못한 경우에만 에러 메세지가 반환된다.
 *
 */

function checkFieldValid(obj, dType) {
   var bNull = obj.getAttribute("DNULL");
   var nSize = parseInt(obj.getAttribute("DSIZE"));
   var nMinLen = parseInt(obj.getAttribute("MINLENGTH"));
   var nMaxLen = parseInt(obj.getAttribute("MAXLENGTH"));
   var sCond = obj.getAttribute("DCOND");
   var isEtc = obj.getAttribute("DETC");
   var sAlt = obj.getAttribute("ALT");
   var dfLen = parseInt(obj.getAttribute("DFMAXLENGTH"));
   var sValue = getValue(obj);

   if(sAlt == null || sAlt == "undefined" || sAlt == "") {
      sAlt = obj.name;
   }

   // Not NULL 필드에 값이 있는지 확인.
   if(bNull == "N" && sValue.length <= 0) {
      return sAlt + "을 입력하세요.\n";
   }
   // 숫자 필드의 값이 숫자인지 확인.
   if("N" == dType && isNaN(sValue)) {
      return sAlt + " 필드는 숫자만 입력할 수 있습니다.\n";
   }
   // 날짜 필드의 값이 날짜인지 확인.
   if("D" == dType && sValue.length > 0 && !isValidDate(sValue)) {
      return sAlt + " 필드에 적합한 날짜형 값이 입력되지 않았습니다.\n";
   }
   // 전화번호 필드의 값이 전화번호인지 확인.
   if("T" == dType && sValue.length > 0 && !is_tel_chars(sValue)) {
      return sAlt + " 필드에 적합한 값이 입력되지 않았습니다.\n";
   }
   // 입력값의 길이가 정확한지 확인.
   if(nSize != NaN && nSize >= 0 && sValue.length > 0 && nSize != getByte(sValue)) {
      if(sValue.length > nSize) {
         return sAlt + " 필드 값의 길이가 허용된 길이보다 큽니다. 허용길이=" + nSize + "\n";
      }
      else if(sValue.length < nSize) {
         return sAlt + " 필드 값의 길이가 허용된 길이보다 작습니다. 허용길이=" + nSize + "\n";
      }
   }
   // 특수문자 체크.
   if(isEtc == "C"){
   		if(is_etc(sValue)) {
   			return sAlt + " 필드에 특수문자가 포함되어 있습니다.\n";
   		}
   }
   
   // 파일이름 길이 체크
   if ( "F"==dType ) {
   		var filenm = sValue;
   		var pos = sValue.lastIndexOf("\\");
   		if ( pos!=-1 ) {
   			filenm = sValue.substring(pos+1,sValue.length);
   		}
  		if ( getByte(filenm) > dfLen ) {
	   		return sAlt + " 필드의 파일명 길이가 허용된 길이보다 큽니다. 최대허용길이=" + dfLen + "\n";
	   	}
   }
  
   // 입력값의 길이가 허용 최대 길이를 넘지 않는지 확인.
   var slength = getByte(sValue);
   if(nMaxLen != NaN && nMaxLen >= 0 && sValue.length > 0 && nMaxLen < slength) {	  return "한글은 " + nMaxLen + "자 영문은 " + (nMaxLen*2) + "까지 입니다.\n";	
      //return sAlt + " 필드 값의 길이가 허용된 길이보다 큽니다. 현재길이=" + slength + ", 최대허용길이=" + nMaxLen + "\n";
   }

   // 입력값의 길이가 허용 최소 길이에 못미치는지 확인.
   if(nMinLen != NaN && nMinLen >= 0 && sValue.length > 0 && nMinLen > slength) {
      return sAlt + " 필드 값의 길이가 허용된 길이보다 작습니다. 현재길이=" + slength + ", 최소허용길이=" + nMinLen + "\n";
   }

   // 입력값의 조건 확인
   if(sValue.length <= 0) {
      return "";
   }
   // 설정된 조건이 있으면...
   if(sCond != null && sCond != "undefined") {
      var aCond = parseDilim(sCond, ",");
      // 콤마로 분리된 조건을 읽어들임.
      var sExp = "";
      var nRem = 0;
      for(var i = 0; i < aCond.length; i++) {
         nRem = i % 3;
         if(nRem == 0) { /**  조건  **/
            sExp += " " + quote(sValue, dType) + " " + aCond[i];
         } else if(nRem == 1) { /**  범위  **/
            sExp += " " + quote(aCond[i], dType);
         } else if (nRem == 2) { /**  연결 연산자  **/
            sExp += " " + aCond[i];
         }
      }
      eval("var b = (" + sExp + ");");
      if(!b) {
         return sAlt + " 필드의 값이 적합하지 않습니다. " + sExp + "\n";
      }
   }
   return "";
}

function quote(str, dType) {
   return(dType == "S" ? "'" : "") + str +(dType == "S" ? "'" : "");
}

/**
 * 문자열을 주어진 dilimeter를 이용하여 분리한다.
 * 분리된 문자열은 배열로 반환된다.
 *
 * @param str 분리를 원하는 문자열 - dilimeter는 어떤 문자열이어도 상관없다(예: ',', '...' 등).
 * @return 분리된 문자열의 배열.
 *
 */

function parseDilim(str, dilim) {
   var n = dilim.length;
   var pos = str.indexOf(dilim);
   var aStr = new Array();
   var i = 0;
   for(i = 0; pos >= 0; i++) {
      aStr[i] = str.substring(0, pos);
      str = str.substring(pos + n, str.length);
      pos = str.indexOf(dilim);
   }
   if(str.length > 0) {
      aStr[i] = str;
   }
   return aStr;
}

/**
 * 문자열의 왼쪽 공백 문자를 제거한다.
 * @param str 공백을 제거할 문자열
 * @return 왼쪽의 공백을 제거한 문자열
 *
 */

function ltrim(str) {
   var l = str.length;
   var i = 0;
   for(; i < l; i++) {
      if(str.substring(i, i + 1) != " ")
      break;
   }
   return str.substring(i);
}

/**
 * 문자열의 오른쪽 공백 문자를 제거한다.
 * @param str 공백을 제거할 문자열
 * @return 오른쪽의 공백을 제거한 문자열
 *
 */

function rtrim(str) {
   var l = str.length;
   var i = l;
   for(; i > 0; i--) {
      if(str.substring(i - 1, i) != " ")
      break;
   }
   return str.substring(0, i);
}

/**
 * 문자열의 좌/우 공백 문자를 모두 제거한다.
 * @param str 공백을 제거할 문자열
 * @return 좌/우의 공백을 제거한 문자열
 *
 */

function alltrim(str) {
   return ltrim(rtrim(str));
}

/**
 * 특수문자 체크
 * @param srcStr 
 * @return 
 *
 */
var _etcValue = '~`!#$%%^&*_=+\|[{]};:\'\",<>/?';

function is_etc(value) {
    var   i, j;
    
    for(i=0; i<value.length;i++){
	    for(j=0;j<_etcValue.length;j++) {
	        if(value.charAt(i) == _etcValue.charAt(j)) {
	            return true;
	        }
	    }
    }
    return false;
}

/**
  * 전화번호를 구성할 만한 문자인가를 체크하는 함수 ( 숫자와 '-'만 허용 )
  * @param value 확인할 문자열
  */

var _telValue = '0123456789-'; 
 
function is_tel_chars(value) {
    var i,j;
    var isVal1, isVal2;
    
    isVal1 = true;
    for ( i=0 ; i<value.length ; i++ ) {
        isVal2 = false;       
        for( j=0 ;j<_telValue.length ; j++ ) {
            if( value.charAt(i)==_telValue.charAt(j) ) {
                isVal2 = true;
                break;
            }
        }
        if ( isVal2==false ) {
            isVal1 = false;
            break;
        }
    }
    return isVal1;
}

/**
  * validate email field
  * @param value
  */
function is_email(value) {
	var s_email;
	
	s_email = alltrim(value);
	
	if (s_email.length == 0) {
		return (true);
	}
	
	if (/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/.test(s_email))
		return (true);
	
	return (false);
}

/**
  * validate file types for image
  * @param value
  */
function is_valid_image(value) {
	var s_image;
	var s_image_type = new Array();
	s_image_type[0] = ".gif";
	s_image_type[1] = ".jpg";
	
	s_image = alltrim(value);
	
	if (s_image.length == 0) {
		return (true);
	}
	
	for (m = 0; m < s_image_type.length; m++) {
		if (s_image.match(s_image_type[m])) {
			return true;
		}
	}
	
	return (false);
}