dojo._xdResourceLoaded({
depends: [["provide", "dojox._cometd.cometd"],
["require", "dojo.AdapterRegistry"],
["require", "dojo.io.script"]],
defineResource: function(dojo){if(!dojo._hasResource["dojox._cometd.cometd"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox._cometd.cometd"] = true;
dojo.provide("dojox._cometd.cometd");
dojo.require("dojo.AdapterRegistry");
dojo.require("dojo.io.script");

// FIXME: need to add local topic support to advise about:
//		successful handshake
//		network failure of channel
//		graceful disconnect

/*
 * this file defines Comet protocol client. Actual message transport is
 * deferred to one of several connection type implementations. The default is a
 * long-polling implementation. A single global object named "dojox.cometd" is
 * used to mediate for these connection types in order to provide a stable
 * interface.
 */

dojox.cometd = new function(){
	
	/* cometd states:
 	* DISCONNECTED:  _initialized==false && _connected==false
 	* CONNECTING:    _initialized==true  && _connected==false (handshake sent)
 	* CONNECTED:     _initialized==true  && _connected==true  (first successful connect)
 	* DISCONNECTING: _initialized==false && _connected==true  (disconnect sent)
 	*/
	this._initialized = false;
	this._connected = false;
	this._polling = false;

	this.connectionTypes = new dojo.AdapterRegistry(true);

	this.version = "1.0";
	this.minimumVersion = "0.9";
	this.clientId = null;
	this.messageId = 0;
	this.batch=0;

	this._isXD = false;
	this.handshakeReturn = null;
	this.currentTransport = null;
	this.url = null;
	this.lastMessage = null;
	this.topics = {};
	this._messageQ = [];
	this.handleAs="json-comment-optional";
	this.advice;
	this.pendingSubscriptions = {}
	this.pendingUnsubscriptions = {}

	this._subscriptions = [];

	this.tunnelInit = function(childLocation, childDomain){
		// placeholder
	}

	this.tunnelCollapse = function(){
		console.debug("tunnel collapsed!");
		// placeholder
	}

	this.init = function(root, props, bargs){
		// FIXME: if the root isn't from the same host, we should automatically
		// try to select an XD-capable transport
		props = props||{};
		// go ask the short bus server what we can support
		props.version = this.version;
		props.minimumVersion = this.minimumVersion;
		props.channel = "/meta/handshake";
		props.id = ""+this.messageId++;

		this.url = root||djConfig["cometdRoot"];
		if(!this.url){
			console.debug("no cometd root specified in djConfig and no root passed");
			return;
		}

		// Are we x-domain? borrowed from dojo.uri.Uri in lieu of fixed host and port properties
		var regexp = "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?$";
		var r = (""+window.location).match(new RegExp(regexp));
		if(r[4]){
			var tmp = r[4].split(":");
			var thisHost = tmp[0];
			var thisPort = tmp[1]||"80"; // FIXME: match 443

			r = this.url.match(new RegExp(regexp));
			if(r[4]){
				tmp = r[4].split(":");
				var urlHost = tmp[0];
				var urlPort = tmp[1]||"80";
				this._isXD = ((urlHost != thisHost)||(urlPort != thisPort));
			}
		}

		if(!this._isXD){
			if(props.ext){
				if(props.ext["json-comment-filtered"]!==true && props.ext["json-comment-filtered"]!==false){
					props.ext["json-comment-filtered"] = true;
				}
			}else{
				props.ext = { "json-comment-filtered": true };
			}
		} 

		var bindArgs = {
			url: this.url,
			handleAs: this.handleAs,
			content: { "message": dojo.toJson([props]) },
			load: dojo.hitch(this, "finishInit"),
			error: function(e){ console.debug("handshake error!:", e); }
		};

		if(bargs){
			dojo.mixin(bindArgs, bargs);
		}
		this._props=props;
		this._initialized=true;
		this.batch=0;
		this.startBatch();
		
		// if xdomain, then we assume jsonp for handshake
		if(this._isXD){
			bindArgs.callbackParamName="jsonp";
			return dojo.io.script.get(bindArgs);
		}
		return dojo.xhrPost(bindArgs);
	}

	this.finishInit = function(data){
		data = data[0];
		this.handshakeReturn = data;
		
		// pick a transport
		if(data["advice"]){
			this.advice = data.advice;
		}
       
       		if(!data.successful){
			console.debug("cometd init failed");
			if(this.advice && this.advice["reconnect"]=="none"){
				return;
			}

			if( this.advice && this.advice["interval"] && this.advice.interval>0 ){
				var cometd=this;
				setTimeout(function(){ cometd.init(cometd.url,cometd._props); }, this.advice.interval);
			}else{
				this.init(this.url,this._props);
			}

			return;
		}
		if(data.version < this.minimumVersion){
			console.debug("cometd protocol version mismatch. We wanted", this.minimumVersion, "but got", data.version);
			return;
		}
		this.currentTransport = this.connectionTypes.match(
			data.supportedConnectionTypes,
			data.version,
			this._isXD
		);
		this.currentTransport._cometd = this;
		this.currentTransport.version = data.version;
		this.clientId = data.clientId;
		this.tunnelInit = dojo.hitch(this.currentTransport, "tunnelInit");
		this.tunnelCollapse = dojo.hitch(this.currentTransport, "tunnelCollapse");

		this.currentTransport.startup(data);
	}

	// public API functions called by cometd or by the transport classes
	this.deliver = function(messages){
		// console.debug(messages);
		dojo.forEach(messages, this._deliver, this);
		return messages;
	}

	this._deliver = function(message){
		// dipatch events along the specified path

		if(!message["channel"]){
			if(message["success"] !== true){
				console.debug("cometd error: no channel for message!", message);
				return;
			}
		}
		this.lastMessage = message;

		if(message.advice){
			this.advice = message.advice; // TODO maybe merge?
		}

		// check to see if we got a /meta channel message that we care about
		if(	(message["channel"]) &&
			(message.channel.length > 5)&&
			(message.channel.substr(0, 5) == "/meta")){
			// check for various meta topic actions that we need to respond to
			switch(message.channel){
				case "/meta/connect":
					if(message.successful && !this._connected){
						this._connected = this._initialized;
						this.endBatch();
					} else if(!this._initialized){
						this._connected = false; // finish disconnect
					}                                     
					break;
				case "/meta/subscribe":
					var pendingDef = this.pendingSubscriptions[message.subscription];
					if(!message.successful){
						if(pendingDef){
							pendingDef.errback(new Error(message.error));
							delete this.pendingSubscriptions[message.subscription];
						}
						return;
					}
					dojox.cometd.subscribed(message.subscription, message);
					if(pendingDef){
						pendingDef.callback(true);
						delete this.pendingSubscriptions[message.subscription];
					}
					break;
				case "/meta/unsubscribe":
					var pendingDef = this.pendingUnsubscriptions[message.subscription];
					if(!message.successful){
						if(pendingDef){
							pendingDef.errback(new Error(message.error));
							delete this.pendingUnsubscriptions[message.subscription];
						}
						return;
					}
					this.unsubscribed(message.subscription, message);
					if(pendingDef){
						pendingDef.callback(true);
						delete this.pendingUnsubscriptions[message.subscription];
					}
					break;
			}
		}
		
		// send the message down for processing by the transport
		this.currentTransport.deliver(message);

		if(message.data){
			// dispatch the message to any locally subscribed listeners
			var tname = "/cometd"+message.channel;
			dojo.publish(tname, [ message ]);
		}
	}

	this.disconnect = function(){
		dojo.forEach(this._subscriptions, dojo.unsubscribe);
		this._subscriptions = [];
		this._messageQ = [];
		if(this._initialized && this.currentTransport){
			this._initialized=false;
			this.currentTransport.disconnect();
		}
		this._initialized=false;
		if(!this._polling)
			this._connected=false;
	}

	// public API functions called by end users
	this.publish = function(/*string*/channel, /*object*/data, /*object*/properties){
		// summary:
		//		publishes the passed message to the cometd server for delivery
		//		on the specified topic
		// channel:
		//		the destination channel for the message
		// data:
		//		a JSON object containing the message "payload"
		// properties:
		//		Optional. Other meta-data to be mixed into the top-level of the
		//		message
		var message = {
			data: data,
			channel: channel
		};
		if(properties){
			dojo.mixin(message, properties);
		}
		this._sendMessage(message);
	}

	this._sendMessage = function(/* object */ message){
		if(this.currentTransport && this._connected && this.batch==0){
			return this.currentTransport.sendMessages([message]);
		}
		else{
			this._messageQ.push(message);
		}
	}

	this.subscribe = function(	/*string */					channel,
								/*object, optional*/	     objOrFunc,
								/*string, optional*/	     funcName){ // return: boolean
		// summary:
		//		inform the server of this client's interest in channel
		// channel:
		//		name of the cometd channel to subscribe to
		// objOrFunc:
		//		an object scope for funcName or the name or reference to a
		//		function to be called when messages are delivered to the
		//		channel
		// funcName:
		//		the second half of the objOrFunc/funcName pair for identifying
		//		a callback function to notifiy upon channel message delivery

		if(this.pendingSubscriptions[channel]){
			// We already asked to subscribe to this channel, and
			// haven't heard back yet. Fail the previous attempt.
			var oldDef = this.pendingSubscriptions[channel];
			oldDef.cancel();
			delete this.pendingSubscriptions[channel];
		}

		var pendingDef = new dojo.Deferred();
		this.pendingSubscriptions[channel] = pendingDef;

		if(objOrFunc){
			var tname = "/cometd"+channel;
			if(this.topics[tname]){
				dojo.unsubscribe(this.topics[tname]);
			}
			var topic = dojo.subscribe(tname, objOrFunc, funcName);
			this.topics[tname] = topic;
		}

		this._sendMessage({
			channel: "/meta/subscribe",
			subscription: channel
		});

		return pendingDef;

	}

	this.subscribed = function(	/*string*/  channel,
								/*obj*/     message){
 	}


	this.unsubscribe = function(/*string*/			channel){ // return: boolean
		// summary:
		//		inform the server of this client's disinterest in channel
		// channel:
		//		name of the cometd channel to unsubscribe from

		if(this.pendingUnsubscriptions[channel]){
			// We already asked to unsubscribe from this channel, and
			// haven't heard back yet. Fail the previous attempt.
			var oldDef = this.pendingUnsubscriptions[channel];
			oldDef.cancel();
			delete this.pendingUnsubscriptions[channel];
		}

		var pendingDef = new dojo.Deferred();
		this.pendingUnsubscriptions[channel] = pendingDef;

		var tname = "/cometd"+channel;
		if(this.topics[tname]){
			dojo.unsubscribe(this.topics[tname]);
		}

		this._sendMessage({
			channel: "/meta/unsubscribe",
			subscription: channel
		});

		return pendingDef;

	}

	this.unsubscribed = function(	/*string*/  channel,
					/*obj*/     message){
	}

	this.startBatch = function(){
		this.batch++;
	}

	this.endBatch = function(){
		if(--this.batch <= 0 && this.currentTransport && this._connected){
			this.batch=0;

			var messages=this._messageQ;
			this._messageQ=[];
			if(messages.length>0){
				this.currentTransport.sendMessages(messages);
			}
		}
	}
	
	this._onUnload = function(){
		// make this the last of the onUnload method
		dojo.addOnUnload(dojox.cometd,"disconnect");
	}
}

/*
transport objects MUST expose the following methods:
	- check
	- startup
	- sendMessages
	- deliver
	- disconnect
optional, standard but transport dependent methods are:
	- tunnelCollapse
	- tunnelInit

Transports SHOULD be namespaced under the cometd object and transports MUST
register themselves with cometd.connectionTypes

here's a stub transport defintion:

cometd.blahTransport = new function(){
	this._connectionType="my-polling";
	this._cometd=null;
	this.lastTimestamp = null;

	this.check = function(types, version, xdomain){
		// summary:
		//		determines whether or not this transport is suitable given a
		//		list of transport types that the server supports
		return dojo.lang.inArray(types, "blah");
	}

	this.startup = function(){
		if(dojox.cometd._polling){ return; }
		// FIXME: fill in startup routine here
		dojox.cometd._polling = true;
	}

	this.sendMessages = function(message){
		// FIXME: fill in message array sending logic
	}

	this.deliver = function(message){
		if(message["timestamp"]){
			this.lastTimestamp = message.timestamp;
		}
		if(	(message.channel.length > 5)&&
			(message.channel.substr(0, 5) == "/meta")){
			// check for various meta topic actions that we need to respond to
			// switch(message.channel){
			// 	case "/meta/connect":
			//		// FIXME: fill in logic here
			//		break;
			//	// case ...: ...
			//	}
		}
	}

	this.disconnect = function(){
	}
}
cometd.connectionTypes.register("blah", cometd.blahTransport.check, cometd.blahTransport);
*/

dojox.cometd.longPollTransport = new function(){
	this._connectionType="long-polling";
	this._cometd=null;
	this.lastTimestamp = null;

	this.check = function(types, version, xdomain){
		return ((!xdomain)&&(dojo.indexOf(types, "long-polling") >= 0));
	}

	this.tunnelInit = function(){
		if(this._cometd._polling){ return; }
		this.openTunnelWith({
			message: dojo.toJson([
				{
					channel:	"/meta/connect",
					clientId:	this._cometd.clientId,
					connectionType: this._connectionType,
					id:		""+this._cometd.messageId++
				}
			])
		});
	}

	this.tunnelCollapse = function(){
		if(!this._cometd._polling){
			// try to restart the tunnel
			this._cometd._polling = false;

			// TODO handle transport specific advice

			if(this._cometd["advice"]){
				if(this._cometd.advice["reconnect"]=="none"){
					return;
				}

				if(	(this._cometd.advice["interval"])&&
					(this._cometd.advice.interval>0) ){
					var transport = this;
					setTimeout(function(){ transport._connect(); },
						this._cometd.advice.interval);
				}else{
					this._connect();
				}
			}else{
				this._connect();
			}
		}
	}

	this._connect = function(){
		if(	(this._cometd["advice"])&&
			(this._cometd.advice["reconnect"]=="handshake")
		){
			this._cometd.init(this._cometd.url,this._cometd._props);
 		}else if(this._cometd._connected){
			this.openTunnelWith({
				message: dojo.toJson([
					{
						channel:	"/meta/connect",
						connectionType: this._connectionType,
						clientId:	this._cometd.clientId,
						timestamp:	this.lastTimestamp,
						id:		""+this._cometd.messageId++
					}
				])
			});
		}
	}

	this.deliver = function(message){
		// console.debug(message);
		if(message["timestamp"]){
			this.lastTimestamp = message.timestamp;
		}
	}

	this.openTunnelWith = function(content, url){
		// console.debug("openTunnelWith:", content, (url||cometd.url));
		var d = dojo.xhrPost({
			url: (url||this._cometd.url),
			content: content,
			handleAs: this._cometd.handleAs,
			load: dojo.hitch(this, function(data){
				// console.debug(evt.responseText);
				// console.debug(data);
				this._cometd._polling = false;
				this._cometd.deliver(data);
				this.tunnelCollapse();
			}),
			error: function(err){
				console.debug("tunnel opening failed:", err);
				dojo.cometd._polling = false;

				// TODO - follow advice to reconnect or rehandshake?
			}
		});
		this._cometd._polling = true;
	}

	this.sendMessages = function(messages){
		for(var i=0; i<messages.length; i++){
			messages[i].clientId = this._cometd.clientId;
			messages[i].id = ""+this._cometd.messageId++;
		}
		return dojo.xhrPost({
			url: this._cometd.url||djConfig["cometdRoot"],
			handleAs: this._cometd.handleAs,
			load: dojo.hitch(this._cometd, "deliver"),
			content: {
				message: dojo.toJson(messages)
			}
		});
	}

	this.startup = function(handshakeData){
		if(this._cometd._connected){ return; }
		this.tunnelInit();
	}

	this.disconnect = function(){
		dojo.xhrPost({
			url: this._cometd.url||djConfig["cometdRoot"],
			handleAs: this._cometd.handleAs,
			content: {
				message: dojo.toJson([{
					channel:	"/meta/disconnect",
					clientId:	this._cometd.clientId,
					id:		""+this._cometd.messageId++
				}])
			}
		});
	}
}

dojox.cometd.callbackPollTransport = new function(){
	this._connectionType = "callback-polling";
	this._cometd = null;
	this.lastTimestamp = null;

	this.check = function(types, version, xdomain){
		// we handle x-domain!
		return (dojo.indexOf(types, "callback-polling") >= 0);
	}

	this.tunnelInit = function(){
		if(this._cometd._polling){ return; }
		this.openTunnelWith({
			message: dojo.toJson([
				{
					channel:	"/meta/connect",
					clientId:	this._cometd.clientId,
					connectionType: this._connectionType,
					id:		""+this._cometd.messageId++
				}
			])
		});
	}

	this.tunnelCollapse = dojox.cometd.longPollTransport.tunnelCollapse;
	this._connect = dojox.cometd.longPollTransport._connect;
	this.deliver = dojox.cometd.longPollTransport.deliver;

	this.openTunnelWith = function(content, url){
		// create a <script> element to generate the request
		dojo.io.script.get({
			load: dojo.hitch(this, function(data){
				this._cometd._polling = false;
				this._cometd.deliver(data);
				this.tunnelCollapse();
			}),
			error: function(){
				this._cometd._polling = false;
				console.debug("tunnel opening failed");
			},
			url: (url||this._cometd.url),
			content: content,
			callbackParamName: "jsonp"
		});
		this._cometd._polling = true;
	}

	this.sendMessages = function(/*array*/ messages){
		for(var i=0; i<messages.length; i++){
			messages[i].clientId = this._cometd.clientId;
			messages[i].id = ""+this._cometd.messageId++;
		}
		var bindArgs = {
			url: this._cometd.url||djConfig["cometdRoot"],
			load: dojo.hitch(this._cometd, "deliver"),
			callbackParamName: "jsonp",
			content: { message: dojo.toJson( messages ) }
		};
		return dojo.io.script.get(bindArgs);
	}

	this.startup = function(handshakeData){
		if(this._cometd._connected){ return; }
		this.tunnelInit();
	}

	this.disconnect = dojox.cometd.longPollTransport.disconnect;
	

	this.disconnect = function(){
		dojo.io.script.get({
			url: this._cometd.url||djConfig["cometdRoot"],
			callbackParamName: "jsonp",
			content: {
				message: dojo.toJson([{
					channel:        "/meta/disconnect",
					clientId:       this._cometd.clientId,
					id:             ""+this._cometd.messageId++
				}])
			}
		});
	}
}
dojox.cometd.connectionTypes.register("long-polling", dojox.cometd.longPollTransport.check, dojox.cometd.longPollTransport);
dojox.cometd.connectionTypes.register("callback-polling", dojox.cometd.callbackPollTransport.check, dojox.cometd.callbackPollTransport);

dojo.addOnUnload(dojox.cometd,"_onUnload");


}

}});