coding UTF-8;

import Math;
import Text;
import GUI;
import File;
import tool.Graph2D;


/** The default value of the expression y(x) to plot graph */
const string DEFAULT_Y_EXPRESSION = "sin(3*x)";

/** The default value of the maximum value of the x-range of the graph. */
const string DEFAULT_X_MAX = "1.0";

/** The default value of the minimum value of the x-range of the graph. */
const string DEFAULT_X_MIN = "-1.0";

/** The default value of the number of the point of the graph. */
const string DEFAULT_X_N = "100";


// Followings  are variables to store IDs of the graph and GUI components.

/** Stores the ID of the graph. **/
int graph = NULL;

/** Stores the ID of the input-window. **/
int window = NULL;

/** Stores the ID of the text-field of the expression y(x). **/
int expressionField = NULL;

/** Stores the ID of the text-field of the maximum value of x-range. **/
int xMaxField = NULL;

/** Stores the ID of the text-field of the minimum value of x-range. **/
int xMinField = NULL;

/** Stores the ID of the text-field of the number of points of the graph. **/
int xNField = NULL;

/** Stores the ID of the PLOT button. **/
int plotButton = NULL;

/** Stores the ID of the CLEAR button. **/
int clearButton = NULL;

/** Stores the ID of the EXPORT button. **/
int exportButton = NULL;

/** Stores the ID of the EXIT button. **/
int exitButton = NULL;



/**
 * Invoked automatically when this program have started.
 */
void main(){

	// Set the console window invisible because it is not necessary for GUI program.
	hide();

	// Create (or get from the system) a 2D graph window.
	graph = getGraph2D();

	// Set the size and the location of the graph-window.
	setGraph2DLocation(graph, 330, 0);
	setGraph2DSize(graph, 720, 600);

	// Create and launch the input-window.
	createInputWindow();

	// If you want to read processings after when the user click PLOT button, 
	// see "onButtonClick" function at near the bottom of this code.
}


/**
 * Plots the expression to the 2D graph.
 * 
 * @param yExpression   The expression of y(x).
 * @param xMin   The minimum value of x-range.
 * @param xMax   The maximum value of x-range.
 * @param n   The number of points of the graph.
 */
void plotGraph( string yExpression, double xMin, double xMax, int n ){

	// Arrays storing vertices data to transfer the graph.
	double xArray[n];
	double yArray[n];

	// coordinate variables of a point.
	double x;
	double y;

	// Check the syntax of the expression y(x).
	if( !evaluable(yExpression, 0.0) ){
		alert("The form of the expression of \"y(x)\" is wrong.");
		return;
	}

	// Store coordinate values to arrays at n-1 equally divided points of the x-range.
	float dx = (xMax-xMin)/(n-1);
	for( int i=0; i<n; i++ ){
		x = xMin + i * dx;
		
		// Evaluate the value of y(x). (The second argument is an option to get the value of float type)
		y = feval( yExpression, 0.0 );
		
		xArray[ i ] = x;
		yArray[ i ] = y;
	}

	// Transfer arrays to the graph, and plot it.
	addGraph2DData( graph, xArray, yArray );
}


/**
 * Creates GUI components of the input-window and launch it.
 */
void createInputWindow(){

	int leftWidth = 100;
	int rightX = leftWidth + 10;
	int rightWidth = 170;
	int buttonWidth = 270;
	int fontSize = 20;
	
	window = newWindow( 0, 0, 320, 460, "Input Window" );

	int expressionLabel = newTextLabel( 10, 10, leftWidth, 25, "y( x ) =" );
	setComponentFontSize(expressionLabel, fontSize);
	mountComponent( expressionLabel, window );

	expressionField = newTextField( rightX, 10, rightWidth, 25, DEFAULT_Y_EXPRESSION );
	setComponentFontSize(expressionField, fontSize);
	mountComponent( expressionField, window );

	int xMaxLabel = newTextLabel( 10, 60, leftWidth, 25, "x-max =" );
	setComponentFontSize(xMaxLabel, fontSize);
	mountComponent( xMaxLabel, window );

	xMaxField = newTextField( rightX, 60, rightWidth, 25, DEFAULT_X_MAX );
	setComponentFontSize(xMaxField, fontSize);
	mountComponent( xMaxField, window );

	int xMinLabel = newTextLabel( 10, 90, leftWidth, 25, "x-min =" );
	setComponentFontSize(xMinLabel, fontSize);
	mountComponent( xMinLabel, window );

	xMinField = newTextField( rightX, 90, rightWidth, 25, DEFAULT_X_MIN );
	setComponentFontSize(xMinField, fontSize);
	mountComponent( xMinField, window );


	int xNLabel = newTextLabel( 10, 120, leftWidth, 25, "x-N =" );
	setComponentFontSize(xNLabel, fontSize);
	mountComponent( xNLabel, window );

	xNField = newTextField( rightX, 120, rightWidth, 25, DEFAULT_X_N );
	setComponentFontSize(xNField, fontSize);
	mountComponent( xNField, window );


	plotButton = newButton( 10, 160, buttonWidth, 50, "PLOT" );
	setComponentFontSize(plotButton, fontSize);
	mountComponent( plotButton, window );


	clearButton = newButton( 10, 220, buttonWidth, 50, "CLEAR" );
	setComponentFontSize(clearButton, fontSize);
	mountComponent( clearButton, window );

	exportButton = newButton( 10, 280, buttonWidth, 50, "EXPORT" );
	setComponentFontSize(exportButton, fontSize);
	mountComponent( exportButton, window );

	exitButton = newButton( 10, 340, buttonWidth, 50, "EXIT" );
	setComponentFontSize(exitButton, fontSize);
	mountComponent( exitButton, window );
}


/**
 * Exports data of the current graph to a file.
 */
void exportFile(){

	// Choose the file path to export.
	string exportFilePath[] = choose();
	if (length(exportFilePath) == 0) {
		return; // Case of nothing has chosen.
	}

	// If the file path has no extension, append it.
	string name = getFileName( exportFilePath[0] );
	if( indexOf(name,".") < 0 ){
		exportFilePath += ".dat2d";
	}

	// Export to a file.
	exportGraph2DData(graph, exportFilePath[0], "COLUMN_TSV");

	// Show message of completion.
	pop( "SAVED: " + exportFilePath[0] );
}


/**
 * Invoked when buttons are clicked (event handler).
 * 
 * @param id   The ID of the clicked button.
 */
void onButtonClick( int id ){

	// Case of PLOT button is clicked.
	if( id == plotButton ){

		// Get the inputted expression of y(x).
		string yExpression = getComponentText( expressionField );

		// Check syntax of inputted contents of x-max, x-min, x-N.
		if( !evaluable( getComponentText( xMaxField ), 0.0 ) ){
			alert("The form of the expression of x-max is wrong.");
			return;
		}
		if( !evaluable( getComponentText( xMinField ), 0.0 ) ){
			alert("The form of the expression of x-min is wrong.");
			return;
		}
		if( !evaluable( getComponentText( xNField ), 0.0 ) ){
			alert("The form of the expression of x-N is wrong.");
			return;
		}

		// Evaluate values of x-max, x-min, x-N.
		double xMax = feval( getComponentText( xMaxField ), 0.0 );
		double xMin = feval( getComponentText( xMinField ), 0.0 );
		int xN = feval( getComponentText( xNField ), 0.0 );

		// Plot the inputted expression of y(x) to the graph.
		// ( "plotGraph" function is declared at near the top of this program. )
		plotGraph( yExpression, xMin, xMax, xN );
		return;
	}

	// Case of CLEAR button is clicked.
	if( id == clearButton ){
		clearGraph2D(graph);
		return;
	}

	// Case of EXPORT button is clicked.
	if( id == exportButton ){
		exportFile();
		return;
	}

	// Case of EXIT button is clicked.
	if( id == exitButton ){
		exit();
		return;
	}
}


/**
 * Invoked when windows are closed (event handler).
 * 
 * @param id   The ID of the closed window.
 */
void onWindowClose( int id ){
	if( id == window ){
		exit();
		return;
	}
}


/**
 * Invoked when graphs are closed (event handler).
 * 
 * @param id   The ID of the closed graph.
 */
void onGraph2DClose( int id ){
	if( id == graph ){
		exit();
		return;
	}
}