/**

 * device.js

 * 

 * WRT v1.1

 * 

/**

 * device object. entry point to device service API (SAPI)

 */

var device = {

	/**

	 * device API public method

	 * 

	 * @method

	 * @param {string} provider Name of service provider, eg, "Service.Calendar"

	 * @param {string} Interface Name of interface, eg, "IDataSource"

	 * @return {Object} service object  

	 */

	getServiceObject: function(provider, Interface){

		if (!device.implementation.context)

			throw 'device implementation object not instantiated!'

		if (device.implementation.options.enabled) 

			return device.implementation.getInterface(provider, Interface);

		else {

			device.implementation.context.notify('device SAPI is disabled.');

			throw 'device not defined!';

		}

	}

};

/**

 * implementation of device emulation mode

 * 

 * @param {String} 		version - version number (default: current version)

 * @return {Object} 	returns new implementation context object 

 * @constructor 		

 */

device.implementation = function(version){

	this.version = version || '';

	// set context to current object

	device.implementation.context = this;	

	var libpath = 'preview/script/lib/',

		datapath = 'preview/data/';

	// load implementation files

	// this is done async by the browser engine, so be aware of sync conditions!!

	if (version == '1')

		loadSAPI(libpath + 'sapi1/');

	else if (!version)

		loadSAPI();

	else

		throw 'unsuppported SAPI version!';

	function loadSAPI(path){

		var path = path || (libpath + "sapi/");

		// load API

		loadScript(path + "AppManager.js");

		loadScript(path + "Calendar.js");

		loadScript(path + "Contact.js");

		loadScript(path + "Landmarks.js");

		loadScript(path + "Location.js");

		loadScript(path + "Logging.js");

		loadScript(path + "MediaManagement.js");

		loadScript(path + "Messaging.js");

		loadScript(path + "Sensor.js");

		loadScript(path + "SysInfo.js");

		// load sample data

		loadScript(datapath + "appManager_data.js");

		loadScript(datapath + "calendar_data.js");

		loadScript(datapath + "contact_data.js");

		loadScript(datapath + "landmarks_data.js");

		loadScript(datapath + "location_data.js");

		loadScript(datapath + "logging_data.js");

		loadScript(datapath + "mediaManagement_data.js");

		loadScript(datapath + "messaging_data.js");

		loadScript(datapath + "sensor_data.js");

		loadScript(datapath + "sysInfo_data.js");

	}

	function loadScript(src){

		var head = document.getElementsByTagName("head")[0] || document.documentElement, 

			script = document.createElement("script");

		script.type = "text/javascript";

		script.src = src;

		head.appendChild(script);

	}

};

(function(){

device.implementation.prototype = {

	/**

	 * Result object

	 * 

	 * object returned by API calls

	 * 

	 * @param {Object} value

	 * @param {Integer} code

	 * @param {String} msg

	 */

	Result : function(value, code, msg){

		return {

			ReturnValue	: value,

			ErrorCode	: code || 0,

			ErrorMessage: msg || undefined

		};

	},

	/**

	 * AsyncResult object

	 * 

	 * object returned by API calls with callbacks

	 * 

	 * @param {Integer} transaction id

	 * @param {Integer} code

	 * @param {String} msg

	 */

	AsyncResult : function(id, code, msg){

		return {

			TransactionID	: id,

			ErrorCode		: code || 0,

			ErrorMessage	: msg || undefined

		};

	},

	/**

	 * ErrorResult object

	 * 

	 * object returned by API calls when error

	 * 

	 * @param {Integer} code

	 * @param {String} msg

	 */

	ErrorResult : function(code, msg){

		device.implementation.context.debug(code, msg);		

		return {

			ErrorCode	: code || 0,

			ErrorMessage: msg || undefined

		};

	},

	/**

	 * Iterator object

	 * 

	 * object returned as ReturnValue by some API

	 * 

	 * @param {Array} data

	 */

	Iterator : function(data){

		var index = 0,

			data = data || [];

		return {

			/**

			 * reset

			 */

			reset : function(){

				index = 0;

			},

			/**

	 		* getNext

	 		*/

			getNext : function(){

				return index < data.length ? data[index++] : undefined;

			}

		}

	},

	/**

	 * internal __methods__

	 */

	$break: 	{}, // 'not implemented',

	debug: function() {

		if (device.implementation.options.debug && window.console && console.log) 

			console.log(arguments);

	},

	// notify developer of api action

	notify: function(msg){

		if (window.console && console.warn)

			console.warn('API Notice -- ' + msg);

	},

	getData : function(provider){

		if (!device.implementation.data[provider])

			throw "no data defined for provider '"+provider+"'";

		if (device.implementation.data[provider]['default'])

			return device.implementation.data[provider]['default'];

		else 

			return device.implementation.data[provider]; 

	},	

	getUniqueID : function(){

		return Number(''+Number(new Date())+ Math.floor(1000*Math.random()));

	},

	callAsync : function(object, method, criteria, callback, flag){

		flag = flag || false;

		var tid = setTimeout(function(){

			var result,

				eventCode = {completed:2, error:4, progress:9},

				code = eventCode.completed;

			try{

				// call method in object's context

				// flag is passed to trigger the method in case of mandatory callback arg

				if (flag)

					result = method.call(object, criteria, null, flag);

				else

					result = method.call(object, criteria);

			} 

			catch(e){

				code = eventCode.error;

			}

			callback(tid, code, result);

		}, device.implementation.options.callbackDelay);

		return this.AsyncResult(tid);

	},

	addListener : function(provider, eventType, criteria, callback, handler){

		if (!device.implementation.listeners[provider])

			device.implementation.listeners[provider] = {};

		var tid = this.getUniqueID();

		device.implementation.listeners[provider][eventType] = {

			'criteria': criteria,

			'callback': callback,

			'handler': handler,

			'transactionID' : tid

		};

		return this.AsyncResult(tid);

	},

	/*

	 * specify either eventType or transactionID

	 * return true if found and removed

	 */

	removeListener: function(provider, eventType, transactionID){

		transactionID = transactionID || null;

		if (transactionID) {

			var allEvents = device.implementation.listeners[provider];

			for (var i in allEvents) {

				var event = allEvents[i];

				if (event.transactionID == transactionID) {

					device.implementation.listeners[provider][i] = null;

					delete device.implementation.listeners[provider][i];

					return true;

				}

			}

		}

		else 

			if (eventType &&

			this.hasListener(provider, eventType)) {

				device.implementation.listeners[provider][eventType] = null;

				delete device.implementation.listeners[provider][eventType];

				return true;

			}

		return false;

	},

	hasListener: function(provider, eventType) {	

		if (!device.implementation.listeners[provider]

			|| !device.implementation.listeners[provider][eventType])

			return false;

		return true;

	},

	// pluck object properties as array	

	keys: function(obj) {

		var keys = [];

		for (var p in obj)

			keys.push(p);

		return keys;

	},

	// extend object properties 

	extend: function(root, ext) {

		for (var p in ext)

			root[p] = ext[p];

		return root;

	},

	// extended text string functionality 

	_t: function(str){

		str = typeof str != 'undefined' ? String(str) : '';

		return new StringEx(str);

	}		

};

	/**

	 * extended String object (available only within device.implementation.context through _t() method)

	 */ 

	var StringEx = function(str){

		// define base String non-transferrable methods!

		this.toString = function(){return str;};

		this.valueOf = function(){return str.valueOf();};

	};

	StringEx.prototype = new String();

	/**

	 * simple sprintf-type functionality

	 * 

	 * "string {title} %s and %s and {here} ".arg({title:'T', here:'H'}, 1, 'there')"

	 * ==> string T 1 and there and H

	 * hash (if present) must be first argument

	 *

	 * @param {Object} [hash] optional hash to replace {tags}

	 * @param {String,Number} data for %s tags

	 * @return {String} original string with tags replaced   

	 */

	StringEx.prototype.arg = function(){

	    var pattern = /\%s|\{\w+\}/g;

	    var args = arguments, 

			len = arguments.length, 

			hash = arguments[0],

			i = typeof hash == 'object' && !(hash instanceof String) ? 1 : 0;

	    return this.replace(pattern, function(capture){

			var key = capture != '%s' && capture.match(/\w+/);

			if (key)

				return hash && hash[key] ? hash[key] : capture;

			else		

				return i < len ? args[i++] : capture;

		});

	}

	/**

	 * trim whitespace from beginning and end of string

	 * @return {String} trimmed string

	 */

	StringEx.prototype.trim = function(){

		return this.replace(/^\s+/, '').replace(/\s+$/, '');

	}

	/**

	 * capitalize string

	 * @return {String} capitalized string

	 */

	StringEx.prototype.capitalize = function(){

    	return this.charAt(0).toUpperCase() + this.substring(1).toLowerCase();

	}

})();

/*

 * device.implementation static (class) properties

 */

/**

 * pointer to current instantiated device.implementation object.

 * use to access device.implemenation namespace.

 * 

 * @see device.implementation 

 */

device.implementation.context = null;	

/**

 * emulation settings options

 */

device.implementation.options = {

	/**

	 * callback delay (msec)

	 * @property {Number} 

	 */

	callbackDelay	: 1200,

	/**

	 * debug flag

	 * @property {Boolean} 

	 */

	debug			: false,

	/**

	 * enabled flag

	 * @property {Boolean} 

	 */

	enabled			: true

};

/**

 * store of interfaces (objects) in the current device implementation.

 * format: [provider][interface]

 * 

 * @property {Object} 

 */

device.implementation.interfaces = {};

/**

 * store of data objects defined for current implementation.

 * data is added useing the loadData method. 

 * 

 * @property {Object} format depends on data

 */

device.implementation.data = {};

/**

 * store of event listeners

 * format: [provider][eventType]

 */

device.implementation.listeners = {}; 

/*

 * device.implementation static (class) methods

 */

/**

 * Add a service provider to device implementation

 * 

 * @param {string} provider Name of service provider, eg, "Service.Calendar"

 * @param {string} Interface Name of interface, eg, "IDataService"

 * @param {Object} serviceProvider Service object

 * @return  none

 */

device.implementation.extend = function(provider, Interface, serviceProvider){

	if (!device.implementation.interfaces[provider])

		device.implementation.interfaces[provider] = {}; 

	device.implementation.interfaces[provider][Interface] = serviceProvider;

};

/**

 * Internal implementation to return a service provider interface object

 * 

 * @param {String} provider  Service provider name 

 * @param {String} Interface	Provider interface name

 * @exception {String} exception thrown if provider or interface is not implemented 

 * @return {Object} the service provider interface object or 'undefined'

 */	

device.implementation.getInterface = function(provider, Interface){

	if (device.implementation.interfaces[provider] 

		&& typeof device.implementation.interfaces[provider][Interface] == 'object') 

	{

		var service = new Object();

		service[Interface] = device.implementation.interfaces[provider][Interface];

		return service;

	}

	else

		throw 'Error: unknown error'; 

};

/**

 * Loads data to the data store

 * 

 * @param {String} provider  Service provider name 

 * @param {String} type Data name/label

 * @param {Function,Object,Array} dataFactory Function to generate the data object, or array/object

 * @return none

 */

device.implementation.loadData = function(provider, type, dataFactory){

	type = type || 'default';

	if (!device.implementation.data[provider]) 

		device.implementation.data[provider] = {};

	device.implementation.data[provider][type] = 

		typeof dataFactory == 'function' 

			? dataFactory()

			: dataFactory;

};

/**

 * trigger an event listener

 * 

 * @param {String} provider Service provider name

 * @param {String} eventType event type 

 * @param {Variant} data ReturnValue for callback function 

 */

device.implementation.triggerListener = function(provider, eventType, data){

	if (!device.implementation.context.hasListener(provider, eventType)) {

		device.implementation.context.notify('no listener defined for provider=' + provider + ', eventType=' + eventType);

		return;

	}

	var listener = device.implementation.listeners[provider][eventType];

	// call the provider's handler

	listener.handler(listener.transactionID, listener.criteria, listener.callback, data);

}