var ApiClient = new Class({
	Extends: Request,
	
	options: {
		// Default option values for the base class
		'headers': {'Accept':'application/json'},
		'method': 'post',
		'evalScripts': false,  // Setting this to true will make the Mootools Request class execute any JS it finds between <script> tags in an api response. Please do not set this to true.
		
		// Igloo specific options below:
		'queryparams': null,														// get added to the URL (can be used in POST and GET requests)
		'postdata': null,															// passed to the Request object later as the 'data' option
		'secretKey': Cookie.read('igloojs').replace("\{","").replace("\}",""),		// used in creating the signature
		'sendimmediately': true,													// immediately send the request once the ApiClient object is created, no more .send(), thanks Ian!
		
		// These api values are combined to create the Request url
		'apibaseurl': document.location.protocol + '//' + document.location.host,
		'apipath': '/.api/api.svc/',
		'apimethod': null,
		'fdata':null,
		'fastsigner':false
	},
	
	initialize: function(options) {
		this.parent(options);
		this.setApiUrl();
		// this is the querystring in the apiurl. This is one ingredient in the crypted sig
		this.setQueryParams(this.options.queryparams);
		if (this.options.sendimmediately && !this.options.sendBlob){
			this.send();
		} else if (this.options.sendimmediately && this.options.sendBlob) {
			this.sendBlob(options.fdata);
		}
	},
	
	setApiUrl: function() {
		this.apiurl = this.options.apibaseurl;
		this.apiurl += this.options.apipath;
		this.apiurl += this.options.apimethod;
	},
	
	setQueryParams: function(params) {
		var apiquerystring = new Hash();
		if (!this.options.fastsigner) {
			apiquerystring.include('apisecure','on');
		}
		if( params ){
			apiquerystring.combine(params);
		}
		if (apiquerystring.getLength() > 0) {
			this.apiurl += "?" + Hash.toQueryString(apiquerystring);
			// OK now we have a very subtle problem.
			// The API expects queryparams containing a "tilde" ~ to be encoded as %7e
			// however our handydandy encodeURIComponent() function does not encode tildes.
			// thus we have to do it to each item in the queryparams before it's assembled into the querystring.
			// we can do this with a simple text replacement because delimiiters are known not to include tildes.
			// be wary that there may be other cases besides tilde
			this.apiurl = this.apiurl.replace('~','%7e').replace("'", '%27');
		}
	},
	
	getRequestUrl: function(returnval) {
		
		// sign the request just before it's sent
		
		var signerOptions = {
			'method': this.options.method,
			'postdata': this.options.postdata,		// passed to the Request object later as the 'data' option
			'secretKey': this.options.secretKey		// used in creating the signature
		
		};
		
		var requesturl = this.apiurl;
		if (!this.options.fastsigner) {
			var clientSigner = new ApiSigner(signerOptions);
			var sig = clientSigner.signRequest(this.apiurl);
			requesturl += (requesturl.indexOf('?') == -1)?'?':'&';
			// add the other ingredients and stir
			requesturl += '&nonce='+clientSigner.nonce;
			requesturl += '&signature='+encodeURIComponent(sig);
		}
		return requesturl;
	},
	
	send: function(query_string) {
		// the user can set 'sendimmediately':false and call the send method passing in a query string like "save=username&name=John"
		if( typeof(query_string) === 'string' ){
			this.setOptions({
				postdata: query_string.parseQueryString()
			});
		}
		
		/* interesting little glitch: if the method is POST and postdata is empty, firefox doesn't send a content-length header. This causes problems deeper in the system. So here we will add some dummy data */
		if(this.options.method == 'post'){
			if(this.options.postdata == null){
				this.options.postdata = {
					'post':'empty'
				}
			}
		}
		
		var requesturl = this.getRequestUrl();
		
		// update the options with the final information needed by Request
		this.setOptions({
			'url': requesturl,
			'data': this.options.postdata
		});
		
		this.parent(query_string);
	},
	sendBlob: function(blob){
		// the user can set 'sendimmediately':false and call the send method passing in a query string like "save=username&name=John"
		if( typeof(blob) === 'string' ){
			this.setOptions({
				postdata: blob.parseQueryString()
			});
		}
		
		var requesturl = this.getRequestUrl();
		
		/* interesting little glitch: if the method is POST and postdata is empty, firefox doesn't send a content-length header. This causes problems deeper in the system. So here we will add some dummy data */
		if(this.options.method == 'post'){
			if(this.options.postdata == null){
				this.options.postdata = {
					'post':'empty'
				}
			}
		}
		
		// update the options with the final information needed by Request
		this.setOptions({
			'url': requesturl,
			'data': this.options.postdata
		});
		this.parent(blob);
	}
	
});

var ApiGetClient = new Class({
	Extends: ApiClient,
	initialize: function(options) {
		options.method = 'get';
		this.parent(options);
		this.setApiUrl();
		// this is the querystring in the apiurl. This is one ingredient in the crypted sig
		this.setQueryParams(this.options.queryparams);
		if (this.options.sendimmediately && !this.options.sendBlob){
			this.send();
		} else if (this.options.sendimmediately && this.options.sendBlob) {
			this.sendBlob(options.fdata);
		}
	}
});

var ApiPostClient = new Class({
	Extends: ApiClient,
	initialize: function(options) {
		options.method = 'post';
		this.parent(options);
		this.setApiUrl();
		// this is the querystring in the apiurl. This is one ingredient in the crypted sig
		this.setQueryParams(this.options.queryparams);
		if (this.options.sendimmediately && !this.options.sendBlob){
			this.send();
		} else if (this.options.sendimmediately && this.options.sendBlob) {
			this.sendBlob(options.fdata);
		}
	}
});

var ApiSigner = new Class ({
	
	Implements: [Options],

	options: {
		'method': 'post',
		'postdata': null,															// passed to the Request object later as the 'data' option
		'secretKey': Cookie.read('igloojs').replace("\{","").replace("\}","")		// used in creating the signature
	},
	
	initialize: function(options) {
		this.setOptions(options);
	},
	
	signRequest: function(apiurl) {
		// right at the moment of sending, generate a new nonce.
		// it mustn't be defined in the initialize method, because then it uses the same nonce every time
		// this way the same api object can be used more than once for repeated requests
		var nonce = this.uniquenonce();
		
		// create the string, as described here -- http://developers.iglooteams.com/wiki/api_signature
		// this string has the format:
		// method : uri nonce (but without the spaces)
		var str = this.options.method.toUpperCase();
		str += ":";
		str += apiurl;
		str += '&' + nonce;
		
		// if posting data, append the postdata to the string
		str += this.options.postdata?Hash.toQueryString(this.options.postdata):'';
		
		// encode the strings into arrays of bytes using a UTF encoder
		var utf8str = CryptoJS.enc.Utf8.stringify(CryptoJS.enc.Utf8.parse(str));
		var utf8secret = CryptoJS.enc.Utf8.stringify(CryptoJS.enc.Utf8.parse(this.options.secretKey));
		
		// Generate the signature with the HMAC-SHA1 algorithm using the UTF8 encoded string and the API secret key
		var cryp = new Crypt.Sha1.Hmac({
			'b64pad': '=',
			'output': 'b64'
		});
		var sig = cryp.encrypt(utf8secret,utf8str);

		// We have the signature. Now let's build the AJAX Request URL
		return sig;
	},
	
	uniquenonce: function() {
		this.nonce = this.nonce || 1;
		this.Date = this.Date || new Date();
		
		var seed = this.Date.getSeconds() + this.nonce;
		this.nonce = Math.floor( Math.random(seed)*1000000000 ) + 1;
		
		return this.nonce;
	}
});

var progressSupport = ('onprogress' in new Browser.Request);
 
/* Extend Request class for allow send Binary Files */
Request.implement({
	sendBlob: function(blob) {
		this.options.isSuccess = this.options.isSuccess || this.isSuccess;
		this.running = true;
		var url = String(this.options.url), method = this.options.method.toLowerCase();
		if (!url) url = document.location.pathname;
		var trimPosition = url.lastIndexOf('/');
		if (trimPosition > -1 && (trimPosition = url.indexOf('#')) > -1) url = url.substr(0, trimPosition);
		//if (this.options.noCache)
		//url += (url.contains('?') ? '&' : '?') + String.uniqueID();
		var xhr = this.xhr;
		if (progressSupport) {
			xhr.onloadstart = this.loadstart.bind(this);
			xhr.onprogress = this.progress.bind(this);
		}
		xhr.open(method.toUpperCase(), url, this.options.async, this.options.user, this.options.password);
		if (this.options.user && 'withCredentials' in xhr) xhr.withCredentials = true;
		xhr.onreadystatechange = this.onStateChange.bind(this);
		Object.each(this.headers, function(value, key){
			try {
				xhr.setRequestHeader(key, value);
			} catch (e){
				this.fireEvent('exception', [key, value]);
			}
		}, this);
		this.fireEvent('request');
		xhr.send(blob);
		if (!this.options.async) this.onStateChange();
		if (this.options.timeout) this.timer = this.timeout.delay(this.options.timeout, this);
		return this;
	} 
});