'use strict'
const init = (L) => {
  /* A Draggable that does not update the element position
    and takes care of only bubbling to targetted path in Canvas mode. */
  L.PathDraggable = L.Draggable.extend({

    initialize: function (path) {
      this._path = path
      this._canvas = (path._map.getRenderer(path) instanceof L.Canvas)
      const element = this._canvas ? this._path._map.getRenderer(this._path)._container : this._path._path
      L.Draggable.prototype.initialize.call(this, element, element, true)
    },

    _updatePosition: function () {
      const e = { originalEvent: this._lastEvent }
      this.fire('drag', e)
    },

    _onDown: function (e) {
      const first = e.touches ? e.touches[0] : e
      this._startPoint = new L.Point(first.clientX, first.clientY)
      if (this._canvas && !this._path._containsPoint(this._path._map.mouseEventToLayerPoint(first))) {
        return
      }
      L.Draggable.prototype._onDown.call(this, e)
    }

  })

  L.Handler.PathDrag = L.Handler.extend({

    initialize: function (path) {
      this._path = path
    },

    getEvents: function () {
      return {
        dragstart: this._onDragStart,
        drag: this._onDrag,
        dragend: this._onDragEnd
      }
    },

    addHooks: function () {
      if (!this._draggable) {
        this._draggable = new L.PathDraggable(this._path)
      }
      this._draggable.on(this.getEvents(), this).enable()
      L.DomUtil.addClass(this._draggable._element, 'leaflet-path-draggable')
    },

    removeHooks: function () {
      this._draggable.off(this.getEvents(), this).disable()
      L.DomUtil.removeClass(this._draggable._element, 'leaflet-path-draggable')
    },

    moved: function () {
      return this._draggable && this._draggable._moved
    },

    _onDragStart: function () {
      this._startPoint = this._draggable._startPoint
      this._path
        .closePopup()
        .fire('movestart')
        .fire('dragstart')
    },

    _onDrag: function (e) {
      const path = this._path
      const event = (e.originalEvent.touches && e.originalEvent.touches.length === 1 ? e.originalEvent.touches[0] : e.originalEvent)
      const newPoint = L.point(event.clientX, event.clientY)
      const latlng = path._map.layerPointToLatLng(newPoint)

      this._offset = newPoint.subtract(this._startPoint)
      this._startPoint = newPoint

      this._path.eachLatLng(this.updateLatLng, this)
      path.redraw()

      e.latlng = latlng
      e.offset = this._offset
      path.fire('drag', e)
      e.latlng = this._path.getCenter ? this._path.getCenter() : this._path.getLatLng()
      path.fire('move', e)
    },

    _onDragEnd: function (e) {
      if (this._path._bounds) this.resetBounds()
      this._path.fire('moveend')
        .fire('dragend', e)
    },

    latLngToLayerPoint: function (latlng) {
      // Same as map.latLngToLayerPoint, but without the round().
      const projectedPoint = this._path._map.project(L.latLng(latlng))
      return projectedPoint._subtract(this._path._map.getPixelOrigin())
    },

    updateLatLng: function (latlng) {
      const oldPoint = this.latLngToLayerPoint(latlng)
      oldPoint._add(this._offset)
      const newLatLng = this._path._map.layerPointToLatLng(oldPoint)
      latlng.lat = newLatLng.lat
      latlng.lng = newLatLng.lng
    },

    resetBounds: function () {
      this._path._bounds = new L.LatLngBounds()
      this._path.eachLatLng(function (latlng) {
        this._bounds.extend(latlng)
      })
    }

  })

  L.Path.include({

    eachLatLng: function (callback, context) {
      context = context || this
      const loop = function (latlngs) {
        for (let i = 0; i < latlngs.length; i++) {
          if (L.Util.isArray(latlngs[i])) loop(latlngs[i])
          else callback.call(context, latlngs[i])
        }
      }
      loop(this.getLatLngs ? this.getLatLngs() : [this.getLatLng()])
    }

  })

  L.Path.addInitHook(function () {
    this.dragging = new L.Handler.PathDrag(this)
    if (this.options.draggable) {
      this.once('add', function () {
        this.dragging.enable()
      })
    }
  })
}
export default {
  init
}