/* ****************************************************
   iLand Spinup Library
   Werner Rammer, 2017
   see details: iland.boku.ac.at/spinup
 **************************************************** */
 
 console.log("loading spinuplib.js");
 
 // helper function that simplifies to execute a function in the context of a particular stand
// e.g.: run_as(123, function() { fmengine.log(stand.id); } );
function run_as(stand_id, what) {
	var old = fmengine.standId;
	fmengine.standId=stand_id;
	what();
	fmengine.standId=old;
}

/** create a String representation of an Javascript object */
function toString(obj) {
	return JSON.stringify(obj, null, 4);
}

/** create a String representation of an Javascript object */
function toFlatString(obj) {
	return toString(obj).replace(/(?:\r\n|\r|\n)/g, ' ');
}

/** print a string representation of an Javascript object to the console */
function printObj( obj) {
	console.log(JSON.stringify(obj, null, 4));
}
/** simple function to duplicate an object. Note that functions are not copied! */
function cloneObj( obj ) {
	return JSON.parse(JSON.stringify(obj));
}

function speciesShareString() {
 var s="";
 for (var i=0;i<stand.nspecies;++i)
    s += stand.speciesId(i) + ": " + Math.round(stand.relSpeciesBasalArea(i)*1000)/1000 + " ";
 return s;
}

 /** A DBH-Distribution Class
 */
  function DBHDist(path, sipath) {
	this.path = path;
	this.sipath = sipath;
	this.dbhdist = Factory.newDBHDistribution();
	this.setup = function() { var sids = fmengine.standIds; 
							  for (var i=0;i<sids.length;++i)
								  this.dbhdist.addStand(sids[i]);
							  this.save();
							}
	this.add = function(stand_id) { this.dbhdist.addStand(stand_id); }
	this.save = function()  {  this.dbhdist.calculate(); 
								this.dbhdist.saveToTextFile(this.path);
								this.dbhdist.saveStandInfo(this.sipath);
	}
	this.saveState = function()  {  this.dbhdist.calculate();
									// http://stackoverflow.com/questions/10802273/insert-a-string-before-the-extension-in-a-filename
									var fname = this.path.replace(/(\.[\w\d_-]+)$/i, '_' + Globals.year + '$1');
									this.dbhdist.saveToTextFile(fname);
									var fname = this.sipath.replace(/(\.[\w\d_-]+)$/i, '_' + Globals.year + '$1');
									this.dbhdist.saveStandInfo(fname); 	
									}
}


/** Logger-Class */
function Logger(logfile) {
	this.path=logfile;
	this.text = "year;stand;text"; // the lines
	this.save = function() {  Globals.saveTextFile(Globals.path(this.path), this.text);  }
	this.log = function(txt) { var line=Globals.year + ";" + stand.id + ";" + txt; 
								this.text = this.text + "\n" + line; }
}

/** Snapshotter */
function Snapshot(databasefile, ru_file_list) {
	this.path = databasefile;
	this.rus = {};
	// load the resource-unit-list: for each stand_id a number of resource unit ids
	var csv = Factory.newCSVFile(Globals.path(ru_file_list)); // do load a file
	for (var i=0;i<csv.rowCount;++i) {
		var stand_id = Number(csv.value(i, 'stand_id'));
		if (this.rus[stand_id] === undefined) {
			this.rus[stand_id] = [ Number(csv.value(i, 'rid')) ];
		} else {
			this.rus[stand_id].push( Number(csv.value(i, 'rid')) );
		}
	}
	
	this.save = function(standid) {  // save trees and saplings 
									Globals.saveStandSnapshot(standid, this.path);
									 // save also the carbon pools
									 Globals.saveStandCarbon(standid, this.rus[standid]);
	                               }
	this.loadAll = function() {
		var sids = fmengine.standIds; 
		for (var i=0;i<sids.length;++i) {
		    console.log('Loading snapshot for stand: ' + sids[i] );
		    Globals.loadStandSnapshot(sids[i], this.path);
		}
		// load also the stored carbon values
		Globals.loadStandCarbon();
		
	}
}


// Calculate Bray-Curtis-Similarity Index
// http://84.89.132.1/~michael/stanford/maeb5.pdf
// return 1 if distributions completely different, 0 if completely equal.
// 'rest' is treated as a special case
function similarity(target, current)
{
	var sum_diff = 0;
	var current_rest = 0;
	for (s in current) {
		if (s in target)
			sum_diff += Math.abs(current[s] - target[s]);
		else
			current_rest += current[s];
		console.log(s + ": " + sum_diff + ", rest: " + current_rest);
	}
	for (s in target)
		if (s!='rest' && !(s in current)  && target[s]!==undefined)
			sum_diff += target[s];
		
	if ('rest' in target)
		sum_diff += Math.abs( target['rest'] - current_rest );
	else
		sum_diff += current_rest;
	return sum_diff;
}


// update planting target, input: object with
// * target species shars
// * current planting target
// * current state (target year)
function updatePlantingTarget(target, current, state)
{
	var res = { extra: {} };
	for (s in target) {
		var curr_diff = target[s] - (state[s]===undefined?0 : state[s]);
		console.log(s + ": diff: " + curr_diff);
		if (Math.abs(curr_diff)>=0.1) {
			if (current[s]==undefined) 
				current[s] = target[s];
			else
				current[s] += curr_diff;
			// save species which show strong overestimating
			if (current[s]<-0.1)
				res.extra[s] = -current[s];
		}
	}
	for (s in state) {
		if (state[s]>0.1 && target[s]===undefined)
			res.extra[s] = 0.1;
	}
	// fix/rescale current
	var csum = 0;
	for (s in current)
		csum += Math.max(current[s],0);
	for (s in current)
		current[s] = Math.max(current[s]/csum,0);
	res['current'] = current;
	return res;
}

// Tending, from WBT project
function calculateSpeciesProbabilities(plan_rel, pct_reduction, min_value_remaining)
{
	// collect basal areas 
	var state_abs = {};
	var total = 0;
	for (var i=0;i<stand.nspecies;++i) {
	state_abs[stand.speciesId(i)] = stand.speciesBasalArea(i);
	total += stand.speciesBasalArea(i);
	}
	if (stand.trace) {
		fmengine.log("State before");
		printObj(state_abs);
	}
	
	var target = Math.max(total * (100-pct_reduction)/100, min_value_remaining );
	if (target == min_value_remaining)
		return false;
	
	var plan = alignTarget(state_abs, plan_rel, target);
	return plan;
}

// tending function, source: WBT
function alignTarget(full_state_abs, plan_rel, target_abs)
{
	var plan = {}; // empty object
	var state_abs = {rest: 0}; // 
	
	var plan_sum = 0;
	var state_sum = 0;
	var s;
	for (s in full_state_abs) {
		if (s in plan_rel)
			state_abs[s] = full_state_abs[s];
		else
			state_abs['rest'] += full_state_abs[s];
	}
	if (!('rest' in plan_rel))
		plan_rel['rest'] = 0;
	//print(state_abs); 
	
	for (s in state_abs) {
		//fmengine.log(s + ": " + target_abs * plan_rel[s] + ": " + state_abs[s] );
		plan[s] = Math.min(target_abs * plan_rel[s], state_abs[s] );
		//fmengine.log(Math.min(target_abs * plan_rel[s], state_abs[s] ));
		plan_sum += plan[s];
		state_sum += state_abs[s];
	}
	//print(plan);
	//fmengine.log(plan_sum); fmengine.log(state_sum);
	if (plan_sum==0)
		return false;
	plan_sum = 0;
	for (s in state_abs) {
		plan[s] = state_abs[s]- plan[s];
		plan_sum += plan[s];
	}
	for (s in state_abs) {
		plan[s] = ( plan[s] * (state_sum-target_abs) / plan_sum);
		if (state_abs[s]>0) 
			plan[s] /= state_abs[s];
		else
			plan[s] = 1; // do nothing when nothing is in state
	}
	return plan;
}