/**
 * baseJS is a work-in-progress lightweight JavaScript library.
 * There is currently NO SUPPORT for Internet Explorer.
 * The original intention of this framework is to provide helper methods for iPhone 
 * development for all versions of the iPhone and iPod Touch Safari Browser.
 * Everything also is tested and works in Firefox 2+.
 *
 * Many of the methods and ideals in this document have been taken from Prototype, jQuery, and YUI.
 * Licensed under the Creative Commons Attribution-ShareAlike 3.0 United States.
 *
 * Written by Paul Armstrong
 * Contact: paul@paularmstrongdesigns.com
 * Site: http://paularmstrongdesigns.com/projects/basejs
 *
 * Internal methods and properties start with an underscore. You probably shouldn't use them.
 *
 * Build Date 2008-11-09 @ 21:02:56
 */
 
var userAgent = navigator.userAgent.toLowerCase();
var base = {
    /**
     * Add properties to an object
     * @param arguments         Last argument is the object of properties or methods 
     *                          to apply to the all preceding parameters.
     */
    extend: function() {
        function ext(destination, source) {
            for(var property in source) {
                destination[property] = source[property];
            }
        }
        if(arguments.length == 2) {
            ext(arguments[0], arguments[1])
        } else {
            var l = arguments.length, src = arguments[l-1], i = l-1;
            while(i--) { ext(arguments[i], src); }
        }
    },
    /**
     * Convenience browser checking. Thanks to prototype && jquery.
     * I will hopefully never really need this.
     */
    browser: {
    	version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [])[1],
    	webkit: /webkit/.test(userAgent),
    	opera: /opera/.test(userAgent), // untested
    	msie: /msie/.test(userAgent) && !/opera/.test(userAgent), // watch out for IE -- no support with baseJS
    	mozilla: /mozilla/.test(userAgent) && !/(compatible|webkit)/.test(userAgent),
        msafari: /apple.*mobile.*safari/.test(userAgent)
    },
    /**
     * Check if the object is an array instance.
     * @param object    {object}    Object to check.
     */
    isArray: function(object) {
        return Object.prototype.toString.call(object) === '[object Array]';
    },
    /**
     * Generate a URL-safe query string from the object.
     * @param object    {object}    Object to transcribe into a query string.
     */
    toQueryString: function(object) {
        var params = [];
        for(var key in object) {
            var str = encodeURIComponent(key)+'=';
            var value = (base.isArray(object[key])) ? object[key].join(',') : object[key];
            str += encodeURIComponent(value);
            params.push(str)
        }
        return params.join('&');
    },
    /**
     * Create and fire custom events
     * @param eventName     {string}        Name of the event
     * @param memo          {object}        Memo parameters for the event (optional)
     */
    _fire: function(element, eventName, memo) {
        var event = document.createEvent('HTMLEvents');
        event.initEvent(eventName, true, true);
        event.memo = memo || {};
     
        element.dispatchEvent(event);
    },
    // Whether or not the Query Selectors API are available set via script
    selectors: false,
    // Location of sizzle.js relative to your requested document
    sizzleSrc: '../sizzle/sizzle.js'
};

base.extend(Array.prototype, NodeList.prototype, {
    /**
     * Run a function on each item in the array
     * @param iterator      {function}      Function to run on each object key
     * @param context       {object}        Scope override (optional)
     */
    each: function(iterator, context) {
        iterator = (context) ? iterator.bind(context) : iterator;
        try {
            var c = this.length, i = 0;
            while(i<c) { 
                // make sure it's not a function!
                if(typeof this[i] !== 'function') { iterator(this[i]);}
                i++;
            }
        } catch(e) { throw e; }
        return this;
    },
    /**
     * Run a function on each item in the array after a specified interval
     * @param iterator      {function}      Function to run on each object key
     * @param interval      {Number}        Number of milliseconds before each iteration is run (default 1000)
     * @param dir           {Number}        -1, 1 or null. Negative gives reverse iteration. (optional)
     * @param context       {object}        Scope override (optional)
     * @param callback      {function}      Function to fire after each item has been iterated. (optional)
     */
    eachAfter: function(iterator, interval, dir, context, callback) {
        iterator = (context) ? iterator.bind(context) : iterator;
        callback = callback || function() {};
        var dir = dir || 1;
        var c = this.length, i = 0;
        if(dir < 0) {
            var t = c;
            c = i;
            i = (t == 0) ? 0 : t-1;
        }
        try {
            var eachIterator = setInterval(function() {
                if(i === c) { 
                    if(callback) { callback(); }
                    clearInterval(eachIterator);
                    return this;
                } else {
                    // make sure it's not a function!
                    if(typeof this[i] !== 'function') { iterator(this[i]); }
                    i = i+dir;
                }
            }.bind(this), (interval || 1000));
        } catch(e) { throw e; }
    }
});

base.extend(Function.prototype, {
    /**
     * Override scope of a function.
     * @param oScope     {object}      Object to override the scope of the function.
     * @param arguments  {*}           Any additional arguments to pass.
     */
    bind: function() {
		var method = this, args = Array.prototype.slice.call(arguments), object = args.shift();
		return function() {
			return method.apply(object, args.concat(Array.prototype.slice.call(arguments)));
		}
    },
    /**
     * Override scope of a callback function on an event.
     * @param oScope     {object}      Object to override the scope of the function.
     * @param arguments  {*}           Any additional arguments to pass.
     */
    bindAsEventListener: function() {
        var method = this, args = Array.prototype.slice.call(arguments), object = args.shift();
        return function(event) {
            return method.apply(object, [event || window.event].concat(Array.prototype.slice.call(arguments)));
        }
    }
});

/**
 * io makes a new io object request
 * @param url           {string}        location to access
 * @param options       {object}        (optional)
 *      @param method           {string}        post or get form method
 *      @param asynchronous     {boolean}       Only true supported at this time.
 *      @param contentType      {string}        Content mime type to send.
 *      @param encoding         {string}        Content encoding.
 *      @param params           {object}        Object of header parameters to send with the request.
 *      @param format           {string}        Response type assumption: 'text', 'json', 'object', 'xml'
 *      @param sanitizeJSON     {boolean}       Whether the JSON needs to be sanitized.
 *      @param onUninitialized  {function}      Ready state callback.
 *      @param onConnected      {function}      Ready state callback.
 *      @param onRequested      {function}      Ready state callback.
 *      @param onProcessing     {function}      Ready state callback.
 *      @param onComplete       {function}      Ready state callback. Includes response object.
 *      @param onFailure        {function}      Ready state callback. Includes response object. (recommended)
 *      @param onSuccess        {function}      Ready state callback. Includes response object. (recommended)
 */
var io = function(url, options) {
    this.options = {
        method: 'post', 
        asynchronous: true,
        contentType: 'application/x-www-form-urlencoded',
        encoding: 'UTF-8',
        params: {},
		format: 'text',
		sanitizeJSON: false
    };
    
    base.extend(this.options, options || {});
    this.options.method = this.options.method.toLowerCase();
    
    this.xhr = new XMLHttpRequest();
    
    // convert the params
    var params = base.toQueryString(this.options.params);
    if(this.options.method.toLowerCase() == 'get') {
        url += (url.indexOf('?') >= 0) ? '&' : '?' + params;
    }
    
    try {
        this.xhr.open(this.options.method, url, this.options.asynchronous);

        this.xhr.onreadystatechange = this._onStateChange.bind(this);
        // set the request headers
        var headers = {
          'X-Requested-With': 'XMLHttpRequest',
          'Accept': '*/*'
        };
        if(this.options.method == 'post') {
            headers['Content-type'] = this.options.contentType+(this.options.encoding ? '; charset='+this.options.encoding : '');
        }
        for(var name in headers) {
            this.xhr.setRequestHeader(name, headers[name]);
        }
        
        this._body = this.options.method.toLowerCase() == 'post' ? (this.options.postBody || params) : null;
        this.xhr.send(this._body);
    } catch(e) {
        console.error('request error', e);
    }
};
base.extend(io, {
    /**
     * io.response filters through an io response object to give most concise information possible.
     * @param response      {object}        The XMLHttpRequest object.
     * @param format        {string}        Type to respond with: 'text', 'json', 'object', 'xml'
     * @param sanitize      {boolean}       Whether the JSON needs to be sanitized.
     */
    response: function(response, format, sanitize) {
    	switch(format.toLowerCase()) {
    		case 'xml':
    		    var xml = (response.responseXML) ? response.responseXML : new String('');
    			return xml;
    		break;
    		case 'json':
        	    var json = response.responseText;
        	    if(sanitize) { json = json.sub(/^\/\*-secure-([\s\S]*)\*\/\s*$/, '#{1}'); }
                
        	    try {
                	var str = response.responseText.replace(/\\./g, '@').replace(/"[^"\\\n\r]*"/g, '');
        	    	if((/^[,:{}\[\]0-9.\-+Eaeflnr-u \n\r\t]*$/).test(str)) {
        	    		return eval('('+json+')');
        	    	}
        	    } catch(e) {
        	    	console.error('json eval error', e);
        	    }
    		break;
    		case 'text':
    		    return response.responseText;
    		break;
    		default:
    		    return response;
    		break;
    	}
    }
});

base.extend(io, {
    Events: ['Uninitialized', 'Connected', 'Requested', 'Processing', 'Complete', 'Failure', 'Success']
});
base.extend(io.prototype, {
    _onStateChange: function() {
        var readyState = this.xhr.readyState;
        if(readyState === 4) {
    	    this._complete = true;
        	var res = new io.response(this.xhr, this.options.format, this.options.sanitizeJSON);

        	// if complete, check for onFailure or onSuccess and fire function if available
            if(this.options.onFailure || this.options.onSuccess) {
                var successCode = (!this.xhr.status) ? 5 : (this.xhr.status >= 200 && this.xhr.status < 300) ? 6 : 5;
                (this.options['on'+io.Events[successCode]] || function() {})(res);
            }

        	// if onEvent function is available for this state
        	(this.options['on'+io.Events[readyState]] || function() {})(res);
    	} else if(readyState > 1 && !((readyState == 4) && this._complete)) {
    		(this.options['on'+io.Events[readyState]] || function() {})();
    	}
    }
});

/**
 * HTML Templates that can be filled with object data.
 * @param template  {string}        The markup that will be used for the template.
 */
var Template = function(template) {
    this.template = template;
    return this.template;
}
base.extend(Template.prototype, {
    /**
     * Parse the data object into the template, replacing #{key} with key values.
     * @param object    {object}        Key/value pairs to parse into the template object.
     */
    parse: function(object) {
        this.data = object;
        this.output = this.template;
        // match every instance of #{key} and replace it with what's in the data object
        this.output = this.output.replace(/#\{(\w+)\}/g, this._replaceCallback.bind(this));
        return this.output;
    },
    /**
     * Private method for parsing the template.
     * @param match1    {string}        Matches #{key}
     * @param match2    {string}        Matches key
     */
    _replaceCallback: function(match1, match2) {
        return this.data[match2] || '';
    }
});

/**
 * Simplified element creation function
 * @param type      {string}        The type of element to create.
 * @param atts      {object}        Attributes to attached to the HTMLElement. (optional)
 * @param content   {string}        Set the innerHTML of the element. (optional)
 */
var Element = function(type, atts, content) {
    this.el = document.createElement(type);

    for(var attr in atts) {
        this.el.setAttribute(attr, atts[attr]);
    }
    
    this.el.innerHTML = content || '';
    return this.el;
};

base.extend(String.prototype, {
    /**
     * Check if the string is empty or whitespace only
     */
    blank: function() {
        return /^\s*$/.test(this);
    },
    /**
     * Convert a string into an HTML NodeList
     */
    toHTML: function() {
        var div = document.createElement('div');
        div.innerHTML = this;
        return div.childNodes;
    },
    /**
     * trim trailing whitespace or custom match from a string
     * @param match         {string}        Regular Expression string to trim. (optional)
     */
    trim: function(match) {
        var re = new RegExp(match) || new RegExp(/\s+?/);
        return this.replace(re, '');
    }
});

base.extend(Event.prototype, {
    /**
     * Shortcut to preventDefault and stopPropagation on events.
     */
    stop: function() {
        this.preventDefault();
        this.stopPropagation();
    }
});

base.extend(HTMLElement.prototype, {
    /**
     * Add a className to an element
     * @param className     {string}        Name of the class to add.
     */
    addClass: function(className) {
        if(!this.hasClass(className)) {
            this.className += ' '+className.trim();
        }
        return this;
    },
    /**
     * Check if element has a given class name
     * @param className     {string}        Name of the class to test against.
     */
    hasClass: function(className) {
        var re = new RegExp('(?:^|\\s+)'+className+'(?:\\s+|$)');
        return re.test(this.className);
    },
    /**
     * Remove a className from an element
     * @param className     {string}        Name of the class to remove.
     */
    removeClass: function(className) {
        if(this.hasClass(className)) {
            var re = new RegExp('(?:^|\\s+)'+className+'(?:\\s+|$)');
            this.className = this.className.replace(re, ' ');

            // iterate through in case of multiple adjacent classes
            if(this.hasClass(className)) { this.removeClass(className); } else {
                this.className = this.className.trim();
            }
        }
        return this;
    },
    /**
     * Toggle a className on an element
     * @param className     {string}        Name of the class to remove.
     */
    toggleClass: function(className) {
        if(this.hasClass(className)) {
            this.removeClass(className);
        } else {
            this.addClass(className);
        }
    },
    /**
     * Calculate the cumulative offset from the left and top of the document.
     * Accessible as array [x, y] or objects x||y
     */
    getXY: function() {
        var valueX = 0, valueY = 0;
        var element = this;
        do {
            valueY += element.offsetTop  || 0;
            valueX += element.offsetLeft || 0;
            element = element.offsetParent;
        } while (element);
        var offset = [valueX, valueY];
        offset.x = valueX, offset.y = valueY;
        
        return offset;
    },
    fire: function(eventName, memo) {
        base._fire(this, eventName, memo);
    }
});

base.extend(document, { 
    _loaded: false,
    fire: function(eventName, memo) {
        base._fire(this, eventName, memo);
    }
});

/**
 * Fire a custom 'dom:loaded' event using DOMContentLoaded if available, else use fallback
 * Safari has had native implementation since WebKit 525+
 *
 * Clear console calls if there is no console
 *
 * Create our magic query selector. Load in Sizzle if necessary.
 * $(selector) returns a NodeList
 * @param selector  {string}        CSS query of selectors.
 * @param context   {HTMLElement}   Context for the query. Limits scope of query.
 */
(function() {
    // fire the custom dom:loaded event
    var timer;
    function fireContentLoaded() {
        if(!document._loaded) {
            if(timer) { window.clearInterval(timer); }
        }
        document.fire('dom:loaded');
        document._loaded = true;
    }
    
    // make any failed console calls silent
    if(typeof console !== 'object') {
        console = { 
            log: function() {}, alert: function() {}, warn: function() {}, info: function() {},
            time: function() {}, timeEnd: function() {}, error: function() {}
        };
    }
    if(typeof document.querySelectorAll === 'function') {
        window.$ = function(selector, context) {
            context = (!!context) ? context : document;
            base.selectors = true;
            return context.querySelectorAll(selector);
        }
        document.addEventListener('DOMContentLoaded', fireContentLoaded, false); 

    } else {
        // note that at this time, Sizzle is not Internet Explorer compatible
        console.warn('Selectors API not available. Falling back on Sizzle query selector.');
        
        var sizzle = new Element('script', { type: 'text/javascript', src: base.sizzleSrc });
        sizzle.onload = function() {
            window.$ = Sizzle;
            if(base.browser.webkit && parseInt(base.browser.version) < 525) {
                console.info('DOMContentLoaded not available. Falling back on document.readyState.')
                timer = window.setInterval(function() {
                    if(/loaded|complete/.test(document.readyState)) { fireContentLoaded(); }
                }, 0);
            } else {
                document.addEventListener('DOMContentLoaded', fireContentLoaded, false); 
            }
        };
        sizzle.onerror = function() {
            console.error('Horrible failure getting Sizzle. That sucks.');
        };
        document.getElementsByTagName('head')[0].appendChild(sizzle);
    }
})();