/* eslint-disable no-var */
/* globals svgEditor, svgCanvas, $ */
/*
 * ext-markers.js
 *
 * Licensed under the Apache License, Version 2
 *
 * Copyright(c) 2010 Will Schleter
 *   based on ext-arrows.js by Copyright(c) 2010 Alexis Deveria
 *
 * This extension provides for the addition of markers to the either end
 * or the middle of a line, polyline, path, polygon.
 *
 * Markers may be either a graphic or arbitary text
 *
 * to simplify the coding and make the implementation as robust as possible,
 * markers are not shared - every object has its own set of markers.
 * this relationship is maintained by a naming convention between the
 * ids of the markers and the ids of the object
 *
 * The following restrictions exist for simplicty of use and programming
 *    objects and their markers to have the same color
 *    marker size is fixed
 *    text marker font, size, and attributes are fixed
 *    an application specific attribute - se_type - is added to each marker element
 *        to store the type of marker
 *
 * TODO:
 *    remove some of the restrictions above
 *    add option for keeping text aligned to horizontal
 *    add support for dimension extension lines
 *
 */

svgEditor.addExtension('Markers', function (S) {
	var // svgcontent = S.svgcontent,
		addElem = S.addSvgElementFromJson,
		selElems;

	var mtypes = ['start', 'mid', 'end'];

	var markerPrefix = 'se_marker_';
	var idPrefix = 'mkr_';

	// note - to add additional marker types add them below with a unique id
	// and add the associated icon(s) to marker-icons.svg
	// the geometry is normallized to a 100x100 box with the origin at lower left
	// Safari did not like negative values for low left of viewBox
	// remember that the coordinate system has +y downward
	var markerTypes = {
		nomarker: {},
		leftarrow:
			{element: 'path', attr: {d: 'M0,50 L100,90 L70,50 L100,10 Z'}},
		rightarrow:
			{element: 'path', attr: {d: 'M100,50 L0,90 L30,50 L0,10 Z'}},
		textmarker:
			{element: 'text', attr: {x: 0, y: 0, 'stroke-width': 0, 'stroke': 'none', 'font-size': 75, 'font-family': 'serif', 'text-anchor': 'left',
				'xml:space': 'preserve'}},
		forwardslash:
			{element: 'path', attr: {d: 'M30,100 L70,0'}},
		reverseslash:
			{element: 'path', attr: {d: 'M30,0 L70,100'}},
		verticalslash:
			{element: 'path', attr: {d: 'M50,0 L50,100'}},
		box:
			{element: 'path', attr: {d: 'M20,20 L20,80 L80,80 L80,20 Z'}},
		star:
			{element: 'path', attr: {d: 'M10,30 L90,30 L20,90 L50,10 L80,90 Z'}},
		xmark:
			{element: 'path', attr: {d: 'M20,80 L80,20 M80,80 L20,20'}},
		triangle:
			{element: 'path', attr: {d: 'M10,80 L50,20 L80,80 Z'}},
		mcircle:
			{element: 'circle', attr: {r: 30, cx: 50, cy: 50}}
	};

	var langList = {
		'en': [
			{id: 'start_marker_list', title: 'Select start marker type'},
			{id: 'mid_marker_list', title: 'Select mid marker type'},
			{id: 'end_marker_list', title: 'Select end marker type'},
			{id: 'nomarker', title: 'No Marker'},
			{id: 'leftarrow', title: 'Left Arrow'},
			{id: 'rightarrow', title: 'Right Arrow'},
			{id: 'textmarker', title: 'Text Marker'},
			{id: 'forwardslash', title: 'Forward Slash'},
			{id: 'reverseslash', title: 'Reverse Slash'},
			{id: 'verticalslash', title: 'Vertical Slash'},
			{id: 'box', title: 'Box'},
			{id: 'star', title: 'Star'},
			{id: 'xmark', title: 'X'},
			{id: 'triangle', title: 'Triangle'},
			{id: 'mcircle', title: 'Circle'},
			{id: 'leftarrow_o', title: 'Open Left Arrow'},
			{id: 'rightarrow_o', title: 'Open Right Arrow'},
			{id: 'box_o', title: 'Open Box'},
			{id: 'star_o', title: 'Open Star'},
			{id: 'triangle_o', title: 'Open Triangle'},
			{id: 'mcircle_o', title: 'Open Circle'}
		]
	};

	// duplicate shapes to support unfilled (open) marker types with an _o suffix
	$.each(['leftarrow', 'rightarrow', 'box', 'star', 'mcircle', 'triangle'], function (i, v) {
		markerTypes[v + '_o'] = markerTypes[v];
	});

	// elem = a graphic element will have an attribute like marker-start
	// attr - marker-start, marker-mid, or marker-end
	// returns the marker element that is linked to the graphic element
	function getLinked (elem, attr) {
		var str = elem.getAttribute(attr);
		if (!str) { return null; }
		var m = str.match(/\(#(.*)\)/);
		if (!m || m.length !== 2) {
			return null;
		}
		return S.getElem(m[1]);
	}

	function setIcon (pos, id) {
		if (id.substr(0, 1) !== '\\') { id = '\\textmarker'; }
		var ci = '#' + idPrefix + pos + '_' + id.substr(1);
		svgEditor.setIcon('#cur_' + pos + '_marker_list', $(ci).children());
		$(ci).addClass('current').siblings().removeClass('current');
	}

	// toggles context tool panel off/on
	// sets the controls with the selected element's settings
	function showPanel (on) {
		$('#marker_panel').toggle(on);

		if (on) {
			var el = selElems[0];
			var val;
			var ci;

			$.each(mtypes, function (i, pos) {
				var m = getLinked(el, 'marker-' + pos);
				var txtbox = $('#' + pos + '_marker');
				if (!m) {
					val = '\\nomarker';
					ci = val;
					txtbox.hide(); // hide text box
				} else {
					if (!m.attributes.se_type) { return; } // not created by this extension
					val = '\\' + m.attributes.se_type.textContent;
					ci = val;
					if (val === '\\textmarker') {
						val = m.lastChild.textContent;
						// txtbox.show(); // show text box
					} else {
						txtbox.hide(); // hide text box
					}
				}
				txtbox.val(val);
				setIcon(pos, ci);
			});
		}
	}

	function addMarker (id, val) {
		var txtBoxBg = '#ffffff';
		var txtBoxBorder = 'none';
		var txtBoxStrokeWidth = 0;

		var marker = S.getElem(id);

		if (marker) { return; }

		if (val === '' || val === '\\nomarker') { return; }

		var el = selElems[0];
		var color = el.getAttribute('stroke');
		// NOTE: Safari didn't like a negative value in viewBox
		// so we use a standardized 0 0 100 100
		// with 50 50 being mapped to the marker position
		var refX = 50;
		var refY = 50;
		var viewBox = '0 0 100 100';
		var markerWidth = 5;
		var markerHeight = 5;
		var strokeWidth = 10;
		var seType;
		if (val.substr(0, 1) === '\\') {
			seType = val.substr(1);
		} else { seType = 'textmarker'; }

		if (!markerTypes[seType]) { return; } // an unknown type!

		// create a generic marker
		marker = addElem({
			'element': 'marker',
			'attr': {
				'id': id,
				'markerUnits': 'strokeWidth',
				'orient': 'auto',
				'style': 'pointer-events:none',
				'se_type': seType
			}
		});

		if (seType !== 'textmarker') {
			var mel = addElem(markerTypes[seType]);
			var fillcolor = color;
			if (seType.substr(-2) === '_o') { fillcolor = 'none'; }
			mel.setAttribute('fill', fillcolor);
			mel.setAttribute('stroke', color);
			mel.setAttribute('stroke-width', strokeWidth);
			marker.appendChild(mel);
		} else {
			var text = addElem(markerTypes[seType]);
			// have to add text to get bounding box
			text.textContent = val;
			var tb = text.getBBox();
			// alert(tb.x + ' ' + tb.y + ' ' + tb.width + ' ' + tb.height);
			var pad = 1;
			var bb = tb;
			bb.x = 0;
			bb.y = 0;
			bb.width += pad * 2;
			bb.height += pad * 2;
			// shift text according to its size
			text.setAttribute('x', pad);
			text.setAttribute('y', bb.height - pad - tb.height / 4); // kludge?
			text.setAttribute('fill', color);
			refX = bb.width / 2 + pad;
			refY = bb.height / 2 + pad;
			viewBox = bb.x + ' ' + bb.y + ' ' + bb.width + ' ' + bb.height;
			markerWidth = bb.width / 10;
			markerHeight = bb.height / 10;

			var box = addElem({
				'element': 'rect',
				'attr': {
					'x': bb.x,
					'y': bb.y,
					'width': bb.width,
					'height': bb.height,
					'fill': txtBoxBg,
					'stroke': txtBoxBorder,
					'stroke-width': txtBoxStrokeWidth
				}
			});
			marker.setAttribute('orient', 0);
			marker.appendChild(box);
			marker.appendChild(text);
		}

		marker.setAttribute('viewBox', viewBox);
		marker.setAttribute('markerWidth', markerWidth);
		marker.setAttribute('markerHeight', markerHeight);
		marker.setAttribute('refX', refX);
		marker.setAttribute('refY', refY);
		S.findDefs().appendChild(marker);

		return marker;
	}

	function convertline (elem) {
		// this routine came from the connectors extension
		// it is needed because midpoint markers don't work with line elements
		if (!(elem.tagName === 'line')) { return elem; }

		// Convert to polyline to accept mid-arrow

		var x1 = Number(elem.getAttribute('x1'));
		var x2 = Number(elem.getAttribute('x2'));
		var y1 = Number(elem.getAttribute('y1'));
		var y2 = Number(elem.getAttribute('y2'));
		var id = elem.id;

		var midPt = (' ' + ((x1 + x2) / 2) + ',' + ((y1 + y2) / 2) + ' ');
		var pline = addElem({
			'element': 'polyline',
			'attr': {
				'points': (x1 + ',' + y1 + midPt + x2 + ',' + y2),
				'stroke': elem.getAttribute('stroke'),
				'stroke-width': elem.getAttribute('stroke-width'),
				'fill': 'none',
				'opacity': elem.getAttribute('opacity') || 1
			}
		});
		$.each(mtypes, function (i, pos) { // get any existing marker definitions
			var nam = 'marker-' + pos;
			var m = elem.getAttribute(nam);
			if (m) { pline.setAttribute(nam, elem.getAttribute(nam)); }
		});

		var batchCmd = new S.BatchCommand();
		batchCmd.addSubCommand(new S.RemoveElementCommand(elem, elem.parentNode));
		batchCmd.addSubCommand(new S.InsertElementCommand(pline));

		$(elem).after(pline).remove();
		svgCanvas.clearSelection();
		pline.id = id;
		svgCanvas.addToSelection([pline]);
		S.addCommandToHistory(batchCmd);
		return pline;
	}

	function setMarker () {
		var poslist = {'start_marker': 'start', 'mid_marker': 'mid', 'end_marker': 'end'};
		var pos = poslist[this.id];
		var markerName = 'marker-' + pos;
		var val = this.value;
		var el = selElems[0];
		var marker = getLinked(el, markerName);
		if (marker) { $(marker).remove(); }
		el.removeAttribute(markerName);
		if (val === '') { val = '\\nomarker'; }
		if (val === '\\nomarker') {
			setIcon(pos, val);
			S.call('changed', selElems);
			return;
		}
		// Set marker on element
		var id = markerPrefix + pos + '_' + el.id;
		addMarker(id, val);
		svgCanvas.changeSelectedAttribute(markerName, 'url(#' + id + ')');
		if (el.tagName === 'line' && pos === 'mid') { el = convertline(el); }
		S.call('changed', selElems);
		setIcon(pos, val);
	}

	// called when the main system modifies an object
	// this routine changes the associated markers to be the same color
	function colorChanged (elem) {
		var color = elem.getAttribute('stroke');

		$.each(mtypes, function (i, pos) {
			var marker = getLinked(elem, 'marker-' + pos);
			if (!marker) { return; }
			if (!marker.attributes.se_type) { return; } // not created by this extension
			var ch = marker.lastElementChild;
			if (!ch) { return; }
			var curfill = ch.getAttribute('fill');
			var curstroke = ch.getAttribute('stroke');
			if (curfill && curfill !== 'none') { ch.setAttribute('fill', color); }
			if (curstroke && curstroke !== 'none') { ch.setAttribute('stroke', color); }
		});
	}

	// called when the main system creates or modifies an object
	// primary purpose is create new markers for cloned objects
	function updateReferences (el) {
		$.each(mtypes, function (i, pos) {
			var id = markerPrefix + pos + '_' + el.id;
			var markerName = 'marker-' + pos;
			var marker = getLinked(el, markerName);
			if (!marker || !marker.attributes.se_type) { return; } // not created by this extension
			var url = el.getAttribute(markerName);
			if (url) {
				var len = el.id.length;
				var linkid = url.substr(-len - 1, len);
				if (el.id !== linkid) {
					var val = $('#' + pos + '_marker').attr('value');
					addMarker(id, val);
					svgCanvas.changeSelectedAttribute(markerName, 'url(#' + id + ')');
					if (el.tagName === 'line' && pos === 'mid') { el = convertline(el); }
					S.call('changed', selElems);
				}
			}
		});
	}

	// simulate a change event a text box that stores the current element's marker type
	function triggerTextEntry (pos, val) {
		$('#' + pos + '_marker').val(val);
		$('#' + pos + '_marker').change();
		// var txtbox = $('#'+pos+'_marker');
		// if (val.substr(0,1)=='\\') {txtbox.hide();}
		// else {txtbox.show();}
	}

	function showTextPrompt (pos) {
		var def = $('#' + pos + '_marker').val();
		if (def.substr(0, 1) === '\\') { def = ''; }
		$.prompt('Enter text for ' + pos + ' marker', def, function (txt) {
			if (txt) { triggerTextEntry(pos, txt); }
		});
	}

	/*
	function setMarkerSet(obj) {
		var parts = this.id.split('_');
		var set = parts[2];
		switch (set) {
		case 'off':
			triggerTextEntry('start','\\nomarker');
			triggerTextEntry('mid','\\nomarker');
			triggerTextEntry('end','\\nomarker');
			break;
		case 'dimension':
			triggerTextEntry('start','\\leftarrow');
			triggerTextEntry('end','\\rightarrow');
			showTextPrompt('mid');
			break;
		case 'label':
			triggerTextEntry('mid','\\nomarker');
			triggerTextEntry('end','\\rightarrow');
			showTextPrompt('start');
			break;
		}
	}
	*/
	// callback function for a toolbar button click
	function setArrowFromButton (obj) {
		var parts = this.id.split('_');
		var pos = parts[1];
		var val = parts[2];
		if (parts[3]) { val += '_' + parts[3]; }

		if (val !== 'textmarker') {
			triggerTextEntry(pos, '\\' + val);
		} else {
			showTextPrompt(pos);
		}
	}

	function getTitle (lang, id) {
		var i, list = langList[lang];
		for (i in list) {
			if (list.hasOwnProperty(i) && list[i].id === id) {
				return list[i].title;
			}
		}
		return id;
	}

	// build the toolbar button array from the marker definitions
	// TODO: need to incorporate language specific titles
	function buildButtonList () {
		var buttons = [];
		// var i = 0;
		/*
		buttons.push({
			id: idPrefix + 'markers_off',
			title: 'Turn off all markers',
			type: 'context',
			events: { 'click': setMarkerSet },
			panel: 'marker_panel'
		});
		buttons.push({
			id: idPrefix + 'markers_dimension',
			title: 'Dimension',
			type: 'context',
			events: { 'click': setMarkerSet },
			panel: 'marker_panel'
		});
		buttons.push({
			id: idPrefix + 'markers_label',
			title: 'Label',
			type: 'context',
			events: { 'click': setMarkerSet },
			panel: 'marker_panel'
		});
*/
		$.each(mtypes, function (k, pos) {
			var listname = pos + '_marker_list';
			var def = true;
			$.each(markerTypes, function (id, v) {
				var title = getTitle('en', String(id));
				buttons.push({
					id: idPrefix + pos + '_' + id,
					svgicon: id,
					title: title,
					type: 'context',
					events: {'click': setArrowFromButton},
					panel: 'marker_panel',
					list: listname,
					isDefault: def
				});
				def = false;
			});
		});
		return buttons;
	}

	return {
		name: 'Markers',
		svgicons: svgEditor.curConfig.extPath + 'markers-icons.xml',
		buttons: buildButtonList(),
		context_tools: [
			{
				type: 'input',
				panel: 'marker_panel',
				title: 'Start marker',
				id: 'start_marker',
				label: 's',
				size: 3,
				events: { change: setMarker }
			}, {
				type: 'button-select',
				panel: 'marker_panel',
				title: getTitle('en', 'start_marker_list'),
				id: 'start_marker_list',
				colnum: 3,
				events: { change: setArrowFromButton }
			}, {
				type: 'input',
				panel: 'marker_panel',
				title: 'Middle marker',
				id: 'mid_marker',
				label: 'm',
				defval: '',
				size: 3,
				events: { change: setMarker }
			}, {
				type: 'button-select',
				panel: 'marker_panel',
				title: getTitle('en', 'mid_marker_list'),
				id: 'mid_marker_list',
				colnum: 3,
				events: { change: setArrowFromButton }
			}, {
				type: 'input',
				panel: 'marker_panel',
				title: 'End marker',
				id: 'end_marker',
				label: 'e',
				size: 3,
				events: { change: setMarker }
			}, {
				type: 'button-select',
				panel: 'marker_panel',
				title: getTitle('en', 'end_marker_list'),
				id: 'end_marker_list',
				colnum: 3,
				events: { change: setArrowFromButton }
			}
		],
		callback: function () {
			$('#marker_panel').addClass('toolset').hide();
		},
		addLangData: function (lang) {
			return { data: langList[lang] };
		},
		selectedChanged: function (opts) {
			// Use this to update the current selected elements
			// console.log('selectChanged',opts);
			selElems = opts.elems;

			var i = selElems.length;
			var markerElems = ['line', 'path', 'polyline', 'polygon'];

			while (i--) {
				var elem = selElems[i];
				if (elem && $.inArray(elem.tagName, markerElems) !== -1) {
					if (opts.selectedElement && !opts.multiselected) {
						showPanel(true);
					} else {
						showPanel(false);
					}
				} else {
					showPanel(false);
				}
			}
		},

		elementChanged: function (opts) {
			// console.log('elementChanged',opts);
			var elem = opts.elems[0];
			if (elem && (
				elem.getAttribute('marker-start') ||
				elem.getAttribute('marker-mid') ||
				elem.getAttribute('marker-end')
			)) {
				colorChanged(elem);
				updateReferences(elem);
			}
			// changing_flag = false; // Not apparently in use
		}
	};
});