///
/// Class: functionNode
///
/// [INTERNAL] Represents a single function, inside JS, webGL, or openGL.
///
/// This handles all the raw state, converted state, etc. Of a single function.
///
/// Properties:
/// 	functionName         - {String}        Name of the function
/// 	jsFunction           - {JS Function}   The JS Function the node represents
/// 	jsFunctionString     - {String}        jsFunction.toString()
/// 	paramNames           - {[String,...]}  Parameter names of the function
/// 	paramType            - {[String,...]}  Shader land parameter type assumption
/// 	isRootKernel         - {Boolean}       Special indicator, for kernel function
/// 	webglFunctionString  - {String}        webgl converted function string
/// 	openglFunctionString - {String}        opengl converted function string
/// 	calledFunctions      - {[String,...]}  List of all the functions called
/// 	initVariables        - {[String,...]}  List of variables initialized in the function
/// 	readVariables        - {[String,...]}  List of variables read operations occur
/// 	writeVariables       - {[String,...]}  List of variables write operations occur
///
var functionNode = (function() {

	//
	// Constructor
	//----------------------------------------------------------------------------------------------------

	///
	/// Function: functionNode
	///
	/// [Constructor] Builds the function with the given JS function, and argument type array.
	///
	/// Parameters:
	/// 	gpu             - {GPU}                   The GPU instance
	/// 	functionName    - {String}                Function name to assume, if its null, it attempts to extract from the function
	/// 	jsFunction      - {JS Function / String}  JS Function to do conversion
	/// 	paramTypeArray  - {[String,...]}          Parameter type array, assumes all parameters are "float" if null
	/// 	returnType      - {String}                The return type, assumes "float" if null
	///
	function functionNode( gpu, functionName, jsFunction, paramTypeArray, returnType ) {

		this.gpu = gpu;

		//
		// Internal vars setup
		//
		this.calledFunctions  = [];
		this.initVariables    = [];
		this.readVariables    = [];
		this.writeVariables   = [];

		//
		// Missing jsFunction object exception
		//
		if( jsFunction == null ) {
			throw "jsFunction, parameter is null";
		}

		//
		// Setup jsFunction and its string property + validate them
		//
		this.jsFunctionString = jsFunction.toString();
		if( !gpu_utils.isFunctionString(this.jsFunctionString) ) {
			console.error("jsFunction, to string conversion check falied: not a function?", this.jsFunctionString);
			throw "jsFunction, to string conversion check falied: not a function?";
		}

		if( !gpu_utils.isFunction(jsFunction) ) {
			//throw "jsFunction, is not a valid JS Function";
			this.jsFunction = null;
		} else {
			this.jsFunction = jsFunction;
		}

		//
		// Setup the function name property
		//
		this.functionName = functionName ||
			(jsFunction && jsFunction.name) ||
			gpu_utils.getFunctionName_fromString(this.jsFunctionString);

		if( !(this.functionName) ) {
			throw "jsFunction, missing name argument or value";
		}

		//
		// Extract parameter name, and its argument types
		//
		this.paramNames = gpu_utils.getParamNames_fromString(this.jsFunctionString);
		if( paramTypeArray != null ) {
			if( paramTypeArray.length != this.paramNames.length ) {
				throw "Invalid argument type array length, against function length -> ("+
					paramTypeArray.length+","+
					this.paramNames.length+
				")";
			}
			this.paramType = paramTypeArray;
		} else {
			this.paramType = [];
			for(var a=0; a<this.paramNames.length; ++a) {
				this.paramType.push("float");
			}
		}

		//
		// Return type handling
		//
		this.returnType = returnType || "float";
	}

	//
	// Core function
	//----------------------------------------------------------------------------------------------------

	///
	/// Function: getJSFunction
	///
	/// Gets and return the stored JS Function.
	/// Note: that this internally eval the function, if only the string was provided on construction
	///
	/// Returns:
	/// 	{JS Function} The function object
	///
	function getJSFunction() {
		if( this.jsFunction ) {
			return this.jsFunction;
		}

		if( this.jsFunctionString ) {
			this.jsFunction = eval( this.jsFunctionString );
			return this.jsFunction;
		}

		throw "Missin jsFunction, and jsFunctionString parameter";
	}
	functionNode.prototype.getJSFunction = getJSFunction;

	///
	/// Function: getJS_AST
	///
	/// Parses the class function JS, and returns its Abstract Syntax Tree object.
	///
	/// This is used internally to convert to shader code
	///
	/// Parameters:
	/// 	inParser - {JISON Parser}  Parser to use, assumes in scope "parser" if null
	///
	/// Returns:
	/// 	{AST Object} The function AST Object, note that result is cached under this.jsFunctionAST;
	///
	function getJS_AST( inParser ) {
		if( this.jsFunctionAST ) {
			return this.jsFunctionAST;
		}

		inParser = inParser || parser;
		if( inParser == null ) {
			throw "Missing JS to AST parser";
		}

		var prasedObj = parser.parse( "var "+this.functionName+" = "+this.jsFunctionString+";" );
		if( prasedObj === null ) {
			throw "Failed to parse JS code via JISON";
		}

		// take out the function object, outside the var declarations
		var funcAST = prasedObj.body[0].declarations[0].init;
		this.jsFunctionAST = funcAST;

		return funcAST;
	}
	functionNode.prototype.getJS_AST = getJS_AST;

	///
	/// Function: getWebglString
	///
	/// Returns the converted webgl shader function equivalent of the JS function
	///
	/// Returns:
	/// 	{String} webgl function string, result is cached under this.webglFunctionString
	///
	function getWebglFunctionString(opt) {
		if( this.webglFunctionString ) {
			return this.webglFunctionString;
		}

		return this.webglFunctionString = functionNode_webgl(this, opt);
	}
	functionNode.prototype.getWebglFunctionString = getWebglFunctionString;

	///
	/// Function: setWebglString
	///
	/// Set the webglFunctionString value, overwriting it
	///
	/// Parameters:
	/// 	shaderCode - {String}  Shader code string, representing the function
	///
	function setWebglFunctionString(shaderCode) {
		this.webglFunctionString = shaderCode;
	}
	functionNode.prototype.setWebglFunctionString = setWebglFunctionString;

	return functionNode;
})();