/*
分类操作类
主要用于用户发布供求、产品、注册、搜索
类名称：tc
构造函数参数说明：
			containerId=容器ID
			sl=要显示的分类层次，默认为0=全部显示
			dv=默认值，默认为0
			sn=select菜单的名称，默认为classid，select菜单的id为classid+层次，
			ss=菜单的size值
			onchange=附加select的onchange事件值
*/

var tradeClass=function(containerId,sl,dv,sn,ss)
{
	//私有属性
	//公有属性
	this.showLayer=0; //要显示的分类层次
	this.defaultValue=0; //默认值
	this.selectName='classid';	//空间的名字（id）为名字+分类层次
	this.selectSize=0;
	this.onchange=null;
	var parmNumber=arguments.length;
	this.containerId=(parmNumber>0)?arguments[0]:"classSelect";
	this.showLayer=(parmNumber>1 && Number(arguments[1]))?parseInt(arguments[0]):0
	this.defaultValue=(parmNumber>2 && Number(arguments[2]))?parseInt(arguments[0]):0
	this.selectName=(parmNumber>3 )?arguments[3]:this.selectName
	this.selectSize=(parmNumber>4 )?parseInt(arguments[4]):0
	
	//分类列表初始值设定
	var classNumber = TClass.length;
	var maxLayer=maxClassLayer;
	var classStr="";
	//方法
	
	
	/*
		加载select菜单，自动适应层数
	*/
this.init=function()
	{
		//获取容器，如果容器不存在则制定到默认值
		var container= document.getElementById(this.containerId);
		var crow,layer,className,tcid,parentId,obj,lv,parentIdPath,childIdPath,defaultParentIdPath,defaultLayer;
		this.showLayer=(this.showLayer>0 && this.showLayer<=maxLayer+1)?this.showLayer:maxLayer+1;
		lv=this.showLayer;
		//首先创建要显示层数的select，从0-n索引id，并填充到容器中
		for (j=0;j<lv;j++)
		{
			obj=document.createElement("select");
			container.appendChild(obj);
			obj.id=this.selectName+j.toString();
			obj.layer= j;
			obj.name = this.selectName;
			if (j<lv-1) obj.onchange=function(){tc.changeClass(this)};
			if (this.selectSize>0)
			{
				obj.size=this.selectSize;
			}
			this.clearSelect(obj);
		}
		
		//计算分类默认值路径，在加载时考虑默认值
		//填充内容并做操作，少一次循环处理
		var forj=1;
		for (i=0;i<classNumber;i++)
		{
			crow=TClass[i];
			tcid=crow.tcid;
			parentId=crow.parentId;
			parentIdPath=crow.parentIdPath;
			childIdPath=crow.childIdPath;
			layer=crow.classLayer;
			//获得默认的父路径
			if (this.defaultValue==tcid)
			{
				defaultParentIdPath=parentIdPath;
				defaultLayer=layer;
			}
			//此版本指加载一级分类
			if (crow.classLayer==0)
			{
			//this.getSelect(layer).options.add(Option(crow.className,tcid.toString())); 老版本填充
			//新版本填充方式
			this.getSelect(layer).options[forj] = new Option(crow.className,tcid.toString());
			forj++;
			}
			
		}
		
		if (this.defaultValue > 0)
		{
			var sobj = null;
			var dvid=0;
			var sary = (defaultParentIdPath+","+this.defaultValue.toString()).split(',');
			for (sai=0; sai<=defaultLayer;sai++)
			{	
				dvid=sary[sai+1];
				sobj=this.getSelect(sai);
				for(si=0;si<sobj.length;si++)
				{
					if (parseInt(sobj.options[si].value)==dvid)
					{
						sobj.options.selectedIndex=si;
						break;
					}
				}
				this.changeClass(sobj);
			}
		}
		else
		{
			this.getSelect(0).selectedIndex=0
		}
	}
	/*
		改变分类的值
		参数:obj=当前正被操作的对象
	*/
this.changeClass=function(obj)	
	{
		var crow,tcid,parentId,parentIdPath,childIdPath,childNumber,layer;
		//获得分类父id，子id，层次
		//alert("aaa");
		layer=parseInt(obj.layer);
		//获取当前值
		dvid=parseInt(obj.options[obj.selectedIndex].value);
	//	if (dvid>0)
	//	{
			//获取子分类数，如果子分类数>0则填充分类
			for(i=0;i<classNumber;i++)
			{
				if (TClass[i].tcid==dvid)
				{
					childNumber=TClass[i].childNumber;
					break;
				}
			}
			//alert(childNumber);
			//alert(this.showLayer);
			if (layer<this.showLayer-1)
			{
				obj2=this.getSelect(layer+1);
				//清除本级分类选择项
				//this.clearSelect(obj2);
				//for(j=obj2.length-1;j>=0;j--)
				//{
				//	obj2.options[j]=null;
				//}
				var i=0;
				var	j=1;
				//清空所有下级分类选项
				for (i=layer+1;i<this.showLayer;i++)
				{
				this.clearSelect(this.getSelect(i));
				}
				//if (childNumber>0) 
				//alert(dvid);
				if(dvid>0)
				{
					for(i=0;i<classNumber;i++)
					{
						if (TClass[i].parentId==dvid)
						{
							//if (dvid==1) alert(TClass[i].tcid);
							//obj2.options.add(Option(TClass[i].className,TClass[i].tcid.toString()));老填充方式
						obj2.options[j] = new Option(TClass[i].className,TClass[i].tcid.toString()); //新版填充方式
						j++;

						}
					}
				}
			}
		//}
		//else
		//{
			
		//}
	
	}
	//根据ID将选项指定到对应选项中。
	//暂时使用有待升级
	this.selectedByClassID=function(findClassId)
	{
		//得到需要的参数，该分类的父路径,这里不使用递归方法，所以js文件中的parentIdPath的准确率非常重要，一定要注意
		var gcrow,parentIdPath,ary;
		for(gi=0;gi<classNumber;gi++)
		{
			gcrow=TClass[gi];
			if(gcrow.tcid==findClassId)
			{
				parentIdPath=gcrow.parentIdPath;
				break;
			}
		}
		//如果parentId>0则证明此分类为多级分类，进行循环处理，否则直接赋值
		if (gcrow.parentId==0)
		{
			var obj=this.getSelect(0);
			this.selectedByValue(obj,findClassId);
			//改变一下select
			this.changeClass(obj);
		}
		else
		{
			parentIdPath+=","+findClassId.toString();
			ary=parentIdPath.split(",");
			//首先获取到所有select对象
			var objs=this.getSelects();
			for (osi=0;osi<objs.length;osi++)
			{
				this.selectedByValue(objs[osi],ary[osi+1]);
				this.changeClass(objs[osi]);
			}
		}
		
		//按顺序根据父路径对所有对话框进行填充
		
		//this.defaultValue=findClassId;
		//var objs=this.getSelects()
		//for (i=0;i<objs.length;i++)
		//{
		//	container.removeChild(objs[i]);
		//}
		//this.init();	
	}
	//根据value值选中所需的ID
	this.selectedByValue=function(obj,valuestr)
		{
			var objLen,oi;
			objLen=obj.length;
			for(oi=0;oi<objLen;oi++)
			{
				if (obj.options[oi].value==valuestr.toString())
				{
					obj.options[oi].selected=true;
					break;
				}
			}
		}
	
/*清除select选项
参数：obj=要清除的对象
*/
this.clearSelect=function(obj)
{
	obj.options.length=0;
	//obj.options.add(Option("-请选择分类-","0")); //老填充方式
	//新填充方式
	obj.options[0] = new Option("-请选择分类-","0"); 
	obj.options[0].selected=false;
}

/*检查分类选择是否合适
参数：checkLayer=要验证的分类层次，默认为0是验证所有已显示的，此值只能小于分类层数
返回值：false为未通过，true为通过
*/
this.checkSelectedIsOk=function(checkLayer)
	{
		var obj;
		ret=true;
		//先处理checkLayer的值，1为第一层
		var cl=checkLayer>this.showLayer || checkLayer<=0?this.showLayer:checkLayer;
		for(i=0;i<cl;i++)
		{
			obj=this.getSelect(i).options;
			if(obj.selectedIndex<1 )
			{
				ret=false;
				break;
			}
		}
		return ret;
	}

/*获取select对象
参数：layer=层次
*/
this.getSelect=function(layer)
	{
		return document.getElementById(this.selectName+layer.toString());
	}
/*
获取获取所有select对象
*/
this.getSelects = function()
	{
		//return document.getElementsByName(this.selectName);
		//alert(this.showLayer);
		var objs=new Array(this.showLayer);
		for(ri=0;ri<this.showLayer;ri++)
		{
			objs[ri]=this.getSelect(ri);
		}
		return objs;
	}
	
/*
根据关键字查找分类，返回json的字符串
*/
this.getClassPathByKeywords=function(keyWords)
	{
		var gi=0;
		//json有两个参数，一个参数是索引的id(tcid)，一个是导航文本(pathTxt)
		var jsonStr="";
		var crow;
		for(gi=0;gi<classNumber;gi++)
		{
			crow=TClass[gi];
			if (crow.className.indexOf(keyWords)>-1)
			{
				jsonStr+="{\"tcid\":"+crow.tcid+",\"pathTxt\":\""+this.getClassPathClassName(crow)+"\"},";
			}
		}
		jsonStr=jsonStr.substring(0,jsonStr.length-1);
		if (jsonStr!="")
		{
			jsonStr="["+jsonStr+"]";
		}
		//alert(jsonStr);
	    return jsonStr;
	}
/*
根据ID字符串获取分类路径，存入json字符串中。
id字符串用“,”分割
这里最终结果将按照系统分类顺序进行排列，好处在于不出现重复分类
*/	
this.getClassPathByIds=function(ids)
	{
		var gi=0;
		//json有两个参数，一个参数是索引的id(tcid)，一个是导航文本(pathTxt)
		var jsonStr="";
		var crow,tempStr;
		//先处理ids，将他前后都加入“,”便于在indexOf时使用（暂时使用，想到好的方法替换）
		ids=","+ids+",";
		for(gi=0;gi<classNumber;gi++)
		{
			crow=TClass[gi];
			//为了分类检索准确性，加","后比对两个
			tempStr=","+crow.tcid.toString()+","
			strIn = ids.indexOf(tempStr)
			if (strIn>-1)
			{
				jsonStr+="{\"tcid\":"+crow.tcid+",\"pathTxt\":\""+this.getClassPathClassName(crow)+"\"},";
							//去掉本次所比对的字符串
				ids=this.stringRemove(ids,strIn,tempStr.length-1)
				//alert(ids);
				if (ids.replace(",","")=="")
				{
					break;
				}

			}
			
		}
		jsonStr=jsonStr.substring(0,jsonStr.length-1);
		if (jsonStr!="")
		{
			jsonStr="["+jsonStr+"]";
		}
		//alert(jsonStr);
	    return jsonStr;
	}
	
	
/*
根据行实例获取对应的分类名称导航，结果为字符串用>连接
*/
this.getClassPathClassName=function(rowObj)
{
	var str=""
	if (rowObj.parentId==0)
	{
		str=rowObj.className;
	}
	else
	{
		var ary=rowObj.parentIdPath.split(",");
		//alert(rowObj.parentIdPath+":"+rowObj.className);
		var aryLen = ary.length;
		var parentId;
		for (i=0;i<aryLen;i++)
		{	
			parentId=parseInt(ary[i]);
			if (parentId==0) continue;
			//if (parentId==rowObj.parentId)
			//{
			//	break;
			//}
			str+=this.getClassName(parentId)+"&gt;";
		}
			str+=rowObj.className;
	}
	return str;
}
//根据分类ID获取分类名称
this.getClassName=function(classId)
	{
		var classNamestr="";
		var gcncrow;
		for(gi=0;gi<classNumber;gi++)
		{
			gcncrow=TClass[gi];
			if (gcncrow.tcid==classId)
			{
				classNamestr=gcncrow.className;	
				break;
			}
		}
		return classNamestr;
	}
	//这是一个公用函数，暂时写在这里以免丢失引用
	//作用：移除字符串中指定开始位置到指定长度的字符
	//参数：str=要处理的字符串,startIndex=开始位置,removeCount=移除长度
	this.stringRemove=function(str,startIndex,removeCount)
		{
			if (removeCount>0)
			{
				var strTemp=""
				if (startIndex>0)	strTemp=str.substring(0,startIndex);
				if (removeCount>0)
				{
					endIndex=(startIndex+removeCount);
					strTemp+=str.substring(endIndex,str.length);
				}
			}
			else
			{
				strTemp=str
			}
			return strTemp;
		}

	
}


//var tc = new tradeClass("a",3,0,"classid",5);
var tc = new tradeClass();

//changeClass=function(obj)	
//	{
//		alert(obj.length);
//		var crow,tcid,parentId,parentIdPath,childIdPath,layer;
//		//获得分类父id，子id，层次
//		return ;
//	}