// Dependencies:
// 1) jQuery

var svgedit = svgedit || {};

(function() {

if (!svgedit.units) {
  svgedit.units = {};
}

var w_attrs = ['x', 'x1', 'cx', 'rx', 'width'];
var h_attrs = ['y', 'y1', 'cy', 'ry', 'height'];
var unit_attrs = $.merge(['r','radius'], w_attrs);

var unitNumMap = {
  '%':  2,
  'em': 3,
  'ex': 4,
  'px': 5,
  'cm': 6,
  'mm': 7,
  'in': 8,
  'pt': 9,
  'pc': 10
};

$.merge(unit_attrs, h_attrs);

// Container of elements.
var elementContainer_;

/**
 * Stores mapping of unit type to user coordinates.
 */
var typeMap_ = {px: 1};

/**
 * ElementContainer interface
 *
 * function getBaseUnit() - returns a string of the base unit type of the container ("em")
 * function getElement() - returns an element in the container given an id
 * function getHeight() - returns the container's height
 * function getWidth() - returns the container's width
 * function getRoundDigits() - returns the number of digits number should be rounded to
 */

/**
 * Function: svgedit.units.init()
 * Initializes this module.
 *
 * Parameters:
 * elementContainer - an object implementing the ElementContainer interface.
 */
svgedit.units.init = function(elementContainer) {
  elementContainer_ = elementContainer;

  var svgns = 'http://www.w3.org/2000/svg';

  // Get correct em/ex values by creating a temporary SVG.
  var svg = document.createElementNS(svgns, 'svg');
  document.body.appendChild(svg);
  var rect = document.createElementNS(svgns,'rect');
  rect.setAttribute('width',"1em");
  rect.setAttribute('height',"1ex");
  rect.setAttribute('x',"1in");
  svg.appendChild(rect);
  var bb = rect.getBBox();
  document.body.removeChild(svg);

  var inch = bb.x;
  typeMap_['em'] = bb.width;
  typeMap_['ex'] = bb.height;
  typeMap_['in'] = inch;
  typeMap_['cm'] = inch / 2.54;
  typeMap_['mm'] = inch / 25.4;
  typeMap_['pt'] = inch / 72;
  typeMap_['pc'] = inch / 6;
  typeMap_['%'] = 0;
};

// Group: Unit conversion functions

// Function: svgedit.units.getTypeMap
// Returns the unit object with values for each unit
svgedit.units.getTypeMap = function() {
  return typeMap_;
};

// Function: svgedit.units.shortFloat
// Rounds a given value to a float with number of digits defined in save_options
//
// Parameters: 
// val - The value as a String, Number or Array of two numbers to be rounded
//
// Returns:
// If a string/number was given, returns a Float. If an array, return a string
// with comma-seperated floats
svgedit.units.shortFloat = function(val) {
  var digits = elementContainer_.getRoundDigits();
  if(!isNaN(val)) {
    // Note that + converts to Number
    return +((+val).toFixed(digits));
  } else if($.isArray(val)) {
    return svgedit.units.shortFloat(val[0]) + ',' + svgedit.units.shortFloat(val[1]);
  }
  return parseFloat(val).toFixed(digits) - 0;
};

// Function: svgedit.units.convertUnit
// Converts the number to given unit or baseUnit
svgedit.units.convertUnit = function(val, unit) {
  unit = unit || elementContainer_.getBaseUnit();
//  baseVal.convertToSpecifiedUnits(unitNumMap[unit]);
//  var val = baseVal.valueInSpecifiedUnits;
//  baseVal.convertToSpecifiedUnits(1);
  return svgedit.unit.shortFloat(val / typeMap_[unit]);
};

// Function: svgedit.units.setUnitAttr
// Sets an element's attribute based on the unit in its current value.
//
// Parameters: 
// elem - DOM element to be changed
// attr - String with the name of the attribute associated with the value
// val - String with the attribute value to convert
svgedit.units.setUnitAttr = function(elem, attr, val) {
  if(!isNaN(val)) {
    // New value is a number, so check currently used unit
    var old_val = elem.getAttribute(attr);
    
    // Enable this for alternate mode
//    if(old_val !== null && (isNaN(old_val) || elementContainer_.getBaseUnit() !== 'px')) {
//      // Old value was a number, so get unit, then convert
//      var unit;
//      if(old_val.substr(-1) === '%') {
//        var res = getResolution();
//        unit = '%';
//        val *= 100;
//        if(w_attrs.indexOf(attr) >= 0) {
//          val = val / res.w;
//        } else if(h_attrs.indexOf(attr) >= 0) {
//          val = val / res.h;
//        } else {
//          return val / Math.sqrt((res.w*res.w) + (res.h*res.h))/Math.sqrt(2);
//        }
//      } else {
//        if(elementContainer_.getBaseUnit() !== 'px') {
//          unit = elementContainer_.getBaseUnit();
//        } else {
//          unit = old_val.substr(-2);
//        }
//        val = val / typeMap_[unit];
//      }
//    
//    val += unit;
//    }
  }
  elem.setAttribute(attr, val);
};

var attrsToConvert = {
  "line": ['x1', 'x2', 'y1', 'y2'],
  "circle": ['cx', 'cy', 'r'],
  "ellipse": ['cx', 'cy', 'rx', 'ry'],
  "foreignObject": ['x', 'y', 'width', 'height'],
  "rect": ['x', 'y', 'width', 'height'],
  "image": ['x', 'y', 'width', 'height'],
  "use": ['x', 'y', 'width', 'height'],
  "text": ['x', 'y']
};

// Function: svgedit.units.convertAttrs
// Converts all applicable attributes to the configured baseUnit
//
// Parameters:
// element - a DOM element whose attributes should be converted
svgedit.units.convertAttrs = function(element) {
  var elName = element.tagName;
  var unit = elementContainer_.getBaseUnit();
  var attrs = attrsToConvert[elName];
  if(!attrs) return;
  var len = attrs.length
  for(var i = 0; i < len; i++) {
    var attr = attrs[i];
    var cur = element.getAttribute(attr);
    if(cur) {
      if(!isNaN(cur)) {
        element.setAttribute(attr, (cur / typeMap_[unit]) + unit);
      } else {
        // Convert existing?
      }
    }
  }
};

// Function: svgedit.units.convertToNum
// Converts given values to numbers. Attributes must be supplied in 
// case a percentage is given
//
// Parameters:
// attr - String with the name of the attribute associated with the value
// val - String with the attribute value to convert
svgedit.units.convertToNum = function(attr, val) {
  // Return a number if that's what it already is
  if(!isNaN(val)) return val-0;
  
  if(val.substr(-1) === '%') {
    // Deal with percentage, depends on attribute
    var num = val.substr(0, val.length-1)/100;
    var width = elementContainer_.getWidth();
    var height = elementContainer_.getHeight();
    
    if(w_attrs.indexOf(attr) >= 0) {
      return num * width;
    } else if(h_attrs.indexOf(attr) >= 0) {
      return num * height;
    } else {
      return num * Math.sqrt((width*width) + (height*height))/Math.sqrt(2);
    }
  } else {
    var unit = val.substr(-2);
    var num = val.substr(0, val.length-2);
    // Note that this multiplication turns the string into a number
    return num * typeMap_[unit];
  }
};

// Function: svgedit.units.isValidUnit
// Check if an attribute's value is in a valid format
//
// Parameters: 
// attr - String with the name of the attribute associated with the value
// val - String with the attribute value to check
svgedit.units.isValidUnit = function(attr, val, selectedElement) {
  var valid = false;
  if(unit_attrs.indexOf(attr) >= 0) {
    // True if it's just a number
    if(!isNaN(val)) {
      valid = true;
    } else {
    // Not a number, check if it has a valid unit
      val = val.toLowerCase();
      $.each(typeMap_, function(unit) {
        if(valid) return;
        var re = new RegExp('^-?[\\d\\.]+' + unit + '$');
        if(re.test(val)) valid = true;
      });
    }
  } else if (attr == "id") {
    // if we're trying to change the id, make sure it's not already present in the doc
    // and the id value is valid.

    var result = false;
    // because getElem() can throw an exception in the case of an invalid id
    // (according to http://www.w3.org/TR/xml-id/ IDs must be a NCName)
    // we wrap it in an exception and only return true if the ID was valid and
    // not already present
    try {
      var elem = elementContainer_.getElement(val);
      result = (elem == null || elem === selectedElement);
    } catch(e) {}
    return result;
  } else {
    valid = true;
  }
  
  return valid;
};


})();