var VG = VG || {};
VG.utils = VG.utils || {};


/**
 * Rende un clone del Prototype passato
 */
VG.utils.CloneProto = function (proto) {
	var F = function () {};
	F.prototype = proto;
	return new F();
}; 


/**
 * 
 * @param tgW
 * @param tgH
 * @param contW
 * @param contH
 * @param fitType
 * @param perc
 */
VG.utils.Fit = function (tgRapp, contW, contH, fitType, zoomRatio, usePerc) {
	var _tgRapp = tgRapp;
	var _contW = contW;
	var _contH = contH;
	var _fitType = fitType;
	var _zoomRatio = zoomRatio || 1;
	var _usePerc = usePerc || true;
	
//	var _tgRapp;
	var _contRapp;
	var _w;
	var _h;
	
	this.width;
	this.height;
	
	_init();
	
	this.width = _w;
	this.height = _h;
	
	function _init() {
		_contRapp = _contW / _contH;
		
		if ( _fitType == "fitOut" ) {
			calcolaOUT();
		}
		else if ( _fitType == "fitIn" ) {
			calcolaIN();
		}
	}
	
	function calcolaOUT () {
		if (_contRapp >= _tgRapp)
		{
			_w = (_usePerc) ? (_contW * _zoomRatio) : (_contW + _zoomRatio);
			_h = _w / _tgRapp;
		}
		else
		{
			_h = (_usePerc) ? (_contH * _zoomRatio) : (_contH + _zoomRatio);
			_w = _h * _tgRapp;
		}
	}
	
	function calcolaIN () {
		if (_contRapp <= _tgRapp)
		{
			_w = (_usePerc) ? (_contW * _zoomRatio) : (_contW + _zoomRatio);
			_h = _w / _tgRapp;
		}
		else
		{
			_h = (_usePerc) ? (_contH * _zoomRatio) : (_contH + _zoomRatio);
			_w = _h * _tgRapp;
		}
	}
};



/**
 * Centra un elemento, non � necesserio che sia posizionato absolute
 * 
 * @param tg
 * @param contW
 * @param contH
 */
VG.utils.Center = function (tg, contW, contH) {
	
	var _tg = $(tg);
	var _tgW = _tg.width();
	var _tgH = _tg.height();
	var _contW = contW;
	var _contH = contH;
	var _left = Math.round((_contW - _tgW) * .5);
	var _top = Math.round((_contH - _tgH) * .5);
	
	
	_tg.css("margin-left", _left + "px");
	_tg.css("margin-top", _top + "px");
};
	




/**
 * Rende il dispositivo corrente.
 * 
 * Attenzione: utilizza la stringa UserAgent che non � di sola lettura (l'utente pu� impostarla)
 * 
 * TODO : specificare meglio i dispositivi, si potrebbe creare
 * un oggetto con le propriet�: famiglia/dispositivo/versione ecc...
 */
VG.utils.SniffDevice = function () {
	
	var d;
	var usAgent = navigator.userAgent;
	if (usAgent.match("iPhone")) {
		d = VG.C.IPHONE;
	} else if (usAgent.match("iPad")) {
		d = VG.C.IPAD;
	} else if (usAgent.match("iPod")) {
		d = VG.C.IPOD;
	} else if (usAgent.match("Windows")) {
		d = VG.C.WIN;
	} else if (usAgent.match("Mac")) {
		d = VG.C.MAC;
	} else if (usAgent.match("Android")) {
		d = VG.C.ANDROID;
	} else {
		d = VG.C.SOME_DEVICE;
	}
	return d;
};


/**
 * Rende l'orientamento.
 * 
 * * TODO : implementare scelta default / rilevamento tipo browser
 * 
 */
VG.utils.GetOrientation = function () {
	
	var or;
	var numOr = Math.abs(window.orientation);
	if (numOr == 0 || numOr == 180) {
		or = VG.C.OR_VER;
	} else {
		or = VG.C.OR_HOR;
	}
	return or;
};


/*
if (VG.utils.GetOrientation == VG.C.OR_HOR) {
	// operazione per orizzontale
} else {
	// operazione per verticale
}
*/

/**
 * Calcolo delle proporzioni
 */
VG.utils.CenterPointer = function () {
	
	
	// VARIABILI PRIVATE
	
	var _startPointMain;	// Number;
	var _endPointMain;		// Number;
	var _startPointSec;		// Number;
	var _endPointSec;		// Number;
	var _limit;				// Boolean
	
	
	
	// METODI PUBBLICI
	
	/**
	 * La prima misura della proporzione (la posizione che verr� PASSATA � in questo intervallo)
	 * 
	 * @param startPoint	inizio
	 * @param endPoint		fine
	 * @param limit			
	 */
	VG.utils.CenterPointer.prototype.setMain = function (startPoint/*Number*/, endPoint/*Number*/, limit/*Boolean*/) {
		_limit = limit || true;
		_startPointMain = startPoint;
		_endPointMain = endPoint;
		
//		console.log(_startPointMain);
//		console.log(_endPointMain);
		
	};
	
	/**
	 * La seconda misura della proporzione (la posizione che verr� RESA � in questo intervallo)
	 * 
	 * @param startPoint	inizio
	 * @param endPoint		fine
	 */
	VG.utils.CenterPointer.prototype.setSecondary = function (startPoint/*Number*/, endPoint/*Number*/) {
		_startPointSec = startPoint;
		_endPointSec = endPoint;
		
//		console.log(_startPointSec);
//		console.log(_endPointSec);
	};
	
	/**
	 * Rende la posizione sulla seconda misura in base alla posizione sulla prima misura
	 * 
	 * @param mainPoint		punto sulla prima misura
	 */
	VG.utils.CenterPointer.prototype.getPosition = function (mainPoint/*Number*/)/*Number*/ {
		var percMain/*Number*/ = _findPercFromPoint(mainPoint);
		var pointSec/*Number*/ = _findPointFromPerc(percMain);
		return pointSec;
	};
	
	
	// METODI PRIVATI
	
	function _findPercFromPoint(point/*Number*/) {
		
		if (_limit) {
			if (point < _startPointMain) point = _startPointMain;
			else if (point > _endPointMain) point = _endPointMain;
		}
		var intervallo/*Number*/ = _endPointMain - _startPointMain;
		var pointInIntervallo/*Number*/ = point - _startPointMain;
		var perc/*Number*/ = ( pointInIntervallo * 100 ) / intervallo;
		return perc;
	};
	
	function _findPointFromPerc(perc/*Number*/)/*Number*/ {
		var intervallo/*Number*/ = _endPointSec - _startPointSec;
		var point/*Number*/ = ( perc * intervallo ) / 100;
		var pointInInterval/*Number*/ = point + _startPointSec;
		return pointInInterval;
	};
	
};



/**
 * Formula di Zenone
 * 
 * @param start		Number > posizione di partenza
 * @param finish	Number > posizione di arrivo
 * @param vel		Number > velocit� di avvicinamento all'arrivo
 * 
 * @returns			Number > nuova posizione
 */
VG.utils.Zenone = function (start/*Number*/, finish/*Number*/, vel/*Number*/)/*Number*/ {
	
	// VAR PRIVATE
	var _start = start;
	var _finish = finish;
	var _vel = vel;
	
	
	VG.utils.Zenone.prototype.posizione = function ()/*Number*/ {
		return _start + ( (_finish - _start) / _vel );
	};
	
};