if(!dojo._hasResource["dojox.data.JsonRestStore"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.data.JsonRestStore"] = true;
dojo.provide("dojox.data.JsonRestStore");
dojo.require("dojox.rpc.Rest"); 
dojo.require("dojox.rpc.JsonReferencing"); // TODO: Make it work without this dependency

// A JsonRestStore takes a REST service and uses it the remote communication for a 
// read/write dojo.data implementation. To use a JsonRestStore you should create a 
// service with a REST transport. This can be configured with an SMD:
//{
//    services: {
//        jsonRestStore: {
//			transport: "REST",
//			envelope: "URL",
//                    target: "store.php",
//					contentType:"application/json",
//                    parameters: [
//                            {name: "location", type: "string", optional: true}
//                    ]
//            }
//    }
//}
// The SMD can then be used to create service, and the service can be passed to a JsonRestStore. For example:
// var myServices = new dojox.rpc.Service(dojo.moduleUrl("dojox.rpc.tests.resources", "test.smd"));
// var jsonStore = new dojox.data.JsonRestStore({service:myServices.jsonRestStore});
// 
// The JsonRestStore will then cause all saved modifications to be server using Rest commands (PUT, POST, or DELETE).
// The JsonRestStore also supports lazy loading. References can be made to objects that have not been loaded.
//  For example if a service returned:
// {"name":"Example","lazyLoadedObject":{"$ref":"obj2"}}
//
// And this object has accessed using the dojo.data API:
// var obj = jsonStore.getValue(myObject,"lazyLoadedObject");
// The object would automatically be requested from the server (with an object id of "obj2").
//
// When using a Rest store on a public network, it is important to implement proper security measures to 
// control access to resources

dojox.data.ASYNC_MODE = 0;
dojox.data.SYNC_MODE = 1;
dojo.declare("dojox.data.JsonRestStore",
	null,
	{
		mode: dojox.data.ASYNC_MODE,
		constructor: function(options){
			//summary:
			//	JsonRestStore constructor, instantiate a new JsonRestStore 
			// A JsonRestStore can be configured from a JSON Schema. Queries are just 
			// passed through as URLs for XHR requests, 
			// so there is nothing to configure, just plug n play.
			// Of course there are some options to fiddle with if you want:
			//  
			// jsonSchema: /* object */
			// 
			// service: /* function */
			// This is the service object that is used to retrieve lazy data and save results 
			// The function should be directly callable with a single parameter of an object id to be loaded
			// The function should also have the following methods:
			// put(id,value) - puts the value at the given id
			// post(id,value) - posts (appends) the value at the given id
			// delete(id) - deletes the value corresponding to the given id		
			// 
			//	idAttribute: /* string */
			//		Defaults to 'id'. The name of the attribute that holds an objects id.
			//		This can be a preexisting id provided by the server.  
			//		If an ID isn't already provided when an object
			//		is fetched or added to the store, the autoIdentity system
			//		will generate an id for it and add it to the index. 

			//	mode: dojox.data.ASYNC_MODE || dojox.data.SYNC_MODE
			//		Defaults to ASYNC_MODE.  This option sets the default mode for this store.
			//		Sync calls return their data immediately from the calling function
			//		instead of calling the callback functions.  Functions such as 
			//		fetchItemByIdentity() and fetch() both accept a string parameter in addtion
			//		to the normal keywordArgs parameter.  When passed this option, SYNC_MODE will
			//		automatically be used even when the default mode of the system is ASYNC_MODE.
			//		A normal request to fetch or fetchItemByIdentity (with kwArgs object) can also 
			//		include a mode property to override this setting for that one request.

			//setup a byId alias to the api call	
			this.byId=this.fetchItemByIdentity;
			// if the advanced json parser is enabled, we can pass through object updates as onSet events
			dojo.connect(dojox.rpc,"onUpdate",this,function(obj,attrName,oldValue,newValue){
				var prefix = this.service.serviceName + '/';
				if (!obj._id){
					console.log("no id on updated object ", obj);
				}
				else if (obj._id.substring(0,prefix.length) == prefix)
					this.onSet(obj,attrName,oldValue,newValue);
				});
			if (options){
				dojo.mixin(this,options);
			}
			if (!this.service)
				throw Error("A service is required for JsonRestStore");
			if (!(this.service.contentType + '').match(/application\/json/))
				throw Error("A service must use a contentType of 'application/json' in order to be used in a JsonRestStore");
			this.idAttribute = (this.service._schema && this.service._schema._idAttr) || 'id';
			var arrayModifyingMethodNames = ["splice","push","pop","unshift","shift","reverse","sort"];
			this._arrayModifyingMethods = {};
			var array = [];
			var _this = this;
			// setup array augmentation, for catching mods and setting arrays as dirty
			for (var i = 0; i < arrayModifyingMethodNames.length; i++){
				(function(key){ // closure for the method to be bound correctly
					var method = array[key];
					_this._arrayModifyingMethods[key] = function(){
						_this._setDirty(this); // set the array as dirty before the native modifying operation
						return method.apply(this,arguments);
					}
					_this._arrayModifyingMethods[key]._augmented = 1;
				})(arrayModifyingMethodNames[i]);
			}
			this._deletedItems=[];
			this._dirtyItems=[];
			//given a url, load json data from as the store
		},

		_loadById: function(id,callback){
			var slashIndex = id.indexOf('/');
			var serviceName = id.substring(0,slashIndex);
			var id = id.substring(slashIndex + 1);
			(this.service.serviceName == serviceName ? 
					this.service : // use the current service if it is the right one 
					dojox.rpc.services[serviceName])(id) // otherwise call by looking up the service 
					.addCallback(callback);
		},
		getValue: function(item, property,lazyCallback){
			// summary:
			//	Gets the value of an item's 'property'
			//
			//	item: /* object */
			//	property: /* string */
			//		property to look up value for	
			// lazyCallback: /* function*/ 
			// 		not part of the API, but if you are using lazy loading properties, you may provide a callback to resume, in order to have asynchronous loading
			var value = item[property]; 
			if (value && value.$ref){
				dojox.rpc._sync = !lazyCallback; // tell the service to operate synchronously (I have some concerns about the "thread" safety with FF3, as I think it does event stacking on sync calls) 
				this._loadById((value && value._id) || (item._id + '.' + property),lazyCallback);
				delete dojox.rpc._sync; // revert to normal async behavior
			} else if (lazyCallback){lazyCallback(value);}
			return value;
		},

		getValues: function(item, property){
			// summary:
			//	Gets the value of an item's 'property' and returns
			//	it.  If this value is an array it is just returned,
			//	if not, the value is added to an array and that is returned.
			//
			//	item: /* object */
			//	property: /* string */
			//		property to look up value for	
	
			var val = this.getValue(item,property);
			return dojo.isArray(val) ? val : [val];
		},

		getAttributes: function(item){
			// summary:
			//	Gets the available attributes of an item's 'property' and returns
			//	it as an array. 
			//
			//	item: /* object */

			var res = [];
			for (var i in item){
				res.push(i);
			}
			return res;
		},

		hasAttribute: function(item,attribute){
			// summary:
			//	Checks to see if item has attribute
			//
			//	item: /* object */
			//	attribute: /* string */
			return attribute in item;		
		},

		containsValue: function(item, attribute, value){
			// summary:
			//	Checks to see if 'item' has 'value' at 'attribute'
			//
			//	item: /* object */
			//	attribute: /* string */
			//	value: /* anything */
			return getValue(item,attribute)==value;
		},


		isItem: function(item){
			// summary:
			//	Checks to see if a passed 'item'
			//	is really a JsonRestStore item.  
			//
			//	item: /* object */
			//	attribute: /* string */
		
			return !!(dojo.isObject(item) && item._id); 
		},

		isItemLoaded: function(item){
			// summary:
			//	returns isItem() :)
			//
			//	item: /* object */

			return !item.$ref;
		},

		loadItem: function(item){
			// summary:
			// Loads an item that has not been loaded yet. Lazy loading should happen through getValue, and if used properly, this should never need to be called
			//	returns true. Note this does not work with lazy loaded primitives!
			if (item.$ref){
				dojox.rpc._sync = true; // tell the service to operate synchronously 
				this._loadById(item._id)
				delete dojox.rpc._sync; // revert to normal async behavior
			}
			 
			return true;
		},

		_walk : function(value,forEach){
			// walk the graph, avoiding duplication
				var walked=[];
				function walk(value){
					if (value && typeof value == 'object' && !value.__walked){
						value.__walked = true;
						walked.push(value);
						for (var i in value){
							if (walk(value[i])){
								forEach(value,i,value[i]);
							}
						}
						return true;
					}
				}
				walk(value);
				forEach({},null,value);
				for (var i = 0; i < walked.length;i++)
					delete walked[i].__walked;
		},
		fetch: function(args){
			//console.log("fetch() ", args);
			// summary
			//	
			//	fetch takes either a string argument or a keywordArgs
			//	object containing the parameters for the search.
			//	If passed a string, fetch will interpret this string
			//	as the query to be performed and will do so in 
			//	SYNC_MODE returning the results immediately.
			//	If an object is supplied as 'args', its options will be 
			// 	parsed and then contained query executed. 
			//
			//	query: /* string or object */
			//		Defaults to "". This is basically passed to the XHR request as the URL to get the data
			//
			//	start: /* int */
			//		Starting item in result set
			//
			//	count: /* int */
			//		Maximum number of items to return
			//
			// cache: /* boolean */
			//
			//	sort: /* function */
			//		Not Implemented yet
			//
			//	The following only apply to ASYNC requests (the default)
			//
			//	onBegin: /* function */
			//		called before any results are returned. Parameters
			//		will be the count and the original fetch request
			//	
			//	onItem: /*function*/
			//		called for each returned item.  Parameters will be
			//		the item and the fetch request
			//
			//	onComplete: /* function */
			//		called on completion of the request.  Parameters will	
			//		be the complete result set and the request
			//
			//	onError: /* function */
			//		colled in the event of an error

			if(dojo.isString(args)){
					query = args;
					args={query: query, mode: dojox.data.SYNC_MODE};
					
			}

			var query;
			if (!args || !args.query){
				if (!args){
					var args={};	
				}

				if (!args.query){
					args.query="";
					query=args.query;
				}

			}

			if (dojo.isObject(args.query)){
				if (args.query.query){
					query = args.query.query;
				}else{
					query = args.query = "";
				}
				if (args.query.queryOptions){
					args.queryOptions=args.query.queryOptions
				}
			}else{
				query=args.query;
			}
			if (args.start || args.count){
				query += '[' + (args.start ? args.start : '') + ':' + (args.count ? ((args.start || 0) + args.count) : '') + ']';  
			}
			var results = dojox.rpc._index[this.service.serviceName + '/' + query];
			if (!args.mode){args.mode = this.mode;}
			var _this = this;
			var defResult;
			dojox.rpc._sync = this.mode;
			dojox._newId = query;
			if (results && !("cache" in args && !args.cache)){ // TODO: Add TTL maybe?
				defResult = new dojo.Deferred;
				defResult.callback(results); 
			}
			else {
				defResult = this.service(query);
			}
			defResult.addCallback(function(results){
				delete dojox._newId; // cleanup				
				if (args.onBegin){	
					args["onBegin"].call(_this, results.length, args);
				}
				_this._walk(results,function(obj,i,value){
					if (value instanceof Array){
						for (var i in _this._arrayModifyingMethods){
							if (!value[i]._augmented){
								value[i] = _this._arrayModifyingMethods[i];
							}
						}
						
					}
				});
				if (args.onItem){
					for (var i=0; i<results.length;i++){	
						args["onItem"].call(_this, results[i], args);
					}
				}					
				if (args.onComplete){
					args["onComplete"].call(_this, results, args);
				}
				return results;
			});
			defResult.addErrback(args.onError);
			return args;
		},
		

		getFeatures: function(){
			// summary:
			// 	return the store feature set

			return { 
				"dojo.data.api.Read": true,
				"dojo.data.api.Identity": true,
				"dojo.data.api.Write": true,
				"dojo.data.api.Notification": true
			}
		},

		getLabel: function(item){
			// summary
			//	returns the label for an item. Just gets the "label" attribute.
			//	
			return this.getValue(item,"label");
		},

		getLabelAttributes: function(item){
			// summary:
			//	returns an array of attributes that are used to create the label of an item
			return ["label"];
		},

		sort: function(a,b){
			console.log("TODO::implement default sort algo");
		},

		//Identity API Support

		getIdentity: function(item){
			// summary
			//	returns the identity of an item or throws
			//	a not found error.
			var prefix = this.service.serviceName + '/';
			if (!item._id){// generate a good random id
				item._id = prefix + Math.random().toString(16).substring(2,14)+Math.random().toString(16).substring(2,14);
			}
			if (item._id.substring(0,prefix.length) != prefix){
				throw Error("Identity attribute not found");
			}
			return item._id.substring(prefix.length);
		},

		getIdentityAttributes: function(item){
			// summary:
			//	returns the attributes which are used to make up the 
			//	identity of an item.  Basically returns this.idAttribute

			return [this.idAttribute];
		},

		fetchItemByIdentity: function(args){
			// summary: 
			//	fetch an item by its identity. fetch and fetchItemByIdentity work exactly the same
			return this.fetch(args); 
		},

		//Write API Support
		newItem: function(data, parentInfo){
			// summary:
			//	adds a new item to the store at the specified point.
			//	Takes two parameters, data, and options. 
			//
			//	data: /* object */
			//		The data to be added in as an item.
			//	parentInfo:
			//		An optional javascript object defining what item is the parent of this item (in a hierarchical store.  Not all stores do hierarchical items), 
			//		and what attribute of that parent to assign the new item to.  If this is present, and the attribute specified
			//		is a multi-valued attribute, it will append this item into the array of values for that attribute.  The structure
			//		of the object is as follows:
			//		{
			//			parent: someItem,
			//		}
			//  or
			//		{
			//			parentId: someItemId,
			//		}
			
			if (this.service._schema && this.service._schema.clazz && data.constructor != this.service._schema.clazz) 
				data = dojo.mixin(new this.service._schema.clazz,data);
			this.getIdentity(data);
			this._getParent(parentInfo).push(data); // essentially what newItem really means
			this.onNew(data);
			return data;
		},
		_getParent : function(parentInfo){
			
			var parentId = (parentInfo && parentInfo.parentId) || this.parentId || '';
			var parent = (parentInfo && parentInfo.parent) || dojox.rpc._index[this.service.serviceName + '/' + parentId] || [];
			if (!parent._id){
				parent._id = this.service.serviceName + '/' + parentId;
				this._setDirty(parent); // set it dirty so it will be post
			}
			return parent;
		},
		deleteItem: function(item,/*array*/parentInfo){	
			// summary
			//	deletes item any references to that item from the store.
			//
			//	item: 
			//  item to delete
			//
			//	removeFrom: This an item or items from which to remove references to this object. This store does not record references,
			// so if this parameter the entire object graph from load items will be searched for references. Providing this parameter
			// is vastly faster. An empty object or truthy primitive can be passed if no references need to be removed 
			
			//	If the desire is to delete only one reference, unsetAttribute or
			//	setValue is the way to go.
			if (this.isItem(item))
				this._deletedItems.push(item);
			var _this = this;
			this._walk(((parentInfo || this.parentId) && this._getParent(parentInfo)) || dojox.rpc._index,function(obj,i,val){
				if (obj[i] === item){ // find a reference to this object
					if (_this.isItem(obj)){
						if (isNaN(i) || !obj.splice){ // remove a property
							_this.unsetAttribute(obj,i);
							delete obj[i];
						}
						else {// remove an array entry
							obj.splice(i,1);
						}
					}
				}
			});
			this.onDelete(item);
		},

		_setDirty: function(item){
			// summary:
			//	adds an item to the list of dirty items.  This item
			//	contains a reference to the item itself as well as a
			//	cloned and trimmed version of old item for use with
			//	revert.
			var i;
			if (!item._id) 
				return;
			//if an item is already in the list of dirty items, don't add it again
			//or it will overwrite the premodification data set.
			for (i=0; i<this._dirtyItems.length; i++){
				if (item==this._dirtyItems[i].item){
					return; 
				}	
			}
			var old = item instanceof Array ? [] : {};
			for (i in item) 
				if (item.hasOwnProperty(i))
					old[i] = item[i];			
			this._dirtyItems.push({item: item, old: old});
		},

		setValue: function(item, attribute, value){
			// summary:
			//	sets 'attribute' on 'item' to 'value'

			var old = item[attribute];
			if (old != value){
				this._setDirty(item);
				item[attribute]=value;
				this.onSet(item,attribute,old,value);
			}
		},

		setValues: function(item, attribute, values){
			// summary:
			//	sets 'attribute' on 'item' to 'value' value
			//	must be an array.


			if (!dojo.isArray(values)){throw new Error("setValues expects to be passed an Array object as its value");}
			this._setDirty(item);
			var old = item[attribute];
			item[attribute]=values;
			this.onSet(item,attribute,old,values);
		},

		unsetAttribute: function(item, attribute){
			// summary:
			//	unsets 'attribute' on 'item'

			this._setDirty(item);
			var old = item[attribute];
			delete item[attribute];
			this.onSet(item,attribute,old,undefined);
		},
		_commitAppend: function(listId,item){
			return this.service.post(listId,item);
		},
		save: function(kwArgs){
			// summary:
			//	Saves the dirty data using REST Ajax methods

			var data = [];
			
			var left = 0; // this is how many changes are remaining to be received from the server
			var _this = this;
			function finishOne(){
				if (!(--left))
					_this.onSave(data);
			}
			while (this._dirtyItems.length > 0){
				var dirty = this._dirtyItems.pop();
				var item = dirty.item;
				var append = false;
				left++;
				var deferred;
				if (item instanceof Array && dirty.old instanceof Array){
					// see if we can just append the item with a post
					append = true;
					for (var i = 0, l = dirty.old.length; i < l; i++){
						if (item[i] != dirty.old[i]){
							append = false;
						}
					}
					if (append){ // if we can, we will do posts to add from here
						for (;i<item.length;i++){
							deferred = this._commitAppend(this.getIdentity(item),item[i]);
							deferred.addCallback(finishOne);
						}
					}
				}
				if (!append){
					deferred = this.service.put(this.getIdentity(item),item);
					deferred.addCallback(finishOne);
				}
				
				data.push(item);
			}
			while (this._deletedItems.length > 0){
				left++;				
				this.service['delete'](this.getIdentity(this._deletedItems.pop())).addCallback(finishOne);
			}
		},


		revert: function(){
			// summary
			//	returns any modified data to its original state prior to a save();

			while (this._dirtyItems.length>0){
				var i;
				var d = this._dirtyItems.pop();
				for (i in d.old){
					d.item[i] = d.old[i];
				}
				for (i in d.item){
					if (!d.old.hasOwnProperty(i))
						delete d.item[i]
				}
			}
			this.onRevert();
		},


		isDirty: function(item){
			// summary
			//	returns true if the item is marked as dirty.
			for (var i=0, l=this._dirtyItems.length; i<l; i++){
				if (this._dirtyItems[i]==item){return true};
			}
		},


		//Notifcation Support

		onSet: function(){
		},

		onNew: function(){

		},

		onDelete: function(){

		},	
	
		onSave: function(items){
			// summary:
			//	notification of the save event..not part of the notification api, 
			//	but probably should be.
			//console.log("onSave() ", items);
		},

		onRevert: function(){
			// summary:
			//	notification of the revert event..not part of the notification api, 
			//	but probably should be.

		}
	}
);


}