/* -------------------------- */		
/*        timerPlugin         */		
/* -------------------------- */		
(function (global, factory) {
  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
  typeof define === 'function' && define.amd ? define(['exports'], factory) :
  (factory((global.timerPlugin = global.timerPlugin || {})));
}(this, function (exports) { 'use strict';

var timerPlugin = function timerPlugin(__mapper) {
	var timer

	let config = {}
	config.width = 600
	config.height = 400
	config.gravity = 0.5
	config.startY = 125
	config.step = 50
	config.rotrx = 40	// x rotation radius 
	config.rotry = 20	// y rotation radius 
	config.randNormal = d3.randomNormal(1.3, 2)
	config.randNormal2 = d3.randomNormal(0.5, 1.8)

	function timerPlugin() {} 
	
	function tickFn(_elapsed) {

							var elapsed = _elapsed
							var svgWidth = config.width
							var svgHeight = config.height
              var gravity = config.gravity
				
							var epsilon = 1e-6
							var tau = 2 * Math.PI
							var pi = Math.PI
		
							if (__mapper !== null && typeof(__mapper) === 'function') {
							
								var nodeItems = __mapper("nodes").items()
								var linkItems = __mapper("links").items()
															
								let planets = __mapper("planets").items()				
											.filter(d => d.type === 'planet')	
											.filter(d => d.radius > epsilon)

								let freeplanets = __mapper("planets").items()				
											.filter(d => d.type === 'planet')	
											.filter(d => d.radius > epsilon)
											.filter(d => d.solarid === null)

											
								let solars = __mapper("solars").items()	
											.filter(d => d.type === 'solar')	
											.filter(d => d.radius > epsilon)

											
								let quad = quadPlugin.quadPlugin()		// quad for planets
										.x(function(d) {return d.x})
										.y(function(d) {return d.y})
										.addAll(freeplanets)		

										
								for (let i = 0; i < solars.length; i++) {	// for each SOLAR
										let s = solars[i]
										let arms = s.arms
										let formparams = s.formparams
										let rad = formparams.rad
										let segs = formparams.segs
										let x = s.x
										let y = s.y
										let vx = s.vx
										let vy = s.vy
										let ps = quad.findmanyothers(s.x, s.y,  // find planets
												// __mapper("nodes").searchRange(), 	// howfaraway
												rad + 1, 	// howfaraway
												arms)		// howmany
											let splnks = []				// links from solar
											let pslnks = []				// links to planet
											for (let j = 0; j < ps.length; j++) {		// each reached PLANET
												let p = ps[j]													// this planet
																								
												splnks.push({source: s, target: p, idx: __mapper("links").linkIdFn(s, p)}) 
												pslnks.push({source: p, target: s, idx: __mapper("links").linkIdFn(s, p)})
												
												let angleRadians = Math.atan2(p.y - s.y, p.x - s.x)		// angle - determines range
												
												// add PI to make positive
												let angidx = Math.round(((Math.PI + angleRadians) /  (2 * Math.PI )) * segs)
													
												let t_x = s.points[0][0]
												let t_y = s.points[0][1]
												if (s.points[angidx]) t_x = s.points[angidx][0]
												if (s.points[angidx]) t_y = s.points[angidx][1]
												
												let rng = __mapper("nodes").distance(		// distance in angle
														{"x":t_x, "y":t_y}, 
														{"x":0, "y":0})
																			
												
												let spdst = __mapper("nodes").distance(s, p)		// current distance sol, planet
												let range =  rng // __mapper("config").solar.absorbfn(s)	// range for absorbtion
												
												
												if (spdst < range && 			// planet within solar range
													( p.solarid === null || 	// planet is not bound
														solars[s.idx].energy < solars[p.solarid].energy)	// new solar is less energy
													) {	

																p.toffset = angleRadians * p.periodtime / (2 * Math.PI)
																p.starttime = undefined														// reset phase timer 
																p.solarid = s.idx 
																p.angidx = angidx
																		
																if (s.points[p.angidx]) p.x = s.points[p.angidx][0]	// upd planet coords
																if (s.points[p.angidx]) p.y = s.points[p.angidx][1]
																p.trace[p.trace.length] = [p.x,p.y]								
																		
															}
													p.pslinks = pslnks
											}
											s.links = splnks				// add link to solar
									}
									
									
									let remainingSolars = solars.reduce ((p, c, i, a) => p.concat(c.links), [])
										
									__mapper("links").items(remainingSolars)	// links from solars
									__mapper("solars").render()			// RENDER SOLARS
									__mapper("planets").render()		// RENDER PLANETS
									__mapper("links").render()			// RENDER LINKS
								
								
							}
				
	}
	
	timerPlugin.start = function () {
				timer = d3.timer(tickFn)
	}

	 
	return timerPlugin	
}
exports.timerPlugin = timerPlugin

}));