var JTK = window.JTK || {
	version: '2.0.1',	//版本号
	basePath : '',		//框架的根路径,
	fnList : [],		//私有变量,用于Dom.ready方法
	_ready : false,		//自由变量,存储页面是否已经加载完毕
	_included : {},		//存储加载进来的javaScrip文件
	startTime : '',		//base.js开始运行的时间,常用于做一些超时处理
	_debug : false,		//debug模式,网站上线后应该关闭,可以避免IE加载Firebug程序
	varCatch : [],
	varNoExist : "ASDGASDFASGasdfasgasdfasfwertqwyqert	werqweyqwerweasdfasdfxXXXXsdfasdfasgasf"	//可以认为不存在的一个字符串
};

JTK.global = this;

/**
 * 返回对象的类型
 * 如果参数传的是null or undefined 则 return false 其它情况会根据变量解析的结果返回
 * string number boolean date function object array regexp element nodelist textnode
 * whitespace 如果解析的地节点就是一个空格就返回 whitespace
 * @param {Mixed} object
 * @return {String}
 */
JTK.getType = function(o){
	if(o === undefined || o === null){
		return false;
	}
	if(o.htmlElement){
		return 'element';
	}
	var t = typeof o;
	if(t == 'object' && o.nodeName) {
		switch(o.nodeType) {
			case 1: return 'element';
			case 3: return (/\S/).test(o.nodeValue) ? 'textnode' : 'whitespace';
		}
	}
	if(t == 'object' || t == 'function') {
		switch(o.constructor) {
			case Array: return 'array';
			case RegExp: return 'regexp';
			case Date: return 'date';
		}
		if(typeof o.length == 'number' && typeof o.item == 'function') {
			return 'nodelist';
		}
	}
	return t;
};

/**
 * alert 接口，预留出来因为以后可能会动态改变框架中调用alert的显示效果
 */
JTK.alert = function(msg){
	alert(msg); 
};

/**
 * 判断对象是否是数组
 */
JTK.isArray = function(obj) {
	return (obj instanceof Array || typeof obj == "array");
};

/**
 * 判断对象是否是字符串
 */
JTK.isString = function(obj){
	return (obj instanceof String || typeof obj == "string");
};

/**
 * 判断对象是否是函数
 */
JTK.isFunction = function(obj) {
	return (obj instanceof Function || typeof obj == "function");
};

/**
 * 判断对象是否是数字
 */
JTK.isNumber = function(ob){ 
	return (ob instanceof Number || typeof ob == "number"); 
};

/**
 * 搜索框架的根目录
 * @private
 */
JTK._findBasePath = function(){
	var scripts = document.getElementsByTagName('script');
    for (var i = scripts.length - 1; i >= 0; --i) {
      var src = scripts[i].src;
      var l = src.length;
      if (src.substr(l - 7) == 'Base.js') {
        JTK.basePath = src.substr(0, l - 7);
        return;
      }
    }
}

/**
 * 记录框架中的依赖关系
 */
JTK._dependencies = {
	pathToNames: {},	//js路径是key,变量名是value
	nameToPath: {}, 	//变量名是key,路径是value
	requires: {},		//包含进来的js
	visited: {},		//在visitNode方法中处理过，加入到script数组中的路径
	written: {} 		//记录系统写入的script路径，如果这里有记录，就不用再往依赖关系里写记录了
};

/**
 * 添加依赖关系
 * @param {string} relPath javascript 文件路径
 * @param {Array} provides An array of strings 对象名数组,引入文件文件提供的对象
 * @param {Array} requires An array of strings 对象名数组,引入文件所需的对象
 */
JTK.addDependency = function(relPath, provides, requires) {
	var provide, require;
	var path = relPath.replace(/\\/g, '/');
	var deps = JTK._dependencies;
	for (var i = 0; provide = provides[i]; i++) {
		deps.nameToPath[provide] = path;
		if (!(path in deps.pathToNames)) {
			deps.pathToNames[path] = {};
		}
		deps.pathToNames[path][provide] = true;
	}
	for (var j = 0; require = requires[j]; j++) {
		if (!(path in deps.requires)) {
			deps.requires[path] = {};
		}
		deps.requires[path][require] = true;
	}
};

/**
 * 引入js文件
 * @param {string} src Script source.
 */
JTK._writeScriptTag = function(src) {
	if (!JTK._dependencies.written[src]) {
		JTK._dependencies.written[src] = true;
		var doc = JTK.global.document;
		doc.write('<script type="text/javascript" src="' +
				src + '"></' + 'script>');
	}
};

/**
 * 动态引入js文件
 * 主要功能是判断依赖关系和判断文件是否需要引入
 */
JTK._writeScripts = function() {
	var scripts = [];
	var originallyScript = {};
	var deps = JTK._dependencies;
	
	//加入访问记录
	function visitNode(path) {
		if (path in deps.written) {
			return;
		}
		if (path in deps.visited) {
			if (!(path in originallyScript)) {
				originallyScript[path] = true;
				scripts.push(path);
			}
			return;
		}
		deps.visited[path] = true;
		if (path in deps.requires) {
			for (var requireName in deps.requires[path]) {
				if (requireName in deps.nameToPath) {
					visitNode(deps.nameToPath[requireName]);
				} else if (!JTK.getObjectByName(requireName)) {
					throw Error('没有定义 nameToPath ' + requireName);
				}
			}
		}
		if (!(path in originallyScript)) {
			originallyScript[path] = true;
			scripts.push(path);
		}
	}

	for (var path in JTK._included) {
		if (!deps.written[path]) {
			visitNode(path);
		}
	}
	for (var i = 0; i < scripts.length; i++) {
		if (scripts[i]) {
			JTK._writeScriptTag(JTK.basePath + scripts[i]);
		} else {
			throw Error('需要引入的js文件没有定义过');
		}
	}
};

/**
 * 根据对象名返回对象本身
 * @param {string} name 对象名
 * @param {string} obj 对象的最用域，默认obj = window;
 */
JTK.getObjectByName = function(name, obj){
	var parts = name.split('.');
	var cur = obj || window;	//cur 当前位置
	for (var part; part = parts.shift(); ) {
		if (cur[part]) {
		  cur = cur[part];
		} else {
		  return null;
		}
	}
	return cur;
};

/**
 * 在依赖关系库中返回路径
 * @param {String} rule 对象全名 比如 JTK.Dom
 */
JTK.getPathFromDeps = function(rule) {
	if (rule in JTK._dependencies.nameToPath) {
		return JTK._dependencies.nameToPath[rule];
	} else {
		return null;
	}
};

/**
 * 包含
 */
JTK.require = function(rule) {
	if (JTK.getObjectByName(rule)) {
		return;
	}
	var path = JTK.getPathFromDeps(rule);
	if (path) {
		JTK._included[path] = true;
		JTK._writeScripts();
	} else {
		var errorMessage = 'JTK.require 找不到: ' + rule;
		JTK.alert(errorMessage);
	}
};

/**
 * base.js加载的时间
 */
JTK.getTime = function() {
	var d = new Date();
	var t = d.getTime();
	return t;
};

/**
 * base.js加载的时间
 */
JTK._getStartTime = function() {
	JTK.startTime = JTK.getTime();
};

/**
 * 如果不是firefox浏览器,则引入firebug lite程序
 */
JTK._getFirebug = function(){
	if(JTK._debug){
		var FF = (navigator.userAgent.indexOf("Firefox")!=-1);
		if(!FF){
			JTK._writeScriptTag(JTK.basePath + 'Firebug/Firebug.js');
		}
	}
}

/**
 * 自动引入JavaScript包的依赖配置文件
 */
JTK._findBasePath();
JTK._writeScriptTag(JTK.basePath + 'deps.js');
JTK._getFirebug();
JTK._getStartTime();