/**
 * xpath 연산함수
 */
function xPathOperation (strOperation, xnNode)
{
	var strCalculation = strOperation;
	// 함수형식의 정규식 작성
	strCalculation = strCalculation.replaceAll(""", "\"");
	var strReg=/(([a-z]|\d|\)|\'|\"|\s)\=([a-z]|\d|\/|\(|\'|\"|\s))/g; // = -> == 변환
	var alOperator = strCalculation.match(strReg);
	if (null != alOperator)
	{
		for(var i = 0 ; i < alOperator.length; i++)
		{ 
			var strOperatorTempData = alOperator[i];
			strOperatorTempData = strOperatorTempData.replace(/\=/g,"==");
			strCalculation = strCalculation.replaceAll(alOperator[i], strOperatorTempData);
		}
	}
	while(true)
	{	
		var rePattern = /(([a-z]+)\-([a-z]+)\-(([a-z]+)(\s+|))\(((([A-Za-z]|\d|\&\&|\|\||\%|\/|\+|\-||\=\=|\!\=|\*|\<|\<\=|\>|\>|\'|\"|\,|\.|\s)+)|)\))|(([a-z]+)\-(([a-z]+)(\s+|))\(((([A-Za-z]|\d|\&\&|\|\||\%|\/|\+|\-||\=\=|\!\=|\*|\<|\<\=|\>|\>|\'|\"|\,|\.|\s)+)|)\))|((([a-z]+)(\s+|))\(((([A-Za-z]|\d|\&\&|\|\||\%|\/|\+|\-||\=\=|\!\=|\*|\<|\<\=|\>|\>|\'|\"|\,|\.|\s)+)|)\))/g;
		var alFunctionResult = strCalculation.match(rePattern);
		if (null != alFunctionResult)
		{
			alFunctionResult.fextractDupArr(); // 배열의 값 중복제거
			for(var i = 0 ; i < alFunctionResult.length; i++)
			{// 수식에 xPath 함수가 있다면 먼저 실행하여 결과값을 추출한다 
				try
				{   //기존에 사용하던 Xpath 함수 형식을 구현한 함수형식으로 변환한다.
					var strTransValue = alFunctionResult[i].replaceAll("-", "_");
					if (-1 != strTransValue.indexOf("/"))
					{   
						var bXpathNodeFunctionExist =false;
						if (strTransValue.isRegular(/(avg|min|max|sum|position|last|count|text|node|namespace\_uri|local\_name|name)(\s+|)\(/g))
						{
							bXpathNodeFunctionExist = true;
						}	
						var strRefPattern = /(\.\.|(\/(\w+(\[\d\]|))))+/g;//Xpath 정규식 작성
						var alRefAddress = strTransValue.match(strRefPattern);
						if (null != alRefAddress)
						{ // 정규식 으로 Xpath 가 존재하는 검사
							alRefAddress.fextractDupArr();
							for(var j = 0 ; j < alRefAddress.length; j++)
							{ // 수식에 Xpath 존재한다면 결과값을 호출한다 
								if (!bXpathNodeFunctionExist)
								{
									if (null != xnNode && alRefAddress[j].isRegular(/\.\.\//g))
									{
										var strTempData = XmlLib.getTextValue(xnNode.selectSingleNode(alRefAddress[j]));
									}
									else
									{
										var strTempData = model.getValue(alRefAddress[j]);
									}	
								}
								else
								{
									var strTempData = alRefAddress[j];
								}	
								if(!isFinite(strTempData))
								{ // 숫자인지 문자인지 판별하여 문자일 경우 문자처리
									strTempData = "\"" + strTempData + "\"";
								}//Xpath 수식의 자리에 Xpath의 반환된 결과값으로 변환시킨다.	
								strTransValue = strTransValue.replaceAll(alRefAddress[j], strTempData);
							}
						}
					}	
					var resultValue = window.eval("xPath_"+ strTransValue.trim());
					strCalculation = strCalculation.replaceAll(alFunctionResult[i],String(resultValue));
				}
				catch (e)
				{
					return "";
				}			
			} 	
		}
		else
		{
			break;
		}	
	}	
	// 식 변환
	if (strCalculation.isRegular(/(\s|\))(and|or|mod|div)(\s|\()/g))
	{
		var alTransMathMark = strCalculation.match(/(\s|\))(and|or|mod|div)(\s|\()/g);
		alTransMathMark.fextractDupArr();
		for(var i = 0 ; i < alTransMathMark.length; i++)
		{
			strCalculation = strCalculation.replaceAll(alTransMathMark[i], alTransMathMark[i].replace(/and/g," && ").replace(/or/g," || ").replace(/mod/g, " % ").replace(/div/g," / "));
		}
	}
	var bOperation = false;
	if (strCalculation.isRegular(/(\&\&)|(\|\|)|(\%)|(\/)|(\+)|(\-)|(\=\=)|(\!\=)|(\*)|(\<)|(\<\=)|(\>)|(\>\=)/g))
	{
		bOperation = true;
	}
	
	//xPath 수식의 패턴을 찾는다
	rePattern =  /(\.\.|(\/(\w+(\[\d\]|))))+/g;
	var alXpathResult = strCalculation.match(rePattern);
	if (null != alXpathResult)
	{
		alXpathResult.fextractDupArr();
		for(var i = 0 ; i < alXpathResult.length; i++)
		{ 
			if (-1 != alXpathResult[i].indexOf("/"))
			{
				if (null != xnNode && alXpathResult[i].isRegular(/\.\.\//g))
				{
					var resultValue = XmlLib.getTextValue(xnNode.selectSingleNode(alXpathResult[i]));
				}
				else
				{
					var resultValue = model.getValue(alXpathResult[i]);
				}
				if (bOperation)
				{
					if (resultValue.isEmpty())
					{
						strCalculation = strCalculation.replaceAll(alXpathResult[i],"0");
					}
					else
					{
						strCalculation = strCalculation.replaceAll(alXpathResult[i],resultValue);
					}	
				}
				else
				{	
					strCalculation = strCalculation.replaceAll(alXpathResult[i],resultValue);
				}	
			}
		}
	}
	var reStringNumberPattern = /(\"|\')(\d+)(\"|\')/g; //수식에서 숫자로 구성된 문자열을 찾는다
	var alStringNumberResult = strCalculation.match(reStringNumberPattern);
	if (null != alStringNumberResult)
	{
		alStringNumberResult.fextractDupArr();
		for(var j = 0 ; j < alStringNumberResult.length; j++)
		{
			strCalculation = strCalculation.replaceAll(alStringNumberResult[j], alStringNumberResult[j].replace(/\'|\"/g,""));
		}
	}	
	
	if (bOperation)
	{	
		try
		{
			var strEnddingCalculate =  window.eval(strCalculation);
			if (strCalculation.isRegular(/\&\&|\|\|/g))
			{
				if (Number(strEnddingCalculate))
				{
					return Number(strEnddingCalculate) ? true : false;
				}
				else
				{
					return strEnddingCalculate;
				}	
			}
			else
			{
				return strEnddingCalculate;
			}	
		}
		catch (e)
		{
			return "";
		}
	}
	else
	{
		return  strCalculation;
	}	
};

/**
 * xPath 함수(Node Function)
 * @return
 */
function xPath_name (strFirstData)
{
	var alReturnValue = strFirstData.split(/\//g);
	return String(alReturnValue[alReturnValue.length - 1]);
};

function xPath_local_name (strFirstData)
{
	var alReturnValue = strFirstData.split(/\//g);
	return String(alReturnValue[alReturnValue.length - 1]);
};

/**
 * xPath 함수(Context Function)
 * @return
 */
function xPath_count (strFirstData)
{
	var alRefNode = model.getInstancePart(null, strFirstData);
	return String(alRefNode.length);
};

/**
 * xPath 함수(Boolean Function)
 * @return
 */
function xPath_boolean (strFirstData)
{//Xpath 표현을 true/false
	strTransString = xPath_string(strFirstData);
	if ("0" != strTransString && "false" != strTransString)
	{
		return true;
	}
	else
	{
		return false;
	}	
};

function xPath_not (bStringData)
{//현재 상태의 boolean 값의 반대 값을 반환
	if (bStringData)
	{
		return false;
	}
	else
	{
		return true;
	}	
};

function xPath_true ()
{//항상 true를 반환
	return true;
};

function xPath_false ()
{//항상 false를 반환
	return false;
};

/**
 * xPath 함수(String Function)
 * @return
 */
function xPath_string (objData)
{ // 인수로 받은 값을 무조건 문자열로 반환
	if (objData)
	{	
		var strStringConvert = String(objData);
		return strStringConvert;
	}
	return "";
};

function xPath_string_length (strStringData)
{ // 문자열의 길이를 반환
	if(strStringData)
	{	
		strStringData = xPath_string (strStringData);
		return strStringData.length;
	}
	return 0;
};	

function xPath_concat ()
{ // 인자로 받는 여러 개의 문자열을 하나의 문자열로 결합해서 반환
	var strReturnValue = "";
	for (var i=0 ; i < arguments.length ; i++)
	{
		strReturnValue +=  xPath_string (arguments[i]);
	}
	return strReturnValue;
};

function xPath_starts_with (strFirstData , strsecondData)
{//첫번째 인자로 오는 문자열이 두 번째 인자로 오는 문자열로 시작하는지를 판단
	strFirstData = xPath_string (strFirstData);
	strsecondData = xPath_string (strsecondData);
	if (0 == strFirstData.indexOf(strsecondData))
	{
		return true;
	}
	else
	{
		return false;
	}	
};

function xPath_contains (strFirstData , strsecondData)
{// 첫 번째 인자로 오는 문자열 안에 두번째 인자로 오는 문자열이 포환되어 있는지 여부
	strFirstData = xPath_string (strFirstData);
	strsecondData = xPath_string (strsecondData);
	if (-1 != strFirstData.indexOf(strsecondData))
	{
		return true;
	}
	else
	{
		return false;
	}	
};

function xPath_substring (strFirstData, nStartPoint, nEndPoint)
{
	strFirstData = xPath_string (strFirstData);
	return strFirstData.substring(nStartPoint-1, nEndPoint);
};

function xPath_substring_before (strFirstData, strSecondData)
{
	strFirstData = xPath_string (strFirstData);
	strsecondData = xPath_string (strsecondData);
	
	var nStrPoint = strFirstData.indexOf(strSecondData);
	return strFirstData.substring(0, nStrPoint);
};

function xPath_substring_after (strFirstData, strSecondData)
{
	strFirstData = xPath_string (strFirstData);
	strsecondData = xPath_string (strsecondData);
	
	var nStrPoint = strFirstData.indexOf(strSecondData);
	return strFirstData.substring(nStrPoint + 1, strFirstData.length);
};

function xPath_normalize_space (strFirstData)
{
	strFirstData = xPath_string (strFirstData);
	return strFirstData.trim();
};

function xPath_translate (strFirstData, strSecondData, strThirdData)
{
	strFirstData = xPath_string (strFirstData);
	strsecondData = xPath_string (strsecondData);
	strThirdData = xPath_string (strThirdData);
	
	return strFirstData.replaceAll(strSecondData, strThirdData);
};

/**
 * xPath 함수(Numeric Function)
 * @return
 */
function xPath_number (strFirstData)
{
	strFirstData = xPath_string (strFirstData);
	
	return Number(strFirstData);
};

function xPath_ceiling (strFirstData)
{
	return Math.ceil(xPath_number (strFirstData));
};

function xPath_floor (strFirstData)
{
	return Math.floor(xPath_number (strFirstData));
};

function xPath_round (strFirstData)
{
	return Math.round(xPath_number (strFirstData));
};

/**
 * xPath 함수(Aggregate Function)
 * @return
 */
function xPath_avg (strFirstData)
{
	var xlRefNode = model.getInstancePart(null, strFirstData);
	var nSumValue = 0;
	for (var i = 0 ; i < xlRefNode.length ; i++)
	{
		var strValue = XmlLib.getTextValue(xlRefNode.item(i));
		if ("" != strValue)
		{
			if (isFinite(strValue))
			{
				nSumValue += Number(strValue);
			}	
		}	
	}
	return String((nSumValue/alRefNode.length));
};

function xPath_min (strFirstData)
{
	var xlRefNode = model.getInstancePart(null, strFirstData);
	var nSumValue = 0;
	for (var i = 0 ; i < xlRefNode.length ; i++)
	{
		var strValue = XmlLib.getTextValue(xlRefNode.item(i));
		if ("" != strValue)
		{
			if (isFinite(strValue))
			{
				nSumValue = nSumValue <= Number(strValue)? nSumValue : Number(strValue);
			}
		}	
	}
	return String(nSumValue);
};

function xPath_max (strFirstData)
{
	var xlRefNode = model.getInstancePart(null, strFirstData);
	var nSumValue = 0;
	for (var i = 0 ; i < xlRefNode.length ; i++)
	{
		var strValue = XmlLib.getTextValue(xlRefNode.item(i));
		if ("" != strValue)
		{
			if (isFinite(strValue))
			{
				nSumValue = nSumValue >= Number(strValue)? nSumValue : Number(strValue);
			}
		}
	}
	return String(nSumValue);
};

function xPath_sum (strFirstData)
{
	var xlRefNode = model.getInstancePart(null, strFirstData);
	var nSumValue = 0;
	for (var i = 0 ; i < xlRefNode.length ; i++)
	{
		var strValue = XmlLib.getTextValue(xlRefNode.item(i));
		if ("" != strValue)
		{
			if (isFinite(strValue))
			{
				nSumValue += Number(strValue);
			}	
		}	
	}
	return String(nSumValue);
};

/**
 * xPath 함수(Date Function)
 * @return
 */
function xPath_days_from_date (strFirstData) 
{
	if (strFirstData.isRegular(/[0-9][0-9][0-9][0-9]\-[0-9][0-9]\-[0-9][0-9]/g))
	{	
		strFirstData = strFirstData.replace(/\-/g,"/");
		return String(Math.round(Math.abs(Date.parse(strFirstData)/1000/60/60/24)));
	}
	else
	{
		return "";
	}	
};

function xPath_seconds_from_datetime (strFirstData)
{
	if (strFirstData.isRegular(/[0-9][0-9][0-9][0-9]\-[0-9][0-9]\-[0-9][0-9]/g))
	{	
		strFirstData = strFirstData.replace(/\-/g,"/");
		return String(Math.round(Math.abs(Date.parse(strFirstData)/1000)));
	}
	else
	{
		return "";
	}	
};

function xPath_seconds (strFirstData)
{
	
};

function xPath_months (strFirstData)
{
	
};

/**
 * xPath 함수(XForms Function)
 * @return
 */
function xPath_luhn (strFirstData)
{
	strFirstData = xPath_string (strFirstData);
	if (12 <= strFirstData.length && 19 >= strFirstData.length)
	{
		for (var i = 0 ; i < strFirstData.length ; i++)
		{
			if (isNaN(strFirstData.substring(i,i + 1)))
			{
				return false;
			}
		}
		return true;
	}
	else
	{
		return false;
	}	
};

function xPath_if (bBoolean, strFirstData, strSecondData)
{
	if (bBoolean)
	{
		return xPath_string(strFirstData);
	}
	else
	{
		return xPath_string(strSecondData);
	}	
};

function xPath_boolean_from_string (strFirstData)
{
	strTransString = xPath_string(strFirstData);
	if ("0" == strTransString || "false" == strTransString)
	{
		return false;
	}
	else if ("1" == strTransString || "true" == strTransString)
	{
		return true;
	}
	return "";
};

function xPath_power (nBase, nExponent)
{
	strBase = xPath_string (nBase);
	strExponent = xPath_string (nExponent);
	
	return Math.pow(Number(strBase), Number(strExponent));
};

function xPath_now ()
{
	var now = new Date();
	var year = now.getUTCFullYear(); // 년도 가져오기
	var month = now.getMonth(); // 월 가져오기
	month = 9 > (month) ? "0"+(month+1):(month+1);
	var date = now.getDate(); // 날짜 가져오기
	date = 10 > (date) ? "0"+(date):(date);
	var hour = now.getHours(); // 시간 가져오기
	hour = 10 > (hour) ? "0"+(hour):(hour);
	var min = now.getMinutes(); // 분 가져오기
	min = 10 > (min) ? "0"+(min):(min);
	var sec = now.getSeconds(); // 초 가져오기
	sec = 10 > (sec) ? "0"+(sec):(sec);
	
	return year + "-" + month + "-" + date + "T" + hour + ":" + min + ":" + sec + "Z";
};