/*! RowReorder 1.2.8
 * 2015-2020 SpryMedia Ltd - datatables.net/license
 */

/**
 * @summary     RowReorder
 * @description Row reordering extension for DataTables
 * @version     1.2.8
 * @file        dataTables.rowReorder.js
 * @author      SpryMedia Ltd (www.sprymedia.co.uk)
 * @contact     www.sprymedia.co.uk/contact
 * @copyright   Copyright 2015-2020 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 (factory) {
  if (typeof define === "function" && define.amd) {
    // AMD
    define(["jquery", "datatables.net"], function ($) {
      return factory($, window, document);
    });
  } else if (typeof exports === "object") {
    // CommonJS
    module.exports = function (root, $) {
      if (!root) {
        root = window;
      }

      if (!$ || !$.fn.dataTable) {
        $ = require("datatables.net")(root, $).$;
      }

      return factory($, root, root.document);
    };
  } else {
    // Browser
    factory(jQuery, window, document);
  }
})(function ($, window, document, undefined) {
  "use strict";
  var DataTable = $.fn.dataTable;

  /**
   * RowReorder provides the ability in DataTables to click and drag rows to
   * reorder them. When a row is dropped the data for the rows effected will be
   * updated to reflect the change. Normally this data point should also be the
   * column being sorted upon in the DataTable but this does not need to be the
   * case. RowReorder implements a "data swap" method - so the rows being
   * reordered take the value of the data point from the row that used to occupy
   * the row's new position.
   *
   * Initialisation is done by either:
   *
   * * `rowReorder` parameter in the DataTable initialisation object
   * * `new $.fn.dataTable.RowReorder( table, opts )` after DataTables
   *   initialisation.
   *
   *  @class
   *  @param {object} settings DataTables settings object for the host table
   *  @param {object} [opts] Configuration options
   *  @requires jQuery 1.7+
   *  @requires DataTables 1.10.7+
   */
  var RowReorder = function (dt, opts) {
    // Sanity check that we are using DataTables 1.10 or newer
    if (!DataTable.versionCheck || !DataTable.versionCheck("1.10.8")) {
      throw "DataTables RowReorder requires DataTables 1.10.8 or newer";
    }

    // User and defaults configuration object
    this.c = $.extend(
      true,
      {},
      DataTable.defaults.rowReorder,
      RowReorder.defaults,
      opts,
    );

    // Internal settings
    this.s = {
      /** @type {integer} Scroll body top cache */
      bodyTop: null,

      /** @type {DataTable.Api} DataTables' API instance */
      dt: new DataTable.Api(dt),

      /** @type {function} Data fetch function */
      getDataFn: DataTable.ext.oApi._fnGetObjectDataFn(this.c.dataSrc),

      /** @type {array} Pixel positions for row insertion calculation */
      middles: null,

      /** @type {Object} Cached dimension information for use in the mouse move event handler */
      scroll: {},

      /** @type {integer} Interval object used for smooth scrolling */
      scrollInterval: null,

      /** @type {function} Data set function */
      setDataFn: DataTable.ext.oApi._fnSetObjectDataFn(this.c.dataSrc),

      /** @type {Object} Mouse down information */
      start: {
        top: 0,
        left: 0,
        offsetTop: 0,
        offsetLeft: 0,
        nodes: [],
      },

      /** @type {integer} Window height cached value */
      windowHeight: 0,

      /** @type {integer} Document outer height cached value */
      documentOuterHeight: 0,

      /** @type {integer} DOM clone outer height cached value */
      domCloneOuterHeight: 0,
    };

    // DOM items
    this.dom = {
      /** @type {jQuery} Cloned row being moved around */
      clone: null,

      /** @type {jQuery} DataTables scrolling container */
      dtScroll: $("div.dataTables_scrollBody", this.s.dt.table().container()),
    };

    // Check if row reorder has already been initialised on this table
    var settings = this.s.dt.settings()[0];
    var exisiting = settings.rowreorder;

    if (exisiting) {
      return exisiting;
    }

    if (!this.dom.dtScroll.length) {
      this.dom.dtScroll = $(this.s.dt.table().container(), "tbody");
    }

    settings.rowreorder = this;
    this._constructor();
  };

  $.extend(RowReorder.prototype, {
    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
     * Constructor
     */

    /**
     * Initialise the RowReorder instance
     *
     * @private
     */
    _constructor: function () {
      var that = this;
      var dt = this.s.dt;
      var table = $(dt.table().node());

      // Need to be able to calculate the row positions relative to the table
      if (table.css("position") === "static") {
        table.css("position", "relative");
      }

      // listen for mouse down on the target column - we have to implement
      // this rather than using HTML5 drag and drop as drag and drop doesn't
      // appear to work on table rows at this time. Also mobile browsers are
      // not supported.
      // Use `table().container()` rather than just the table node for IE8 -
      // otherwise it only works once...
      $(dt.table().container()).on(
        "mousedown.rowReorder touchstart.rowReorder",
        this.c.selector,
        function (e) {
          if (!that.c.enable) {
            return;
          }

          // Ignore excluded children of the selector
          if ($(e.target).is(that.c.excludedChildren)) {
            return true;
          }

          var tr = $(this).closest("tr");
          var row = dt.row(tr);

          // Double check that it is a DataTable row
          if (row.any()) {
            that._emitEvent("pre-row-reorder", {
              node: row.node(),
              index: row.index(),
            });

            that._mouseDown(e, tr);
            return false;
          }
        },
      );

      dt.on("destroy.rowReorder", function () {
        $(dt.table().container()).off(".rowReorder");
        dt.off(".rowReorder");
      });
    },

    /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
     * Private methods
     */

    /**
     * Cache the measurements that RowReorder needs in the mouse move handler
     * to attempt to speed things up, rather than reading from the DOM.
     *
     * @private
     */
    _cachePositions: function () {
      var dt = this.s.dt;

      // Frustratingly, if we add `position:relative` to the tbody, the
      // position is still relatively to the parent. So we need to adjust
      // for that
      var headerHeight = $(dt.table().node()).find("thead").outerHeight();

      // Need to pass the nodes through jQuery to get them in document order,
      // not what DataTables thinks it is, since we have been altering the
      // order
      var nodes = $.unique(dt.rows({ page: "current" }).nodes().toArray());
      var middles = $.map(nodes, function (node, i) {
        var top = $(node).position().top - headerHeight;

        return (top + top + $(node).outerHeight()) / 2;
      });

      this.s.middles = middles;
      this.s.bodyTop = $(dt.table().body()).offset().top;
      this.s.windowHeight = $(window).height();
      this.s.documentOuterHeight = $(document).outerHeight();
    },

    /**
     * Clone a row so it can be floated around the screen
     *
     * @param  {jQuery} target Node to be cloned
     * @private
     */
    _clone: function (target) {
      var dt = this.s.dt;
      var clone = $(dt.table().node().cloneNode(false))
        .addClass("dt-rowReorder-float")
        .append("<tbody/>")
        .append(target.clone(false));

      // Match the table and column widths - read all sizes before setting
      // to reduce reflows
      var tableWidth = target.outerWidth();
      var tableHeight = target.outerHeight();
      var sizes = target.children().map(function () {
        return $(this).width();
      });

      clone
        .width(tableWidth)
        .height(tableHeight)
        .find("tr")
        .children()
        .each(function (i) {
          this.style.width = sizes[i] + "px";
        });

      // Insert into the document to have it floating around
      clone.appendTo("body");

      this.dom.clone = clone;
      this.s.domCloneOuterHeight = clone.outerHeight();
    },

    /**
     * Update the cloned item's position in the document
     *
     * @param  {object} e Event giving the mouse's position
     * @private
     */
    _clonePosition: function (e) {
      var start = this.s.start;
      var topDiff = this._eventToPage(e, "Y") - start.top;
      var leftDiff = this._eventToPage(e, "X") - start.left;
      var snap = this.c.snapX;
      var left;
      var top = topDiff + start.offsetTop;

      if (snap === true) {
        left = start.offsetLeft;
      } else if (typeof snap === "number") {
        left = start.offsetLeft + snap;
      } else {
        left = leftDiff + start.offsetLeft;
      }

      if (top < 0) {
        top = 0;
      } else if (
        top + this.s.domCloneOuterHeight >
        this.s.documentOuterHeight
      ) {
        top = this.s.documentOuterHeight - this.s.domCloneOuterHeight;
      }

      this.dom.clone.css({
        top: top,
        left: left,
      });
    },

    /**
     * Emit an event on the DataTable for listeners
     *
     * @param  {string} name Event name
     * @param  {array} args Event arguments
     * @private
     */
    _emitEvent: function (name, args) {
      this.s.dt.iterator("table", function (ctx, i) {
        $(ctx.nTable).triggerHandler(name + ".dt", args);
      });
    },

    /**
     * Get pageX/Y position from an event, regardless of if it is a mouse or
     * touch event.
     *
     * @param  {object} e Event
     * @param  {string} pos X or Y (must be a capital)
     * @private
     */
    _eventToPage: function (e, pos) {
      if (e.type.indexOf("touch") !== -1) {
        return e.originalEvent.touches[0]["page" + pos];
      }

      return e["page" + pos];
    },

    /**
     * Mouse down event handler. Read initial positions and add event handlers
     * for the move.
     *
     * @param  {object} e      Mouse event
     * @param  {jQuery} target TR element that is to be moved
     * @private
     */
    _mouseDown: function (e, target) {
      var that = this;
      var dt = this.s.dt;
      var start = this.s.start;

      var offset = target.offset();
      start.top = this._eventToPage(e, "Y");
      start.left = this._eventToPage(e, "X");
      start.offsetTop = offset.top;
      start.offsetLeft = offset.left;
      start.nodes = $.unique(dt.rows({ page: "current" }).nodes().toArray());

      this._cachePositions();
      this._clone(target);
      this._clonePosition(e);

      this.dom.target = target;
      target.addClass("dt-rowReorder-moving");

      $(document)
        .on("mouseup.rowReorder touchend.rowReorder", function (e) {
          that._mouseUp(e);
        })
        .on("mousemove.rowReorder touchmove.rowReorder", function (e) {
          that._mouseMove(e);
        });

      // Check if window is x-scrolling - if not, disable it for the duration
      // of the drag
      if ($(window).width() === $(document).width()) {
        $(document.body).addClass("dt-rowReorder-noOverflow");
      }

      // Cache scrolling information so mouse move doesn't need to read.
      // This assumes that the window and DT scroller will not change size
      // during an row drag, which I think is a fair assumption
      var scrollWrapper = this.dom.dtScroll;
      this.s.scroll = {
        windowHeight: $(window).height(),
        windowWidth: $(window).width(),
        dtTop: scrollWrapper.length ? scrollWrapper.offset().top : null,
        dtLeft: scrollWrapper.length ? scrollWrapper.offset().left : null,
        dtHeight: scrollWrapper.length ? scrollWrapper.outerHeight() : null,
        dtWidth: scrollWrapper.length ? scrollWrapper.outerWidth() : null,
      };
    },

    /**
     * Mouse move event handler - move the cloned row and shuffle the table's
     * rows if required.
     *
     * @param  {object} e Mouse event
     * @private
     */
    _mouseMove: function (e) {
      this._clonePosition(e);

      // Transform the mouse position into a position in the table's body
      var bodyY = this._eventToPage(e, "Y") - this.s.bodyTop;
      var middles = this.s.middles;
      var insertPoint = null;
      var dt = this.s.dt;

      // Determine where the row should be inserted based on the mouse
      // position
      for (var i = 0, ien = middles.length; i < ien; i++) {
        if (bodyY < middles[i]) {
          insertPoint = i;
          break;
        }
      }

      if (insertPoint === null) {
        insertPoint = middles.length;
      }

      // Perform the DOM shuffle if it has changed from last time
      if (this.s.lastInsert === null || this.s.lastInsert !== insertPoint) {
        var nodes = $.unique(dt.rows({ page: "current" }).nodes().toArray());

        if (insertPoint > this.s.lastInsert) {
          this.dom.target.insertAfter(nodes[insertPoint - 1]);
        } else {
          this.dom.target.insertBefore(nodes[insertPoint]);
        }

        this._cachePositions();

        this.s.lastInsert = insertPoint;
      }

      this._shiftScroll(e);
    },

    /**
     * Mouse up event handler - release the event handlers and perform the
     * table updates
     *
     * @param  {object} e Mouse event
     * @private
     */
    _mouseUp: function (e) {
      var that = this;
      var dt = this.s.dt;
      var i, ien;
      var dataSrc = this.c.dataSrc;

      this.dom.clone.remove();
      this.dom.clone = null;

      this.dom.target.removeClass("dt-rowReorder-moving");
      //this.dom.target = null;

      $(document).off(".rowReorder");
      $(document.body).removeClass("dt-rowReorder-noOverflow");

      clearInterval(this.s.scrollInterval);
      this.s.scrollInterval = null;

      // Calculate the difference
      var startNodes = this.s.start.nodes;
      var endNodes = $.unique(dt.rows({ page: "current" }).nodes().toArray());
      var idDiff = {};
      var fullDiff = [];
      var diffNodes = [];
      var getDataFn = this.s.getDataFn;
      var setDataFn = this.s.setDataFn;

      for (i = 0, ien = startNodes.length; i < ien; i++) {
        if (startNodes[i] !== endNodes[i]) {
          var id = dt.row(endNodes[i]).id();
          var endRowData = dt.row(endNodes[i]).data();
          var startRowData = dt.row(startNodes[i]).data();

          if (id) {
            idDiff[id] = getDataFn(startRowData);
          }

          fullDiff.push({
            node: endNodes[i],
            oldData: getDataFn(endRowData),
            newData: getDataFn(startRowData),
            newPosition: i,
            oldPosition: $.inArray(endNodes[i], startNodes),
          });

          diffNodes.push(endNodes[i]);
        }
      }

      // Create event args
      var eventArgs = [
        fullDiff,
        {
          dataSrc: dataSrc,
          nodes: diffNodes,
          values: idDiff,
          triggerRow: dt.row(this.dom.target),
          originalEvent: e,
        },
      ];

      // Emit event
      this._emitEvent("row-reorder", eventArgs);

      var update = function () {
        if (that.c.update) {
          for (i = 0, ien = fullDiff.length; i < ien; i++) {
            var row = dt.row(fullDiff[i].node);
            var rowData = row.data();

            setDataFn(rowData, fullDiff[i].newData);

            // Invalidate the cell that has the same data source as the dataSrc
            dt.columns().every(function () {
              if (this.dataSrc() === dataSrc) {
                dt.cell(fullDiff[i].node, this.index()).invalidate("data");
              }
            });
          }

          // Trigger row reordered event
          that._emitEvent("row-reordered", eventArgs);

          dt.draw(false);
        }
      };

      // Editor interface
      if (this.c.editor) {
        // Disable user interaction while Editor is submitting
        this.c.enable = false;

        this.c.editor
          .edit(
            diffNodes,
            false,
            $.extend({ submit: "changed" }, this.c.formOptions),
          )
          .multiSet(dataSrc, idDiff)
          .one("preSubmitCancelled.rowReorder", function () {
            that.c.enable = true;
            that.c.editor.off(".rowReorder");
            dt.draw(false);
          })
          .one("submitUnsuccessful.rowReorder", function () {
            dt.draw(false);
          })
          .one("submitSuccess.rowReorder", function () {
            update();
          })
          .one("submitComplete", function () {
            that.c.enable = true;
            that.c.editor.off(".rowReorder");
          })
          .submit();
      } else {
        update();
      }
    },

    /**
     * Move the window and DataTables scrolling during a drag to scroll new
     * content into view.
     *
     * This matches the `_shiftScroll` method used in AutoFill, but only
     * horizontal scrolling is considered here.
     *
     * @param  {object} e Mouse move event object
     * @private
     */
    _shiftScroll: function (e) {
      var that = this;
      var dt = this.s.dt;
      var scroll = this.s.scroll;
      var runInterval = false;
      var scrollSpeed = 5;
      var buffer = 65;
      var windowY = e.pageY - document.body.scrollTop,
        windowVert,
        dtVert;

      // Window calculations - based on the mouse position in the window,
      // regardless of scrolling
      if (windowY < $(window).scrollTop() + buffer) {
        windowVert = scrollSpeed * -1;
      } else if (
        windowY >
        scroll.windowHeight + $(window).scrollTop() - buffer
      ) {
        windowVert = scrollSpeed;
      }

      // DataTables scrolling calculations - based on the table's position in
      // the document and the mouse position on the page
      if (scroll.dtTop !== null && e.pageY < scroll.dtTop + buffer) {
        dtVert = scrollSpeed * -1;
      } else if (
        scroll.dtTop !== null &&
        e.pageY > scroll.dtTop + scroll.dtHeight - buffer
      ) {
        dtVert = scrollSpeed;
      }

      // This is where it gets interesting. We want to continue scrolling
      // without requiring a mouse move, so we need an interval to be
      // triggered. The interval should continue until it is no longer needed,
      // but it must also use the latest scroll commands (for example consider
      // that the mouse might move from scrolling up to scrolling left, all
      // with the same interval running. We use the `scroll` object to "pass"
      // this information to the interval. Can't use local variables as they
      // wouldn't be the ones that are used by an already existing interval!
      if (windowVert || dtVert) {
        scroll.windowVert = windowVert;
        scroll.dtVert = dtVert;
        runInterval = true;
      } else if (this.s.scrollInterval) {
        // Don't need to scroll - remove any existing timer
        clearInterval(this.s.scrollInterval);
        this.s.scrollInterval = null;
      }

      // If we need to run the interval to scroll and there is no existing
      // interval (if there is an existing one, it will continue to run)
      if (!this.s.scrollInterval && runInterval) {
        this.s.scrollInterval = setInterval(function () {
          // Don't need to worry about setting scroll <0 or beyond the
          // scroll bound as the browser will just reject that.
          if (scroll.windowVert) {
            var top = $(document).scrollTop();
            $(document).scrollTop(top + scroll.windowVert);

            if (top !== $(document).scrollTop()) {
              var move = parseFloat(that.dom.clone.css("top"));
              that.dom.clone.css("top", move + scroll.windowVert);
            }
          }

          // DataTables scrolling
          if (scroll.dtVert) {
            var scroller = that.dom.dtScroll[0];

            if (scroll.dtVert) {
              scroller.scrollTop += scroll.dtVert;
            }
          }
        }, 20);
      }
    },
  });

  /**
   * RowReorder default settings for initialisation
   *
   * @namespace
   * @name RowReorder.defaults
   * @static
   */
  RowReorder.defaults = {
    /**
     * Data point in the host row's data source object for where to get and set
     * the data to reorder. This will normally also be the sorting column.
     *
     * @type {Number}
     */
    dataSrc: 0,

    /**
     * Editor instance that will be used to perform the update
     *
     * @type {DataTable.Editor}
     */
    editor: null,

    /**
     * Enable / disable RowReorder's user interaction
     * @type {Boolean}
     */
    enable: true,

    /**
     * Form options to pass to Editor when submitting a change in the row order.
     * See the Editor `from-options` object for details of the options
     * available.
     * @type {Object}
     */
    formOptions: {},

    /**
     * Drag handle selector. This defines the element that when dragged will
     * reorder a row.
     *
     * @type {String}
     */
    selector: "td:first-child",

    /**
     * Optionally lock the dragged row's x-position. This can be `true` to
     * fix the position match the host table's, `false` to allow free movement
     * of the row, or a number to define an offset from the host table.
     *
     * @type {Boolean|number}
     */
    snapX: false,

    /**
     * Update the table's data on drop
     *
     * @type {Boolean}
     */
    update: true,

    /**
     * Selector for children of the drag handle selector that mouseDown events
     * will be passed through to and drag will not activate
     *
     * @type {String}
     */
    excludedChildren: "a",
  };

  /*
   * API
   */
  var Api = $.fn.dataTable.Api;

  // Doesn't do anything - work around for a bug in DT... Not documented
  Api.register("rowReorder()", function () {
    return this;
  });

  Api.register("rowReorder.enable()", function (toggle) {
    if (toggle === undefined) {
      toggle = true;
    }

    return this.iterator("table", function (ctx) {
      if (ctx.rowreorder) {
        ctx.rowreorder.c.enable = toggle;
      }
    });
  });

  Api.register("rowReorder.disable()", function () {
    return this.iterator("table", function (ctx) {
      if (ctx.rowreorder) {
        ctx.rowreorder.c.enable = false;
      }
    });
  });

  /**
   * Version information
   *
   * @name RowReorder.version
   * @static
   */
  RowReorder.version = "1.2.8";

  $.fn.dataTable.RowReorder = RowReorder;
  $.fn.DataTable.RowReorder = RowReorder;

  // Attach a listener to the document which listens for DataTables initialisation
  // events so we can automatically initialise
  $(document).on("init.dt.dtr", function (e, settings, json) {
    if (e.namespace !== "dt") {
      return;
    }

    var init = settings.oInit.rowReorder;
    var defaults = DataTable.defaults.rowReorder;

    if (init || defaults) {
      var opts = $.extend({}, init, defaults);

      if (init !== false) {
        new RowReorder(settings, opts);
      }
    }
  });

  return RowReorder;
});
