/* Copyright (c) 2005 Tim Taylor Consulting (see LICENSE.txt) */
  
  ToolMan._dragFactory = {
          createSimpleGroup : function(element, handle) {
                  handle = handle ? handle : element
                  var group = this.createGroup(element)
                  group.setHandle(handle)
                  group.transparentDrag()
                  group.onTopWhileDragging()
                  return group
          },
  
          createGroup : function(element) {
                  var group = new _ToolManDragGroup(this, element)
  
                  var position = ToolMan.css().readStyle(element, 'position')
                  if (position == 'static') {
                          element.style["position"] = 'relative'
                  } else if (position == 'absolute') {
                          /* for Safari 1.2 */
                          ToolMan.coordinates().topLeftOffset(element).reposition(element)
                  }
  
                  // TODO: only if ToolMan.isDebugging()
                  group.register('draginit', this._showDragEventStatus)
                  group.register('dragmove', this._showDragEventStatus)
                  group.register('dragend', this._showDragEventStatus)
  
                  return group
          },
  
          _showDragEventStatus : function(dragEvent) {
                  window.status = dragEvent.toString()
          },
  
          constraints : function() {
                  return this._constraintFactory
          },
  
          _createEvent : function(type, event, group) {
                  return new _ToolManDragEvent(type, event, group)
          }
  }
  
  function _ToolManDragGroup(factory, element) {
          this.factory = factory
          this.element = element
          this._handle = null
          this._thresholdDistance = 0
          this._transforms = new Array()
          // TODO: refactor into a helper object, move into events.js
          this._listeners = new Array()
          this._listeners['draginit'] = new Array()
          this._listeners['dragstart'] = new Array()
          this._listeners['dragmove'] = new Array()
          this._listeners['dragend'] = new Array()
  }
  
  _ToolManDragGroup.prototype = {
          /*
  	 * TODO:
  	 *   - unregister(type, func)
  	 *   - move custom event listener stuff into Event library
  	 *   - keyboard nudging of "selected" group
  	 */
  
          setHandle : function(handle) {
                  var events = ToolMan.events()
  
                  handle.toolManDragGroup = this
                  events.register(handle, 'mousedown', this._dragInit)
                  handle.onmousedown = function() { return false }
  
                  if (this.element != handle)
                          events.unregister(this.element, 'mousedown', this._dragInit)
          },
  
          register : function(type, func) {
                  this._listeners[type].push(func)
          },
  
          addTransform : function(transformFunc) {
                  this._transforms.push(transformFunc)
          },
  
          verticalOnly : function() {
                  this.addTransform(this.factory.constraints().vertical())
          },
  
          horizontalOnly : function() {
                  this.addTransform(this.factory.constraints().horizontal())
          },
  
          setThreshold : function(thresholdDistance) {
                  this._thresholdDistance = thresholdDistance
          },
  
          transparentDrag : function(opacity) {
                  var opacity = typeof(opacity) != "undefined" ? opacity : 0.75;
                  var originalOpacity = ToolMan.css().readStyle(this.element, "opacity")
  
                  this.register('dragstart', function(dragEvent) {
                          var element = dragEvent.group.element
                          element.style.opacity = opacity
                          element.style.filter = 'alpha(opacity=' + (opacity * 100) + ')'
                  })
                  this.register('dragend', function(dragEvent) {
                          var element = dragEvent.group.element
                          element.style.opacity = originalOpacity
                          element.style.filter = 'alpha(opacity=100)'
                  })
          },
  
          onTopWhileDragging : function(zIndex) {
                  var zIndex = typeof(zIndex) != "undefined" ? zIndex : 100000;
                  var originalZIndex = ToolMan.css().readStyle(this.element, "z-index")
  
                  this.register('dragstart', function(dragEvent) {
                          dragEvent.group.element.style.zIndex = zIndex
                  })
                  this.register('dragend', function(dragEvent) {
                          dragEvent.group.element.style.zIndex = originalZIndex
                  })
          },
  
          _dragInit : function(event) {
                  event = ToolMan.events().fix(event)
                  var group = document.toolManDragGroup = this.toolManDragGroup
                  var dragEvent = group.factory._createEvent('draginit', event, group)
  
                  group._isThresholdExceeded = false
                  group._initialMouseOffset = dragEvent.mouseOffset
                  group._grabOffset = dragEvent.mouseOffset.minus(dragEvent.topLeftOffset)
                  ToolMan.events().register(document, 'mousemove', group._drag)
                  document.onmousemove = function() { return false }
                  ToolMan.events().register(document, 'mouseup', group._dragEnd)
  
                  group._notifyListeners(dragEvent)
          },
  
          _drag : function(event) {
                  event = ToolMan.events().fix(event)
                  var coordinates = ToolMan.coordinates()
                  var group = this.toolManDragGroup
                  if (!group) return
                  var dragEvent = group.factory._createEvent('dragmove', event, group)
  
                  var newTopLeftOffset = dragEvent.mouseOffset.minus(group._grabOffset)
  
                  // TODO: replace with DragThreshold object
                  if (!group._isThresholdExceeded) {
                          var distance = 
                                          dragEvent.mouseOffset.distance(group._initialMouseOffset)
                          if (distance < group._thresholdDistance) return
                          group._isThresholdExceeded = true
                          group._notifyListeners(
                                          group.factory._createEvent('dragstart', event, group))
                  }
  
                  for (i in group._transforms) {
                          var transform = group._transforms[i]
                          newTopLeftOffset = transform(newTopLeftOffset, dragEvent)
                  }
  
                  var dragDelta = newTopLeftOffset.minus(dragEvent.topLeftOffset)
                  var newTopLeftPosition = dragEvent.topLeftPosition.plus(dragDelta)
                  newTopLeftPosition.reposition(group.element)
                  dragEvent.transformedMouseOffset = newTopLeftOffset.plus(group._grabOffset)
  
                  group._notifyListeners(dragEvent)
  
                  var errorDelta = newTopLeftOffset.minus(coordinates.topLeftOffset(group.element))
                  if (errorDelta.x != 0 || errorDelta.y != 0) {
                          coordinates.topLeftPosition(group.element).plus(errorDelta).reposition(group.element)
                  }
          },
  
          _dragEnd : function(event) {
                  event = ToolMan.events().fix(event)
                  var group = this.toolManDragGroup
                  var dragEvent = group.factory._createEvent('dragend', event, group)
  
                  group._notifyListeners(dragEvent)
  
                  this.toolManDragGroup = null
                  ToolMan.events().unregister(document, 'mousemove', group._drag)
                  document.onmousemove = null
                  ToolMan.events().unregister(document, 'mouseup', group._dragEnd)
          },
  
          _notifyListeners : function(dragEvent) {
                  var listeners = this._listeners[dragEvent.type]
                  for (i in listeners) {
                          listeners[i](dragEvent)
                  }
          }
  }
  
  function _ToolManDragEvent(type, event, group) {
          this.type = type
          this.group = group
          this.mousePosition = ToolMan.coordinates().mousePosition(event)
          this.mouseOffset = ToolMan.coordinates().mouseOffset(event)
          this.transformedMouseOffset = this.mouseOffset
          this.topLeftPosition = ToolMan.coordinates().topLeftPosition(group.element)
          this.topLeftOffset = ToolMan.coordinates().topLeftOffset(group.element)
  }
  
  _ToolManDragEvent.prototype = {
          toString : function() {
                  return "mouse: " + this.mousePosition + this.mouseOffset + "    " +
                                  "xmouse: " + this.transformedMouseOffset + "    " +
                                  "left,top: " + this.topLeftPosition + this.topLeftOffset
          }
  }
  
  ToolMan._dragFactory._constraintFactory = {
          vertical : function() {
                  return function(coordinate, dragEvent) {
                          var x = dragEvent.topLeftOffset.x
                          return coordinate.x != x
                                          ? coordinate.factory.create(x, coordinate.y) 
                                          : coordinate
                  }
          },
  
          horizontal : function() {
                  return function(coordinate, dragEvent) {
                          var y = dragEvent.topLeftOffset.y
                          return coordinate.y != y
                                          ? coordinate.factory.create(coordinate.x, y) 
                                          : coordinate
                  }
          }
  }