(function($){

	$.fn.iviewer  = function(o) {
		return this.each(function() {
			$(this).data('viewer', new $iv(this,o));
		});
	}

	var defaults = {
		/**
		* start zoom value for image, not used now
		* may be equal to "fit" to fit image into container or scale in % 
		**/
		zoom: "fit",
		/**
		* base value to scale image
		**/
		zoom_base: 100,
		/**
		* maximum zoom
		**/
		zoom_max: 800,
		/**
		* minimum zoom
		**/
		zoom_min: 25,
		/**
		* base of rate multiplier.
		* zoom is calculated by formula: zoom_base * zoom_delta^rate
		**/
		zoom_delta: 1.4,
		/**
		* if true plugin doesn't add its own controls
		**/
		ui_disabled: false,
		/**
		* if false, plugin doesn't bind resize event on window and this must 
		* be handled manually
		**/
		update_on_resize: true,
		/**
		* event is triggered when zoom value is changed
		* @param int new zoom value
		* @return boolean if false zoom action is aborted
		**/
		onZoom: null,
		/**
		* callback is fired after plugin setup
		**/
		initCallback: null,
		/**
		* event is fired on drag begin
		* @param object coords mouse coordinates on the image
		* @return boolean if false is returned, drag action is aborted
		**/
		onStartDrag: null,
		/**
		* event is fired on drag action
		* @param object coords mouse coordinates on the image
		**/
		onDrag: null,
		/**
		* event is fired when mouse moves over image
		* @param object coords mouse coordinates on the image
		**/
		onMouseMove: null,
		/**
		* mouse click event
		* @param object coords mouse coordinates on the image
		**/
		onClick: null,
		/**
		* event is fired when image starts to load
		*/
		onStartLoad: null,
		/**
		* event is fired, when image is loaded and initially positioned
		*/
		onFinishLoad: null
	};

	$.iviewer = function(e,o) {
		var me = this;

		/* object containing actual information about image
		*   @img_object.object - jquery img object
		*   @img_object.orig_{width|height} - original dimensions
		*   @img_object.display_{width|height} - actual dimensions
		*/
		this.img_object = {};

		this.zoom_object = {}; //object to show zoom status
		this.image_loaded = false;

		//drag variables
		this.dx = 0; 
		this.dy = 0;
		this.dragged = false;

		this.settings = $.extend({}, defaults, o || {});
		this.current_zoom = this.settings.zoom;

		if (this.settings.src === null){
			return;
		}

		this.container = $(e);

		this.update_container_info();

		//init container
		this.container.css("overflow","hidden");

		if (this.settings.update_on_resize == true) {
			$(window).resize(function() {
				me.update_container_info();
			});
		}

		this.img_object.x = 0;
		this.img_object.y = 0;

		//init object
		this.img_object.object = $("<img>").
			css({ position: "absolute", top :"0px", left: "0px"}). //this is needed, because chromium sets them auto otherwise
			//bind mouse events
			mousedown(function(e){ return me.drag_start(e); }).
			mousemove(function(e){return me.drag(e)}).
			mouseup(function(e){return me.drag_end(e)}).
			click(function(e){return me.click(e)}).
			mouseleave(function(e){return me.drag_end(e)}).
			mousewheel(function(ev, delta) {
				//this event is there instead of containing div, because
				//at opera it triggers many times on div
				var zoom = (delta > 0)?1:-1;
				me.zoom_by(zoom);
				return false;
			});

		this.img_object.object.prependTo(me.container);
		this.loadImage(this.settings.src);

		if (!this.settings.ui_disabled) {
			this.createui();
		}

		if (this.settings.initCallback) {
			this.settings.initCallback.call(this);
		}
	}


	var $iv = $.iviewer;

	$iv.fn = $iv.prototype = {
		iviewer : "0.4.2"
	}
	$iv.fn.extend = $iv.extend = $.extend;

	$iv.fn.extend({

		loadImage: function(src) {
			this.current_zoom = this.settings.zoom;
			this.image_loaded = false;
			var me = this;

			if(this.settings.onStartLoad) {
				this.settings.onStartLoad.call(this);
			}

			this.img_object.object.unbind('load').
				removeAttr("src").
				removeAttr("width").
				removeAttr("height").
				css({ top: 0, left: 0 }).
				load(function(){
					me.image_loaded = true;
					me.img_object.display_width = me.img_object.orig_width = this.width;
					me.img_object.display_height = me.img_object.orig_height = this.height;

					if(!me.container.hasClass("iviewer_cursor")) {
						me.container.addClass("iviewer_cursor");
					}

					if(me.settings.zoom == "fit") {
						me.fit();
					} else {
						me.set_zoom(me.settings.zoom);
					}

					if(me.settings.onFinishLoad) {
						me.settings.onFinishLoad.call(me);
					}

					//src attribute is after setting load event, or it won't work
				}).attr("src",src);
		},

		/**
		* fits image in the container
		**/
		fit: function() {
			var aspect_ratio = this.img_object.orig_width / this.img_object.orig_height;
			var window_ratio = this.settings.width /  this.settings.height;
			var choose_left = (aspect_ratio > window_ratio);
			var new_zoom = 0;

			if(choose_left) {
				new_zoom = this.settings.width / this.img_object.orig_width * 100;
			} else {
				new_zoom = this.settings.height / this.img_object.orig_height * 100;
			}

			this.set_zoom(new_zoom);
		},

		/**
		* center image in container
		**/
		center: function() {
			this.setCoords(-Math.round((this.img_object.display_height - this.settings.height)/2),
			-Math.round((this.img_object.display_width - this.settings.width)/2));
		},

		/**
		*   move a point in container to the center of display area
		*   @param x a point in container
		*   @param y a point in container
		**/
		moveTo: function(x, y) {
			var dx = x-Math.round(this.settings.width/2);
			var dy = y-Math.round(this.settings.height/2);

			var new_x = this.img_object.x - this.dx;
			var new_y = this.img_object.y - this.dy;

			this.setCoords(new_x, new_y);
		},

		/**
		* set coordinates of upper left corner of image object
		**/
		setCoords: function(x,y) {
			//do nothing while image is being loaded
			if(!this.image_loaded) {
				return;
			}

			//check new coordinates to be correct (to be in rect)
			if(y > 0){
				y = 0;
			}
			if(x > 0){
				x = 0;
			}
			if(y + this.img_object.display_height < this.settings.height){
				y = this.settings.height - this.img_object.display_height;
			}
			if(x + this.img_object.display_width < this.settings.width){
				x = this.settings.width - this.img_object.display_width;
			}
			if(this.img_object.display_width <= this.settings.width){
				x = -(this.img_object.display_width - this.settings.width)/2;
			}
			if(this.img_object.display_height <= this.settings.height){
				y = -(this.img_object.display_height - this.settings.height)/2;
			}

			this.img_object.x = x;
			this.img_object.y = y;

			this.img_object.object.css("top",y + "px")
			.css("left",x + "px");
		},


		/**
		* convert coordinates on the container to the coordinates on the image (in original size)
		*
		* @return object with fields x,y according to coordinates or false
		* if initial coords are not inside image
		**/
		containerToImage : function (x,y) {
			if(x < this.img_object.x || y < this.img_object.y ||
			x > this.img_object.x + this.img_object.display_width ||
			y > this.img_object.y + this.img_object.display_height) {
				return false;
			}

			return {
				x :  $iv.descaleValue(x - this.img_object.x, this.current_zoom),
				y :  $iv.descaleValue(y - this.img_object.y, this.current_zoom)
			};
		},

		/**
		* convert coordinates on the image (in original size) to the coordinates on the container
		*
		* @return object with fields x,y according to coordinates or false
		* if initial coords are not inside image
		**/
		imageToContainer : function (x,y) {
			if(x > this.img_object.orig_width || y > this.img_object.orig_height) {
				return false;
			}

			return {
				x : this.img_object.x + $iv.scaleValue(x, this.current_zoom),
				y : this.img_object.y + $iv.scaleValue(y, this.current_zoom)
			};
		},

		/**
		* get mouse coordinates on the image
		* @param e - object containing pageX and pageY fields, e.g. mouse event object
		*
		* @return object with fields x,y according to coordinates or false
		* if initial coords are not inside image
		**/
		getMouseCoords : function(e) {
			var img_offset = this.img_object.object.offset();

			return {
				x : $iv.descaleValue(e.pageX - img_offset.left, this.current_zoom),
				y : $iv.descaleValue(e.pageY - img_offset.top, this.current_zoom)
			};
		},

		/**
		* set image scale to the new_zoom
		* @param new_zoom image scale in % 
		**/
		set_zoom: function(new_zoom) {
			if(this.settings.onZoom && this.settings.onZoom.call(this, new_zoom) == false) {
				return;
			}

			//do nothing while image is being loaded
			if(!this.image_loaded) {
				return;
			}

			if(new_zoom <  this.settings.zoom_min) {
				new_zoom = this.settings.zoom_min;
			} else if(new_zoom > this.settings.zoom_max) {
				new_zoom = this.settings.zoom_max;
			}

			/* we fake these values to make fit zoom properly work */
			if(this.current_zoom == "fit") {
				var old_x = Math.round(this.settings.width/2 + this.img_object.orig_width/2);
				var old_y = Math.round(this.settings.height/2 + this.img_object.orig_height/2);
				this.current_zoom = 100;
			} else {
				var old_x = -parseInt(this.img_object.object.css("left"),10) +
				Math.round(this.settings.width/2);
				var old_y = -parseInt(this.img_object.object.css("top"),10) + 
				Math.round(this.settings.height/2);
			}

			var new_width = $iv.scaleValue(this.img_object.orig_width, new_zoom);
			var new_height = $iv.scaleValue(this.img_object.orig_height, new_zoom);
			var new_x = $iv.scaleValue( $iv.descaleValue(old_x, this.current_zoom), new_zoom);
			var new_y = $iv.scaleValue( $iv.descaleValue(old_y, this.current_zoom), new_zoom);

			new_x = this.settings.width/2 - new_x;
			new_y = this.settings.height/2 - new_y;

			this.img_object.object.attr("width",new_width)
				.attr("height",new_height);
			this.img_object.display_width = new_width;
			this.img_object.display_height = new_height;

			this.setCoords(new_x, new_y);

			this.current_zoom = new_zoom;

			$.isFunction( this.settings.onAfterZoom ) && this.settings.onAfterZoom.call( this, new_zoom );
			this.update_status();
		},

		/**
		* changes zoom scale by delta
		* zoom is calculated by formula: zoom_base * zoom_delta^rate 
		* @param Integer delta number to add to the current multiplier rate number 
		**/
		zoom_by: function(delta) {
			var closest_rate = this.find_closest_zoom_rate(this.current_zoom);

			var next_rate = closest_rate + delta;
			var next_zoom = this.settings.zoom_base * Math.pow(this.settings.zoom_delta, next_rate)
			if (delta > 0 && next_zoom < this.current_zoom) {
				next_zoom *= this.settings.zoom_delta;
			}

			if (delta < 0 && next_zoom > this.current_zoom) {
				next_zoom /= this.settings.zoom_delta;
			}

			this.set_zoom(next_zoom);
		},

		/**
		* finds closest multiplier rate for value
		* basing on zoom_base and zoom_delta values from settings
		* @param Number value zoom value to examine
		**/
		find_closest_zoom_rate: function(value) {
			if(value == this.settings.zoom_base) {
				return 0;
			}

			function div(val1,val2) { return val1 / val2 };
			function mul(val1,val2) { return val1 * val2 };

			var func = (value > this.settings.zoom_base)?mul:div;
			var sgn = (value > this.settings.zoom_base)?1:-1;

			var mltplr = this.settings.zoom_delta;
			var rate = 1;

			while(Math.abs(func(this.settings.zoom_base, Math.pow(mltplr,rate)) - value) > 
			Math.abs(func(this.settings.zoom_base, Math.pow(mltplr,rate+1)) - value)) {
				rate++;
			}

			return sgn * rate;
		},

		/* update scale info in the container */
		update_status: function() {
			if(!this.settings.ui_disabled) {
				var percent = Math.round(100*this.img_object.display_height/this.img_object.orig_height);
				if(percent) {
					this.zoom_object.html(percent + "%");
				}
			}
		},

		update_container_info: function() {
			this.settings.height = this.container.height();
			this.settings.width = this.container.width();
		},

		/**
		*   callback for handling mousdown event to start dragging image
		**/
		drag_start: function(e) {
			if(this.settings.onStartDrag && 
				this.settings.onStartDrag.call(this,this.getMouseCoords(e)) == false) {
					return false;
			}

			/* start drag event*/
			this.dragged = true;
			this.container.addClass("iviewer_drag_cursor");

			this.dx = e.pageX - this.img_object.x;
			this.dy = e.pageY - this.img_object.y;
			return false;
		},

		/**
		*   callback for handling mousmove event to drag image
		**/
		drag: function(e) {
			this.settings.onMouseMove && 
			this.settings.onMouseMove.call(this,this.getMouseCoords(e));

			if(this.dragged){
				this.settings.onDrag && 
				this.settings.onDrag.call(this,this.getMouseCoords(e));

				var ltop =  e.pageY -this.dy;
				var lleft = e.pageX -this.dx;

				this.setCoords(lleft, ltop);
				return false;
			}
		},

		/**
		*   callback for handling stop drag
		**/
		drag_end: function(e) {
			this.container.removeClass("iviewer_drag_cursor");
			this.dragged=false;
		},

		click: function(e) {
			this.settings.onClick && 
			this.settings.onClick.call(this,this.getMouseCoords(e));
		},

		/**
		*   create zoom buttons info box
		**/
		createui: function() {
			var me=this; 

			$("<div>").addClass("iviewer_zoom_in").addClass("iviewer_common").
			addClass("iviewer_button").
			mousedown(function(){me.zoom_by(1); return false;}).appendTo(this.container);

			$("<div>").addClass("iviewer_zoom_out").addClass("iviewer_common").
			addClass("iviewer_button").
			mousedown(function(){me.zoom_by(- 1); return false;}).appendTo(this.container);

			$("<div>").addClass("iviewer_zoom_zero").addClass("iviewer_common").
			addClass("iviewer_button").
			mousedown(function(){me.set_zoom(100); return false;}).appendTo(this.container);

			$("<div>").addClass("iviewer_zoom_fit").addClass("iviewer_common").
			addClass("iviewer_button").
			mousedown(function(){me.fit(this); return false;}).appendTo(this.container);

			this.zoom_object = $("<div>").addClass("iviewer_zoom_status").addClass("iviewer_common").
			appendTo(this.container);

			this.update_status(); //initial status update
		}
	});

	$iv.extend({
		scaleValue: function(value, toZoom) {
			return value * toZoom / 100;
		},

		descaleValue: function(value, fromZoom) {
			return value * 100 / fromZoom;
		}
	});

})(jQuery);