// Noise parameters are explained here:
// https://minetest.gitlab.io/minetest/perlin-noise/#noise-parameters

// Perlin values below minDisplayedNoiseValue are 
// drawn blue, values above maxDisplayedNoiseValue 
// are cyan, and values within the range are greyscale.

// Due to precision of javascript's number type, this 
// emulator may get it wrong in extreme cases. The BigInts
// option can correct for that, but is slow and rarely needed.

function postprocess_perlinValue(value) {
  // if you want to make a programatic adjustment
  // to the value before it's displayed then that
  // can be done here.
  return value;
}

const MAGIC_X    = 1619;
const MAGIC_Y    = 31337;
const MAGIC_Z    = 52591;
const MAGIC_SEED = 1013;

const NOISE_MAGIC_X    = 1619n;
const NOISE_MAGIC_Y    = 31337n;
const NOISE_MAGIC_Z    = 52591n;
const NOISE_MAGIC_SEED = 1013n;



var opts;

var Options = function() {
  this.imageSize = 528;
  this.minDisplayedNoiseValue = -1;
  this.maxDisplayedNoiseValue = 1;
  this.colorizeClippedValues = true;
  this.offset = 0.0;
  this.scale = 1;
  this.spread_x = 64;
  this.spread_y = 64;
  this.octaves = 6;
  this.persistence = 0.5;
  this.lacunarity = 2;
  this.eased = true;
  this.absvalue = false;
  this.absFinalValue = false;
  this.useBigInts = false;
  this.zoomFactor = 10;
  
  this.seed = 1;
  
  this.newSeed = () => {
    newSeed(Math.random());
    drawCanvas();
  };
};


function minetest_noise2d(x, y, seed)
{
  // Due to Javascript lacking good integer types, this result will
  // tend toward 1 as y becomes large.
  // minetest_noise2d_BigInts() fixes this problem but is ridiculously slow.
  //var n = (MAGIC_X * x + MAGIC_Y * y + MAGIC_SEED * seed) & 0x7fffffff;
  
  var n = (
      ((
        ((MAGIC_X    * x)  & 0x7fffffff) + 
        ((MAGIC_Y    * y)  & 0x7fffffff) 
      ) & 0x7fffffff) +
      ((MAGIC_SEED * seed) & 0x7fffffff)
    ) & 0x7fffffff;
  n = (n >>> 13) ^ n;
/*
  n = ( 
    ((
      n * ( 
        (( 
          (( 
            ((
              n * n
            ) & 0x7fffffff) * 
            60493
          ) & 0x7fffffff) + 
          19990303
        ) & 0x7fffffff) 
      )) & 0x7fffffff) + 
    1376312589) & 0x7fffffff;
  */
  
  n = ( ((n * ( (( (( ((n * n) & 0x7fffffff) * 60493) & 0x7fffffff) + 19990303) & 0x7fffffff) )) & 0x7fffffff) + 1376312589) & 0x7fffffff;
  
  //n = (n * (n * n * 60493 + 19990303) + 1376312589) & 0x7fffffff;
  return 1 - (Math.floor(n) / 0x40000000);
}

function minetest_noise2d_BigInts(x, y, seed)
{
  // In Minetest, n is an unsigned int, which Javascript does not possess, so 
  // divide and shift operations on it must be performed unsigned.
  // (Before a bitwise operation is performed, JavaScript converts numbers to 
  // 32 bits signed integers)
  //
  // Note that in two's complement arithmetic, the arithmetic operations of 
  // add, subtract, and multiply are bit-wise identical if the two operands 
  // are regarded as both being signed or both being unsigned.
  //var n = (NOISE_MAGIC_X * BigInt(x) + NOISE_MAGIC_Y * BigInt(y) + NOISE_MAGIC_SEED * BigInt(seed)) & 0x7fffffffn;
  //n = (n >> 13n) ^ n;
  var n = (
    ((MAGIC_X    * x)    & 0x7fffffff) + 
    ((MAGIC_Y    * y)    & 0x7fffffff) + 
    ((MAGIC_SEED * seed) & 0x7fffffff)
  ) & 0x7fffffff;
  var nn = BigInt((n >>> 13) ^ n);
  
  nn = (nn * (nn * nn * 60493n + 19990303n) + 1376312589n) & 0x7fffffffn;
  return 1 - Number(nn) / 0x40000000;
}


const UINT32_MAGIC_X    = UINT32(1619);
const UINT32_MAGIC_Y    = UINT32(31337);
const UINT32_MAGIC_SEED = UINT32(1013);
const UINT32_RNG_PRIME1 = UINT32(60493);
const UINT32_RNG_PRIME2 = UINT32(19990303);
const UINT32_RNG_PRIME3 = UINT32(1376312589);
const UINT32_MASK31     = UINT32(0x7fffffff);

function minetest_noise2d_jscuint(x, y, seed)
{
  // In Minetest, n is an unsigned int, which Javascript does not possess, so 
  // divide and shift operations on it must be performed unsigned.
  // (Before a bitwise operation is performed, JavaScript converts numbers to 
  // 32 bits signed integers)
  //
  // Note that in two's complement arithmetic, the arithmetic operations of 
  // add, subtract, and multiply are bit-wise identical if the two operands 
  // are regarded as both being signed or both being unsigned.
  //var n = (NOISE_MAGIC_X * BigInt(x) + NOISE_MAGIC_Y * BigInt(y) + NOISE_MAGIC_SEED * BigInt(seed)) & 0x7fffffffn;
  //n = (n >> 13n) ^ n;
  var n = UINT32(x).multiply(UINT32_MAGIC_X)
    .add(UINT32(y).multiply(UINT32_MAGIC_Y))
    .add(UINT32(seed).multiply(UINT32_MAGIC_SEED))
    .and(UINT32_MASK31)
         
  var nn = n.clone().shiftRight(13).xor(n)
  
  nn = nn.clone().multiply(
    nn.clone().multiply(nn).multiply(UINT32_RNG_PRIME1).add(UINT32_RNG_PRIME2)
  ).add(UINT32_RNG_PRIME3).and(UINT32_MASK31)
         
  //nn = (nn * (nn * nn * 60493n + 19990303n) + 1376312589n) & 0x7fffffffn;
  return 1 - nn.toNumber() / 0x40000000;
}



function minetest_noise2d_gradient(x, y, seed, eased)
{
  seed = Math.floor(seed);
  
	// Calculate the integer coordinates
	var x0 = Math.floor(x);
	var y0 = Math.floor(y);  
	// Calculate the remaining part of the coordinates
	var x1 = x - x0;
	var y1 = y - y0;
  
	// Get values for corners of square
  var v00, v10, v01, v11
  if (opts.useBigInts) {
    // slooooow
    /*
    v00 = minetest_noise2d_BigInts(x0, y0, seed);
    v10 = minetest_noise2d_BigInts(x0+1, y0, seed);
    v01 = minetest_noise2d_BigInts(x0, y0+1, seed);
    v11 = minetest_noise2d_BigInts(x0+1, y0+1, seed);
    //*/
    
    v00 = minetest_noise2d_jscuint(x0, y0, seed);
    v10 = minetest_noise2d_jscuint(x0+1, y0, seed);
    v01 = minetest_noise2d_jscuint(x0, y0+1, seed);
    v11 = minetest_noise2d_jscuint(x0+1, y0+1, seed);
    //*/
  } else {
    v00 = minetest_noise2d(x0, y0, seed);
    v10 = minetest_noise2d(x0+1, y0, seed);
    v01 = minetest_noise2d(x0, y0+1, seed);
    v11 = minetest_noise2d(x0+1, y0+1, seed);    
  }

  // Interpolate  
  return eased ?
    biLinearInterpolation(v00, v10, v01, v11, x1, y1) :
    biLinearInterpolationNoEase(v00, v10, v01, v11, x1, y1);
}

/*
 * Ease function used by Minetest
 */
function biLinearInterpolation(v00, v10,v01, v11, x, y)
{
  var tx = x * x * x * (x * (6.0 * x - 15.0) + 10.0); // easeCurve(x);
  var ty = y * y * y * (y * (6.0 * y - 15.0) + 10.0); // easeCurve(y);
  var u = v00 + (v10 - v00) * tx; // linearInterpolation(v00, v10, tx);
  var v = v01 + (v11 - v01) * tx; // linearInterpolation(v01, v11, tx);
  return    u + (v   -   u) * ty; // linearInterpolation(u, v, ty);
}

/*
 * NoEase interp function used by Minetest
 */
function biLinearInterpolationNoEase(v00, v10,v01, v11, x, y)
{
  var u = v00 + (v10 - v00) * x; // linearInterpolation(v00, v10, x);
  var v = v01 + (v11 - v01) * x; // linearInterpolation(v01, v11, x);
  return    u + (v   -   u) * y; // linearInterpolation(u, v, y);
}	


function showSpinner(visible) {
  var spinner = document.querySelector('div.spinner');  
  spinner.style.visibility = visible ? 'visible' : 'hidden';
}

/*
 * Draw on canvas
 */
// renders perlin noise on canvas with given ease function applied to value
function updatePreview() {
  //drawCanvas();
    
  showSpinner(true);
  setTimeout(
    function() {
      drawCanvas();
      showSpinner(false);
    }, 
    1
  );
}
  
function drawCanvas() {  
  var canvas = document.querySelector('canvas.main');
  canvas.width = opts.imageSize;
  canvas.height = opts.imageSize;
  var ctx = canvas.getContext('2d');
  var image = ctx.createImageData(canvas.width, canvas.height);
  var data = image.data;
  
  if (opts.maxDisplayedNoiseValue < opts.minDisplayedNoiseValue) {
    var temp = opts.maxDisplayedNoiseValue;
    opts.maxDisplayedNoiseValue = opts.minDisplayedNoiseValue;
    opts.minDisplayedNoiseValue = temp;    
  }
  
  // Minetest Protects against an octave having a spread < 1
  // Maximum possible spread value factor
  var octacve_warning = document.querySelector('div.octave_warning');
  var noisepoints_warning = document.querySelector('div.noisepoints_warning');
  var wavelength = document.querySelector('.wavelength');
	var ofactor = (opts.lacunarity > 1.0) ?
		Math.pow(opts.lacunarity, opts.octaves - 1) :
		opts.lacunarity;  
  
  wavelength.textContent = " wavelength " + 
    (Math.round(Math.max(opts.spread_x / ofactor,opts.spread_y / ofactor) * 100) / 100)
  
  octacve_warning.style.display =   
	  (opts.spread_x / ofactor < 1.0 || opts.spread_y / ofactor < 1.0) ?
    "block" : "none";

  /*
  noisepoints_warning.style.display = 
    (opts.imageSize * ofactor / Math.min(opts.spread_x, opts.spread_y) > 1000000000) ?
    "block" : "none";*/
  
  var seed = opts.seed
  
  for (var px_x = 0; px_x < canvas.width; px_x++) {
    for (var px_y = 0; px_y < canvas.height; px_y++) {
      
      var a = 0;
      var f = 1;
      var g = 1;
      
      var x = px_x / opts.spread_x;
      var y = px_y / opts.spread_y;

      for (var i = 0; i < opts.octaves; i++) {
        
        var noiseval = minetest_noise2d_gradient(x * f, y * f, seed + i, opts.eased);        
        if (opts.absvalue) {
          noiseval = Math.abs(noiseval);
        }
        
        a += g * noiseval;
        f *= opts.lacunarity;
        g *= opts.persistence;
      }
      
      var value = opts.offset + a * opts.scale
      
      if (opts.absFinalValue) {
        // absFinalValue is something the lua mod might do with the perlin noise value
        // it's not a Minetest engine flag like absvalue which applies the abs to each octave.
        value = Math.abs(value);
      }      
      value = postprocess_perlinValue(value);
      
      // set the canvas color based on where noiseval falls between
      // minDisplayedNoiseValue and maxDisplayedNoiseValue
      var clipped = opts.colorizeClippedValues && (value > opts.maxDisplayedNoiseValue || value < opts.minDisplayedNoiseValue);
      value = Math.min(opts.maxDisplayedNoiseValue, Math.max(opts.minDisplayedNoiseValue, value));
      value = 255 * (value - opts.minDisplayedNoiseValue) / (opts.maxDisplayedNoiseValue - opts.minDisplayedNoiseValue);
           
      var cell = (px_x + px_y * canvas.width) * 4;
      data[cell] = data[cell + 1] = data[cell + 2] = Math.floor(value);      
      if (clipped) {
        data[cell + 0] = 0;
        data[cell + 2] = 255;
      }
      
      data[cell + 3] = 255; // alpha
    }
  }
  
  ctx.putImageData(image, 0, 0);
  
  drawZoomed(image, opts.zoomFactor);
  showSpinner(false);  
}

function drawZoomed(image, factor) {
  
  document.querySelector(".zoomfactor").textContent = "zoom ×" + factor;
  
  var sourceSize = Math.floor(opts.imageSize / factor);

  var tempCanvas = document.createElement("canvas");
  var tempCtx = tempCanvas.getContext("2d");
  tempCanvas.width = tempCanvas.height = sourceSize;
  tempCtx.putImageData(image, 0, 0);
  
  var canvas = document.querySelector('canvas.zoom');
  canvas.width = canvas.height = sourceSize * factor;
  var ctx = canvas.getContext('2d');  
  ctx.scale(factor, factor);
  ctx.imageSmoothingEnabled = false;
  ctx.drawImage(tempCanvas, 0, 0);
}

function maxLacunarity() {
  var minSpread = Math.min(opts.spread_x, opts.spread_y);
  var result = Math.pow(minSpread, 1.0 / (opts.octaves - 1))
  return Math.trunc((result) * 100) / 100
}
/*
	var ofactor = (opts.lacunarity > 1.0) ?
		Math.pow(opts.lacunarity, opts.octaves - 1) :
		opts.lacunarity;  
  
	if (opts.spread_x / ofactor < 1.0 ||
			opts.spread_y / ofactor < 1.0) {
    octacve_warning.style.visibility = "visible";
	} else {
    octacve_warning.style.visibility = "hidden";    
  }
*/


function init() {
  opts = new Options();
    
  const pane = new Tweakpane({
    //title: 'Parameters',
    container: document.getElementById('controlpanel'),
  });
  pane.element.parentElement.style.width = '400px';
  pane.element.style.fontSize = "12px";

  const pane_noise = pane.addFolder({ expanded: true, title: 'Noise params' });
  pane_noise.addInput(opts, 'offset');
  pane_noise.addInput(opts, 'scale');
  pane_noise.addInput(opts, 'spread_x', {label: 'spread.x'});
  pane_noise.addInput(opts, 'spread_y', {label: 'spread.y'});
  pane_noise.addInput(opts, 'octaves', {min: 1, max: 16, step: 1});  
  pane_noise.addInput(opts, 'persistence', {min: 0, max: 10, step: 0.01});
  const control_lacunarity = pane_noise.addInput(opts, 'lacunarity', {min: 0, max: 10, step: 0.01});
  pane_noise.addButton({ title: 'Find maximum lacunarity (but 2.0 is better)' }).on('click', () => { 
    opts.lacunarity = maxLacunarity();
    control_lacunarity.refresh();
  });  
  pane_noise.addInput(opts, 'eased', {label: 'Flags: eased'});
  pane_noise.addInput(opts, 'absvalue', {label: 'Flags: absvalue'});
  pane_noise.addInput(opts, 'absFinalValue', {label: 'Apply abs() to final value'});
  pane_noise.addSeparator();
  
  const control_seed = pane_noise.addInput(opts, 'seed', {label: "Seed", step: 1});
  pane_noise.addButton({ title: 'New seed' }).on('click', () => { 
    opts.seed = Math.floor(Math.random() * 0xFFFFFFFF);
    control_seed.refresh();
  });
  
  pane.addSeparator();
  const pane_preview = pane.addFolder({ expanded: true, title: 'Preview rendering options' });
  pane_preview.addInput(opts, 'imageSize', {label: 'Image size', min: 16, max: 1000, step: 1});
  pane_preview.addInput(opts, 'zoomFactor', {label: 'Zoom factor', min: 1, max: 30, step: 1});
  pane_preview.addInput(opts, 'minDisplayedNoiseValue', {label: 'Min. displayed noise value'});
  pane_preview.addInput(opts, 'maxDisplayedNoiseValue', {label: 'Max. displayed noise value'});  
  pane_preview.addInput(opts, 'colorizeClippedValues', {label: 'Colorize clipped values'});
  pane_preview.addInput(opts, 'useBigInts', {label: 'Use BigInts (slooow)'});
  
  
  pane.on('change', (value) => {
    updatePreview();
  });
  
  updatePreview();
}


init();
//window.addEventListener('load',init);