/*! AutoFill 1.2.0
 * ©2008-2014 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     AutoFill
 * @description Add Excel like click and drag auto-fill options to DataTables
 * @version     1.2.0
 * @file        dataTables.autoFill.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2010-2014 SpryMedia Ltd.
 *
 * This source file is free software, available under the following license:
 *   MIT license - http://datatables.net/license/mit
 *
 * This source file is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the license files for details.
 *
 * For details please refer to: http://www.datatables.net
 */

(function (window, document, undefined) {

	var factory = function ($, DataTable) {
		"use strict";

		/**
		 * AutoFill provides Excel like auto-fill features for a DataTable
		 *
		 * @class AutoFill
		 * @constructor
		 * @param {object} oTD DataTables settings object
		 * @param {object} oConfig Configuration object for AutoFill
		 */
		var AutoFill = function (oDT, oConfig) {
			/* Sanity check that we are a new instance */
			if (!(this instanceof AutoFill)) {
				throw( "Warning: AutoFill must be initialised with the keyword 'new'" );
			}

			if (!$.fn.dataTableExt.fnVersionCheck('1.7.0')) {
				throw( "Warning: AutoFill requires DataTables 1.7 or greater");
			}


			/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
			 * Public class variables
			 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

			this.c = {};

			/**
			 * @namespace Settings object which contains customisable information for AutoFill instance
			 */
			this.s = {
				/**
				 * @namespace Cached information about the little dragging icon (the filler)
				 */
				"filler": {
					"height": 0,
					"width": 0
				},

				/**
				 * @namespace Cached information about the border display
				 */
				"border": {
					"width": 2
				},

				/**
				 * @namespace Store for live information for the current drag
				 */
				"drag": {
					"startX": -1,
					"startY": -1,
					"startTd": null,
					"endTd": null,
					"dragging": false
				},

				/**
				 * @namespace Data cache for information that we need for scrolling the screen when we near
				 *   the edges
				 */
				"screen": {
					"interval": null,
					"y": 0,
					"height": 0,
					"scrollTop": 0
				},

				/**
				 * @namespace Data cache for the position of the DataTables scrolling element (when scrolling
				 *   is enabled)
				 */
				"scroller": {
					"top": 0,
					"bottom": 0
				},

				/**
				 * @namespace Information stored for each column. An array of objects
				 */
				"columns": []
			};


			/**
			 * @namespace Common and useful DOM elements for the class instance
			 */
			this.dom = {
				"table": null,
				"filler": null,
				"borderTop": null,
				"borderRight": null,
				"borderBottom": null,
				"borderLeft": null,
				"currentTarget": null
			};


			/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
			 * Public class methods
			 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

			/**
			 * Retreieve the settings object from an instance
			 *  @method fnSettings
			 *  @returns {object} AutoFill settings object
			 */
			this.fnSettings = function () {
				return this.s;
			};


			/* Constructor logic */
			this._fnInit(oDT, oConfig);
			return this;
		};


		AutoFill.prototype = {
			/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
			 * Private methods (they are of course public in JS, but recommended as private)
			 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

			/**
			 * Initialisation
			 *  @method _fnInit
			 *  @param {object} dt DataTables settings object
			 *  @param {object} config Configuration object for AutoFill
			 *  @returns void
			 */
			"_fnInit": function (dt, config) {
				var
					that = this,
					i, iLen;

				// Use DataTables API to get the settings allowing selectors, instances
				// etc to be used, or for backwards compatibility get from the old
				// fnSettings method
				this.s.dt = DataTable.Api ?
					new DataTable.Api(dt).settings()[0] :
					dt.fnSettings();
				this.s.init = config || {};
				this.dom.table = this.s.dt.nTable;

				$.extend(true, this.c, AutoFill.defaults, config);

				/* Add and configure the columns */
				this._initColumns();

				/* Auto Fill click and drag icon */
				var filler = $('<div/>', {
					'class': 'AutoFill_filler'
				})
					.appendTo('body');
				this.dom.filler = filler[0];

				// Get the height / width of the click element
				this.s.filler.height = filler.height();
				this.s.filler.width = filler.width();
				filler[0].style.display = "none";

				/* Border display - one div for each side. We can't just use a single
				 * one with a border, as we want the events to effectively pass through
				 * the transparent bit of the box
				 */
				var border;
				var appender = document.body;
				if (that.s.dt.oScroll.sY !== "") {
					that.s.dt.nTable.parentNode.style.position = "relative";
					appender = that.s.dt.nTable.parentNode;
				}

				border = $('<div/>', {
					"class": "AutoFill_border"
				});
				this.dom.borderTop = border.clone().appendTo(appender)[0];
				this.dom.borderRight = border.clone().appendTo(appender)[0];
				this.dom.borderBottom = border.clone().appendTo(appender)[0];
				this.dom.borderLeft = border.clone().appendTo(appender)[0];

				/* Events */
				filler.on('mousedown.DTAF', function (e) {
					this.onselectstart = function () {
						return false;
					};
					that._fnFillerDragStart.call(that, e);
					return false;
				});

				$('tbody', this.dom.table).on(
					'mouseover.DTAF mouseout.DTAF',
					'>tr>td, >tr>th',
					function (e) {
						that._fnFillerDisplay.call(that, e);
					}
				);

				$(this.dom.table).on('destroy.dt.DTAF', function () {
					filler.off('mousedown.DTAF').remove();
					$('tbody', this.dom.table).off('mouseover.DTAF mouseout.DTAF');
				});
			},


			_initColumns: function () {
				var that = this;
				var i, ien;
				var dt = this.s.dt;
				var config = this.s.init;

				for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
					this.s.columns[i] = $.extend(true, {}, AutoFill.defaults.column);
				}

				dt.oApi._fnApplyColumnDefs(
					dt,
					config.aoColumnDefs || config.columnDefs,
					config.aoColumns || config.columns,
					function (colIdx, def) {
						that._fnColumnOptions(colIdx, def);
					}
				);

				// For columns which don't have read, write, step functions defined,
				// use the default ones
				for (i = 0, ien = dt.aoColumns.length; i < ien; i++) {
					var column = this.s.columns[i];

					if (!column.read) {
						column.read = this._fnReadCell;
					}
					if (!column.write) {
						column.read = this._fnWriteCell;
					}
					if (!column.step) {
						column.read = this._fnStep;
					}
				}
			},


			"_fnColumnOptions": function (i, opts) {
				var column = this.s.columns[ i ];
				var set = function (outProp, inProp) {
					if (opts[ inProp[0] ] !== undefined) {
						column[ outProp ] = opts[ inProp[0] ];
					}
					if (opts[ inProp[1] ] !== undefined) {
						column[ outProp ] = opts[ inProp[1] ];
					}
				};

				// Compatibility with the old Hungarian style of notation
				set('enable', ['bEnable', 'enable']);
				set('read', ['fnRead', 'read']);
				set('write', ['fnWrite', 'write']);
				set('step', ['fnStep', 'step']);
				set('increment', ['bIncrement', 'increment']);
			},


			/**
			 * Find out the coordinates of a given TD cell in a table
			 *  @method  _fnTargetCoords
			 *  @param   {Node} nTd
			 *  @returns {Object} x and y properties, for the position of the cell in the tables DOM
			 */
			"_fnTargetCoords": function (nTd) {
				var nTr = $(nTd).parents('tr')[0];
				var position = this.s.dt.oInstance.fnGetPosition(nTd);

				return {
					"x": $('td', nTr).index(nTd),
					"y": $('tr', nTr.parentNode).index(nTr),
					"row": position[0],
					"column": position[2]
				};
			},


			/**
			 * Display the border around one or more cells (from start to end)
			 *  @method  _fnUpdateBorder
			 *  @param   {Node} nStart Starting cell
			 *  @param   {Node} nEnd Ending cell
			 *  @returns void
			 */
			"_fnUpdateBorder": function (nStart, nEnd) {
				var
					border = this.s.border.width,
					offsetStart = $(nStart).offset(),
					offsetEnd = $(nEnd).offset(),
					x1 = offsetStart.left - border,
					x2 = offsetEnd.left + $(nEnd).outerWidth(),
					y1 = offsetStart.top - border,
					y2 = offsetEnd.top + $(nEnd).outerHeight(),
					width = offsetEnd.left + $(nEnd).outerWidth() - offsetStart.left + (2 * border),
					height = offsetEnd.top + $(nEnd).outerHeight() - offsetStart.top + (2 * border),
					oStyle;

				// Recalculate start and end (when dragging "backwards")
				if (offsetStart.left > offsetEnd.left) {
					x1 = offsetEnd.left - border;
					x2 = offsetStart.left + $(nStart).outerWidth();
					width = offsetStart.left + $(nStart).outerWidth() - offsetEnd.left + (2 * border);
				}

				if (this.s.dt.oScroll.sY !== "") {
					/* The border elements are inside the DT scroller - so position relative to that */
					var
						offsetScroll = $(this.s.dt.nTable.parentNode).offset(),
						scrollTop = $(this.s.dt.nTable.parentNode).scrollTop(),
						scrollLeft = $(this.s.dt.nTable.parentNode).scrollLeft();

					x1 -= offsetScroll.left - scrollLeft;
					x2 -= offsetScroll.left - scrollLeft;
					y1 -= offsetScroll.top - scrollTop;
					y2 -= offsetScroll.top - scrollTop;
				}

				/* Top */
				oStyle = this.dom.borderTop.style;
				oStyle.top = y1 + "px";
				oStyle.left = x1 + "px";
				oStyle.height = this.s.border.width + "px";
				oStyle.width = width + "px";

				/* Bottom */
				oStyle = this.dom.borderBottom.style;
				oStyle.top = y2 + "px";
				oStyle.left = x1 + "px";
				oStyle.height = this.s.border.width + "px";
				oStyle.width = width + "px";

				/* Left */
				oStyle = this.dom.borderLeft.style;
				oStyle.top = y1 + "px";
				oStyle.left = x1 + "px";
				oStyle.height = height + "px";
				oStyle.width = this.s.border.width + "px";

				/* Right */
				oStyle = this.dom.borderRight.style;
				oStyle.top = y1 + "px";
				oStyle.left = x2 + "px";
				oStyle.height = height + "px";
				oStyle.width = this.s.border.width + "px";
			},


			/**
			 * Mouse down event handler for starting a drag
			 *  @method  _fnFillerDragStart
			 *  @param   {Object} e Event object
			 *  @returns void
			 */
			"_fnFillerDragStart": function (e) {
				var that = this;
				var startingTd = this.dom.currentTarget;

				this.s.drag.dragging = true;

				that.dom.borderTop.style.display = "block";
				that.dom.borderRight.style.display = "block";
				that.dom.borderBottom.style.display = "block";
				that.dom.borderLeft.style.display = "block";

				var coords = this._fnTargetCoords(startingTd);
				this.s.drag.startX = coords.x;
				this.s.drag.startY = coords.y;

				this.s.drag.startTd = startingTd;
				this.s.drag.endTd = startingTd;

				this._fnUpdateBorder(startingTd, startingTd);

				$(document).bind('mousemove.AutoFill', function (e) {
					that._fnFillerDragMove.call(that, e);
				});

				$(document).bind('mouseup.AutoFill', function (e) {
					that._fnFillerFinish.call(that, e);
				});

				/* Scrolling information cache */
				this.s.screen.y = e.pageY;
				this.s.screen.height = $(window).height();
				this.s.screen.scrollTop = $(document).scrollTop();

				if (this.s.dt.oScroll.sY !== "") {
					this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
					this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
				}

				/* Scrolling handler - we set an interval (which is cancelled on mouse up) which will fire
				 * regularly and see if we need to do any scrolling
				 */
				this.s.screen.interval = setInterval(function () {
					var iScrollTop = $(document).scrollTop();
					var iScrollDelta = iScrollTop - that.s.screen.scrollTop;
					that.s.screen.y += iScrollDelta;

					if (that.s.screen.height - that.s.screen.y + iScrollTop < 50) {
						$('html, body').animate({
													"scrollTop": iScrollTop + 50
												}, 240, 'linear');
					}
					else if (that.s.screen.y - iScrollTop < 50) {
						$('html, body').animate({
													"scrollTop": iScrollTop - 50
												}, 240, 'linear');
					}

					if (that.s.dt.oScroll.sY !== "") {
						if (that.s.screen.y > that.s.scroller.bottom - 50) {
							$(that.s.dt.nTable.parentNode).animate({
																	   "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() + 50
																   }, 240, 'linear');
						}
						else if (that.s.screen.y < that.s.scroller.top + 50) {
							$(that.s.dt.nTable.parentNode).animate({
																	   "scrollTop": $(that.s.dt.nTable.parentNode).scrollTop() - 50
																   }, 240, 'linear');
						}
					}
				}, 250);
			},


			/**
			 * Mouse move event handler for during a move. See if we want to update the display based on the
			 * new cursor position
			 *  @method  _fnFillerDragMove
			 *  @param   {Object} e Event object
			 *  @returns void
			 */
			"_fnFillerDragMove": function (e) {
				if (e.target && e.target.nodeName.toUpperCase() == "TD" &&
					e.target != this.s.drag.endTd) {
					var coords = this._fnTargetCoords(e.target);

					if (this.c.mode == "y" && coords.x != this.s.drag.startX) {
						e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
					}
					if (this.c.mode == "x" && coords.y != this.s.drag.startY) {
						e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
					}

					if (this.c.mode == "either") {
						if (coords.x != this.s.drag.startX) {
							e.target = $('tbody>tr:eq(' + this.s.drag.startY + ')>td:eq(' + coords.x + ')', this.dom.table)[0];
						}
						else if (coords.y != this.s.drag.startY) {
							e.target = $('tbody>tr:eq(' + coords.y + ')>td:eq(' + this.s.drag.startX + ')', this.dom.table)[0];
						}
					}

					// update coords
					if (this.c.mode !== "both") {
						coords = this._fnTargetCoords(e.target);
					}

					var drag = this.s.drag;
					drag.endTd = e.target;

					if (coords.y >= this.s.drag.startY) {
						this._fnUpdateBorder(drag.startTd, drag.endTd);
					}
					else {
						this._fnUpdateBorder(drag.endTd, drag.startTd);
					}
					this._fnFillerPosition(e.target);
				}

				/* Update the screen information so we can perform scrolling */
				this.s.screen.y = e.pageY;
				this.s.screen.scrollTop = $(document).scrollTop();

				if (this.s.dt.oScroll.sY !== "") {
					this.s.scroller.scrollTop = $(this.s.dt.nTable.parentNode).scrollTop();
					this.s.scroller.top = $(this.s.dt.nTable.parentNode).offset().top;
					this.s.scroller.bottom = this.s.scroller.top + $(this.s.dt.nTable.parentNode).height();
				}
			},


			/**
			 * Mouse release handler - end the drag and take action to update the cells with the needed values
			 *  @method  _fnFillerFinish
			 *  @param   {Object} e Event object
			 *  @returns void
			 */
			"_fnFillerFinish": function (e) {
				var that = this, i, iLen, j;

				$(document).unbind('mousemove.AutoFill mouseup.AutoFill');

				this.dom.borderTop.style.display = "none";
				this.dom.borderRight.style.display = "none";
				this.dom.borderBottom.style.display = "none";
				this.dom.borderLeft.style.display = "none";

				this.s.drag.dragging = false;

				clearInterval(this.s.screen.interval);

				var cells = [];
				var table = this.dom.table;
				var coordsStart = this._fnTargetCoords(this.s.drag.startTd);
				var coordsEnd = this._fnTargetCoords(this.s.drag.endTd);
				var columnIndex = function (visIdx) {
					return that.s.dt.oApi._fnVisibleToColumnIndex(that.s.dt, visIdx);
				};

				// xxx - urgh - there must be a way of reducing this...
				if (coordsStart.y <= coordsEnd.y) {
					for (i = coordsStart.y; i <= coordsEnd.y; i++) {
						if (coordsStart.x <= coordsEnd.x) {
							for (j = coordsStart.x; j <= coordsEnd.x; j++) {
								cells.push({
											   node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
											   x: j - coordsStart.x,
											   y: i - coordsStart.y,
											   colIdx: columnIndex(j)
										   });
							}
						}
						else {
							for (j = coordsStart.x; j >= coordsEnd.x; j--) {
								cells.push({
											   node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
											   x: j - coordsStart.x,
											   y: i - coordsStart.y,
											   colIdx: columnIndex(j)
										   });
							}
						}
					}
				}
				else {
					for (i = coordsStart.y; i >= coordsEnd.y; i--) {
						if (coordsStart.x <= coordsEnd.x) {
							for (j = coordsStart.x; j <= coordsEnd.x; j++) {
								cells.push({
											   node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
											   x: j - coordsStart.x,
											   y: i - coordsStart.y,
											   colIdx: columnIndex(j)
										   });
							}
						}
						else {
							for (j = coordsStart.x; j >= coordsEnd.x; j--) {
								cells.push({
											   node: $('tbody>tr:eq(' + i + ')>td:eq(' + j + ')', table)[0],
											   x: coordsStart.x - j,
											   y: coordsStart.y - i,
											   colIdx: columnIndex(j)
										   });
							}
						}
					}
				}

				// An auto-fill requires 2 or more cells
				if (cells.length <= 1) {
					return;
				}

				var edited = [];
				var previous;

				for (i = 0, iLen = cells.length; i < iLen; i++) {
					var cell = cells[i];
					var column = this.s.columns[ cell.colIdx ];
					var read = column.read.call(column, cell.node);
					var stepValue = column.step.call(column, cell.node, read, previous, i, cell.x, cell.y);

					column.write.call(column, cell.node, stepValue);

					previous = stepValue;
					edited.push({
									cell: cell,
									colIdx: cell.colIdx,
									newValue: stepValue,
									oldValue: read
								});
				}

				if (this.c.complete !== null) {
					this.c.complete.call(this, edited);
				}

				// In 1.10 we can do a static draw
				if (DataTable.Api) {
					new DataTable.Api(this.s.dt).draw(false);
				}
				else {
					this.s.dt.oInstance.fnDraw();
				}
			},


			/**
			 * Display the drag handle on mouse over cell
			 *  @method  _fnFillerDisplay
			 *  @param   {Object} e Event object
			 *  @returns void
			 */
			"_fnFillerDisplay": function (e) {
				var filler = this.dom.filler;

				/* Don't display automatically when dragging */
				if (this.s.drag.dragging) {
					return;
				}

				/* Check that we are allowed to AutoFill this column or not */
				var nTd = (e.target.nodeName.toLowerCase() == 'td') ? e.target : $(e.target).parents('td')[0];
				var iX = this._fnTargetCoords(nTd).column;
				if (!this.s.columns[iX].enable) {
					filler.style.display = "none";
					return;
				}

				if (e.type == 'mouseover') {
					this.dom.currentTarget = nTd;
					this._fnFillerPosition(nTd);

					filler.style.display = "block";
				}
				else if (!e.relatedTarget || !e.relatedTarget.className.match(/AutoFill/)) {
					filler.style.display = "none";
				}
			},


			/**
			 * Position the filler icon over a cell
			 *  @method  _fnFillerPosition
			 *  @param   {Node} nTd Cell to position filler icon over
			 *  @returns void
			 */
			"_fnFillerPosition": function (nTd) {
				var offset = $(nTd).offset();
				var filler = this.dom.filler;
				filler.style.top = (offset.top - (this.s.filler.height / 2) - 1 + $(nTd).outerHeight()) + "px";
				filler.style.left = (offset.left - (this.s.filler.width / 2) - 1 + $(nTd).outerWidth()) + "px";
			}
		};


// Alias for access
		DataTable.AutoFill = AutoFill;
		DataTable.AutoFill = AutoFill;


		/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
		 * Constants
		 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

		/**
		 * AutoFill version
		 *  @constant  version
		 *  @type      String
		 *  @default   See code
		 */
		AutoFill.version = "1.2.0";


		/**
		 * AutoFill defaults
		 *  @namespace
		 */
		AutoFill.defaults = {
			/**
			 * Mode for dragging (restrict to y-axis only, x-axis only, either one or none):
			 *
			 *  * `y`      - y-axis only (default)
			 *  * `x`      - x-axis only
			 *  * `either` - either one, but not both axis at the same time
			 *  * `both`   - multiple cells allowed
			 *
			 * @type {string}
			 * @default `y`
			 */
			mode: 'y',

			complete: null,

			/**
			 * Column definition defaults
			 *  @namespace
			 */
			column: {
				/**
				 * If AutoFill should be enabled on this column
				 *
				 * @type {boolean}
				 * @default true
				 */
				enable: true,

				/**
				 * Allow automatic increment / decrement on this column if a number
				 * is found.
				 *
				 * @type {boolean}
				 * @default true
				 */
				increment: true,

				/**
				 * Cell read function
				 *
				 * Default function will simply read the value from the HTML of the
				 * cell.
				 *
				 * @type   {function}
				 * @param  {node} cell `th` / `td` element to read the value from
				 * @return {string}    Data that has been read
				 */
				read: function (cell) {
					return $(cell).html();
				},

				/**
				 * Cell write function
				 *
				 * Default function will simply write to the HTML and tell the DataTable
				 * to update.
				 *
				 * @type   {function}
				 * @param  {node} cell `th` / `td` element to write the value to
				 * @return {string}    Data two write
				 */
				write: function (cell, val) {
					var table = $(cell).parents('table');
					if (DataTable.Api) {
						// 1.10
						table.DataTable().cell(cell).data(val);
					}
					else {
						// 1.9
						var dt = table.dataTable();
						var pos = dt.fnGetPosition();
						dt.fnUpdate(val, pos[0], pos[2], false);
					}
				},

				/**
				 * Step function. This provides the ability to customise how the values
				 * are incremented.
				 *
				 * @param  {node} cell `th` / `td` element that is being operated upon
				 * @param  {string} read Cell value from `read` function
				 * @param  {string} last Value of the previous cell
				 * @param  {integer} i Loop counter
				 * @param  {integer} x Cell x-position in the current auto-fill. The
				 *   starting cell is coordinate 0 regardless of its physical position
				 *   in the DataTable.
				 * @param  {integer} y Cell y-position in the current auto-fill. The
				 *   starting cell is coordinate 0 regardless of its physical position
				 *   in the DataTable.
				 * @return {string} Value to write
				 */
				step: function (cell, read, last, i, x, y) {
					// Increment a number if it is found
					var re = /(\-?\d+)/;
					var match = this.increment && last ? last.match(re) : null;
					if (match) {
						return last.replace(re, parseInt(match[1], 10) + (x < 0 || y < 0 ? -1 : 1));
					}
					return last === undefined ?
						read :
						last;
				}
			}
		};

		return AutoFill;
	};  // factory


	factory(jQuery, jQuery.fn.dataTable);

}(window, document));

