const config ={
   separationDistance: 0.2, // Separation distance between new streamlines.
   simplification: 0.1, // line simplification amount (0.1-2)
   paperWidth : 600, // width and height of SVG canvas
   paperHeight: 600,
   boundingBox: 
  {left: -5, top: -5, width: 10, height: 10} // This is the "zoom" level of the rendering
 } 

// What function to produce streamlines for
let vectorField = function(p) {
  return {
      x: Math.cos((Math.cos(p.y)-p.x*p.y)),
      y: (p.x)
    }; 
}

let SVGcanvas = SVG('drawing').size(config.paperWidth, config.paperHeight);
let width = SVGcanvas.width();
let height = SVGcanvas.height();

const seedPoint = {
  x: config.boundingBox.left + Math.random() * config.boundingBox.width,
  y: config.boundingBox.top + Math.random() * config.boundingBox.height
}

function compileVectorFieldFunction(code) {
  try {
    let creator = new Function(code + '\nreturn vectorField;');
    let vectorField = creator();
    vectorField(seedPoint); // just a test.
    return vectorField;
  } catch (e) {
    alert(e.message);
    //fieldCode.error = e.message;
    return null;
  }
}
let streamlinesProcess = null;

const generateStreamlines = function() {
  SVGcanvas.clear();
  const description = document.createElement("title");
description.innerHTML = document.getElementById("function").innerHTML.trim();

SVGcanvas.node.appendChild(description);  
  const svgGroup = SVGcanvas.group();
  
  streamlinesProcess = streamlines({
  // As usual, define your vector field:
//  vectorField(p) { return {x: Math.sin(p.x*p.x)*p.y, y: p.x}; },
  vectorField,
  onStreamlineAdded(points) {
    let transformedPoints = [];
    for (let i = 0; i < points.length; i++){
      let tx = (points[i].x - config.boundingBox.left)/ config.boundingBox.width;
      let ty = (points[i].y - config.boundingBox.top)/ config.boundingBox.height;
      transformedPoints.push([Math.round(tx * width * 10 ) / 10, Math.round(((1 - ty) * height ) * 10 ) / 10 ]);
    }
    let simplifiedPath = simplify(transformedPoints, config.simplification);
    let polyline = svgGroup.polyline(simplifiedPath).fill('none').stroke({width:1});
  
  },
  seed: seedPoint,
  boundingBox: config.boundingBox,
  // Separation distance between new streamlines.
  dSep: config.separationDistance,

  // Distance between streamlines when integration should stop.
  dTest: 0.001,
  timeStep: 0.01
});
  streamlinesProcess.run();
}

generateStreamlines();

let downloadButtonEl = document.getElementById("download");

downloadButtonEl.addEventListener("click", writeDownloadLink);

let regenerateButtonEl = document.getElementById("generate");
regenerateButtonEl.addEventListener("click", function(){
  let func = generate();
  document.getElementById("function").innerHTML = func;
  vectorField = compileVectorFieldFunction(func);
  
  streamlinesProcess.dispose();
  generateStreamlines();
});

// util functions
function writeDownloadLink(){
 var svgDoctype = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>';

  // serialize our SVG XML to a string.
  var svgString = (new XMLSerializer()).serializeToString(document.body.querySelector("svg"));

  // reduce the SVG path by cutting off floating point values after the first digit beyond floating point (~50% less MBs)
  svgString = svgString.replace(/([\-+]?\d{1,}\.\d{3,}([eE][\-+]?\d+)?)/g, function (x) {
    return (+x).toFixed(1)
  });

  var blob = new Blob([svgDoctype+svgString], {type: 'image/svg+xml;charset=utf-8'});

  /* This portion of script saves the file to local filesystem as a download */
  var svgUrl = URL.createObjectURL(blob);

  var downloadLink = document.createElement("a");
  downloadLink.href = svgUrl;
  downloadLink.download = "streamlines" + Date.now() + ".svg";
  document.body.appendChild(downloadLink);
  downloadLink.click();
  document.body.removeChild(downloadLink);
}

// square distance from a point to a segment
function getSqSegDist(p, p1, p2) {
    var x = p1[0],
        y = p1[1],
        dx = p2[0] - x,
        dy = p2[1] - y;

    if (dx !== 0 || dy !== 0) {

        var t = ((p[0] - x) * dx + (p[1] - y) * dy) / (dx * dx + dy * dy);

        if (t > 1) {
            x = p2[0];
            y = p2[1];

        } else if (t > 0) {
            x += dx * t;
            y += dy * t;
        }
    }

    dx = p[0] - x;
    dy = p[1] - y;

    return dx * dx + dy * dy;
}

function simplifyDPStep(points, first, last, sqTolerance, simplified) {
    var maxSqDist = sqTolerance,
        index;

    for (var i = first + 1; i < last; i++) {
        var sqDist = getSqSegDist(points[i], points[first], points[last]);

        if (sqDist > maxSqDist) {
            index = i;
            maxSqDist = sqDist;
        }
    }

    if (maxSqDist > sqTolerance) {
        if (index - first > 1) simplifyDPStep(points, first, index, sqTolerance, simplified);
        simplified.push(points[index]);
        if (last - index > 1) simplifyDPStep(points, index, last, sqTolerance, simplified);
    }
}

// simplification using Ramer-Douglas-Peucker algorithm
function simplify(points, tolerance) {
    if (points.length<=1)
        return points;
    tolerance = typeof tolerance === 'number' ? tolerance : 1;
    var sqTolerance = tolerance * tolerance;
    
    var last = points.length - 1;

    var simplified = [points[0]];
    simplifyDPStep(points, 0, last, sqTolerance, simplified);
    simplified.push(points[last]);

    return simplified;
}