/**
* smartupdater - jQuery Plugin
*  
* Version - 4.0.beta 
* Copyright (c) 2010 - 2011 Vadim Kiryukhin
* vkiryukhin @ gmail.com
* 
* http://www.eslinstructor.net/smartupdater/
*
* Dual licensed under the MIT and GPL licenses:
*   http://www.opensource.org/licenses/mit-license.php
*   http://www.gnu.org/licenses/gpl.html
*
* USAGE:
*
*	$("#myObject").smartupdater({
*			url : "foo.php"
*			}, function (data) {
*				//process data here;
*			}
*		);
*		
*	Public functions:
*		$("#myObject").smartupdater("stop")
*		$("#myObject").smartupdater("restart");
*		$("#myObject").smartupdater("setTimeout",timeout);
*		$("#myObject").smartupdater("alterUrl"[,"foo.php"[,data]]); 
*		$("#myObject").smartupdater("alterCallback"[, foo]); 
*
*	Public Attributes:
*		var status  = $("#myObject").smartupdater("getState"); 
*		var timeout = $("#myObject").smartupdater("getTimeout");
*
**/

(function($) {


		var methods = {
		
			init : function( options, callback) {
				return this.each(function () {
					var elem = this,
					es = {};

					elem.settings = jQuery.extend(true,{
						url					: '',		// see jQuery.ajax for details
						type				: 'get', 	// see jQuery.ajax for details
						data				: '',   	// see jQuery.ajax for details
						dataType			: 'text', 	// see jQuery.ajax for details
								
						minTimeout			: 60000, 	// 1 minute
						maxFailedRequests 	: 10, 		// max. number of consecutive ajax failures
						maxFailedRequestsCb	: false, 	// falure callback function
						httpCache 			: false,	// http cache 
						rCallback			: false,	// remote callback functions
						selfStart			: true,		// start automatically after initializing
						smartStop			: { active:			false, 	//disabled by default
												monitorTimeout:	2500, 	// 2.5 seconds
												minHeight:		1,	  	// 1px
												minWidth:		1	  	// 1px	
											  } 

					}, options);
						
					elem.smartupdaterStatus = {state:'',timeout:0};

					es = elem.settings;
						
					es.prevContent 		= '';
					es.failedRequests	= 0;
					es.etag 			= '0';
					es.lastModified 	= '0';
					es.callback 		= callback;
					es.origReq = {url:es.url,data:es.data,callback:callback};
					es.stopFlag = false;
				
					
					function start() {
					
					/* check if element has been deleted and clean it up  */
						if(!$(elem).parents('body').length) {
								clearInterval(elem.smartupdaterStatus.smartStop);
								clearTimeout(elem.settings.h);
								elem = {};
								return;
						} 
					
						$.ajax({
							url		: es.url,
							type	: es.type,
							data	: es.data,
							dataType: es.dataType,
							cache	: false, // MUST be set to false to prevent IE caching issue.

							success: function (data, statusText, xhr) {
							
								var dataNotModified = false, 
									rCallback = false, 
									xSmart = jQuery.parseJSON(xhr.getResponseHeader("X-Smartupdater")),
									xhrEtag, xhrLM;
								
								if(xSmart) { // remote control 
								
									/* remote timeout */
									es.minTimeout = xSmart.timeout ? xSmart.timeout : es.minTimeout;
									
									/* remote callback */
									rCallback = xSmart.callback ? xSmart.callback : false;
								}
								
								if(es.httpCache) { // http cache process here
								
									xhrEtag = xhr.getResponseHeader("ETag");
									xhrLM = xhr.getResponseHeader("Last-Modified");
									
									dataNotModified = (es.etag ==  xhrEtag || es.lastModified == xhrLM) ? true : false;
									es.etag 		=  xhrEtag ? xhrEtag : es.etag;
									es.lastModified =  xhrLM   ? xhrLM   : es.lastModified;
								}
								
								if ( 	dataNotModified || 
										es.prevContent == xhr.responseText || 
										xhr.status == 304 ) { // data is not changed 
										
										if(!es.stopFlag) {
											clearTimeout(es.h);
											es.h = setTimeout(start, es.minTimeout);
										}
											
								} else { // data is changed 

								/* cache response data */
									es.prevContent = xhr.responseText;
									
								/* reset timeout */
									if(!es.stopFlag) {
										clearTimeout(es.h);
										es.h = setTimeout(start, es.minTimeout);
									}
									
								/* run callback function */
									if(es.rCallback && rCallback && es.rCallback.search(rCallback) != -1) {
										window[rCallback](data);
									} else  { 
										es.callback(data);
									}
								}
								
								elem.smartupdaterStatus.timeout = es.minTimeout;
								es.failedRequests = 0;
							}, 
									
							error: function(xhr, textStatus, errorThrown) { 
								if ( ++es.failedRequests < es.maxFailedRequests ) {
								
								/* increment falure counter and reset timeout */
									if(!es.stopFlag) {
										clearTimeout(es.h);
										es.h = setTimeout(start, es.minTimeout);
										elem.smartupdaterStatus.timeout = es.minTimeout;
									}
									
								} else {
								
								/* stop smartupdater */
									clearTimeout(es.h);
									elem.smartupdaterStatus.state = 'OFF';
									if( typeof(es.maxFailedRequestsCb)==='function') {
										es.maxFailedRequestsCb(xhr, textStatus, errorThrown);
									}
								}
							},
							
							beforeSend: function(xhr, settings) {
							
								if(es.httpCache) {
								
								/* set http cache-related headers */
									xhr.setRequestHeader("If-None-Match", es.etag );
									xhr.setRequestHeader("If-Modified-Since", es.lastModified );
								}
								
							/* Feedback: Smartupdater sends it's current timeout to server */
								xhr.setRequestHeader("X-Smartupdater", '{"timeout":"'+elem.smartupdaterStatus.timeout+'"}');
							}
						});
						
						elem.smartupdaterStatus.state = 'ON';
					} 
						
					es.fnStart = start;
					
					if(es.selfStart) {
						start();
					}
					
					if(es.smartStop.active) {
					
						elem.smartupdaterStatus.smartStop = setInterval(function(){

							// check if object has been deleted 
							if(!$(elem).parents('body').length) {
								clearInterval(elem.smartupdaterStatus.smartStop);
								clearTimeout(elem.settings.h);
								elem = {};
								return;
							} 

							var $elem = $(elem);
							var width =  $elem.width(),
								height = $elem.height(),
								hidden = $elem.is(":hidden");
								
							//element has been expanded, so smartupdater should be re-started.
							if(!hidden && height > es.smartStop.minHeight && width > es.smartStop.minWidth 
								 && elem.smartupdaterStatus.state=="OFF") {
								$elem.smartupdater("restart");
							} else 	
							//element has been minimized, so smartupdater should be stopped.
							if( (hidden || height <= es.smartStop.minHeight || width <= es.smartStop.minWidth) 
									&& elem.smartupdaterStatus.state=="ON") {
								$elem.smartupdater("stop");

							} 
							
						},es.smartStop.monitorTimeout);
					}
					
				});

			},// init()
			
			stop : function () {
				return this.each(function () {
					this.settings.stopFlag = true;
					clearTimeout(this.settings.h);
					this.smartupdaterStatus.state = 'OFF';
				});
			}, 
			
			restart : function () {        
				return this.each(function () {
					this.settings.stopFlag = false;
					clearTimeout(this.settings.h);
					this.settings.failedRequests = 0;
					this.settings.etag = "0";
					this.settings.lastModified = "0";
					this.settings.fnStart();
				})
			},
			
			setTimeout : function (period) {
				return this.each(function () {
					clearTimeout(this.settings.h);
					this.settings.minTimeout = period;
					this.settings.fnStart();
				});
			}, 
			
			alterCallback : function (callback) {
				return this.each(function () {
					this.settings.callback  = callback	? callback 	: this.settings.origReq.callback;
				});
			}, 
			
			alterUrl : function (url,data) {
				return this.each(function () {
					this.settings.url 	= url 	? url : this.settings.origReq.url;
					this.settings.data	= data 	? data : this.settings.origReq.data;
				});
			},
			
			getTimeout : function () {
				return this[0].smartupdaterStatus.timeout;
			},
			
			getState : function () {
				return this[0].smartupdaterStatus.state;
			}
			
		}; //methods
		
	jQuery.fn.smartupdater = function (options, callback) {	
	
		if ( methods[options] ) {
			return methods[ options ].apply( this, Array.prototype.slice.call( arguments, 1 ));
		} else if ( typeof options === 'object' || ! method ) {
			return methods.init.apply( this, arguments );
		} else {
			$.error( 'Method ' +  options + ' does not exist on jQuery.tooltip' );
		}
	}; 

	
})(jQuery);