coding UTF-8;        // Specify the character encoding (to prevent garbled text)
import Math;         // Import library for using mathematical functions
import GUI;          // Import library for building GUI windows
import tool.Graph2D; // Import library for 2D graph plotting


// Variables for storing wave parameters
double amplitudeA = 1.0;   // Amplitude (A) of Wave A
double amplitudeB = 1.0;   // Amplitude (A) of Wave B
double wavelengthA = 0.35; // Wavelength (��) of Wave A
double wavelengthB = 0.4;  // Wavelength (��) of Wave B
double periodA = 1.0;      // Period (T) of Wave A
double periodB = 0.5;      // Period (T) of Wave B

// Configuration variables for graph range, number of points, time steps, etc.
const int N = 1024;          // Number of points on the graph (higher for smoother curves)
const double X_MIN = 0.0;    // Minimum value of the X-axis
const double X_MAX = 4.0;    // Maximum value of the X-axis
const double Y_MIN = -2.0;   // Minimum value of the Y-axis
const double Y_MAX = 2.0;    // Maximum value of the Y-axis
const double DT = 0.05;      // Time increment per loop (when speed = 1.0)
const double DX = (X_MAX - X_MIN) / N; // X-axis spacing between points

// Arrays to store coordinate data for passing wave data to the graph
double waveX[ 3 ][ N ];  // X-coordinates (3 series: Wave A, Wave B, Composite Wave �~ number of points)
double waveY[ 3 ][ N ];  // Y-coordinates (3 series: Wave A, Wave B, Composite Wave �~ number of points)

// Variables for the GUI (parameter setting window)
int window;            // Stores the ID of the window
int periodSliderA;     // ID of the period slider for Wave A
int periodSliderB;     // ID of the period slider for Wave B
int wavelengthSliderA; // ID of the wavelength slider for Wave A
int wavelengthSliderB; // ID of the wavelength slider for Wave B
int amplitudeSliderA;  // ID of the amplitude slider for Wave A
int amplitudeSliderB;  // ID of the amplitude slider for Wave B
int speedSlider;       // ID of the animation speed slider
int infoLabelA;        // ID of the label displaying Wave A's parameters
int infoLabelB;        // ID of the label displaying Wave B's parameters
int timeLabel;         // ID of the label displaying the current time
int resetButton;       // ID of the button to reset time

// Other control-related variables
float speed = 0.5;         // Animation speed
int graph;                 // Stores the ID of the graph software instance
bool continuesLoop = true; // Controls whether the animation loop runs or stops
double t;                  // Time variable


// ======================================================================
// Main routine - this function runs automatically on startup
// ======================================================================

void main( ){
	
	// Ask the user whether to input initial wave parameters; input if needed
	inputParameters();
	
	// Launch the graph window
	createGraphWindow();
	
	// Build the GUI (parameter setting window)
	createSettingWindow();
	
	t = 0.0; // Initialize time to zero
	
	// Main animation loop
	while( continuesLoop ) {
		
		// Display the current time in the graph title
		string roundedTime = round(t, 1, HALF_UP);    // Round time to 1 decimal place
		setGraph2DTitle(graph, "t = " + roundedTime); // Set title as "t = [time]"
		
		// Calculate the coordinates of points for graph plotting
		for( int i=0; i<N; i++ ) {
			
			double x = X_MIN + i * DX; // X-coordinate of the i-th point
			
			// Wave A
			waveX[ 0 ][ i ] = x;
			waveY[ 0 ][ i ] = amplitudeA * sin( 2.0 * PI * ( t/periodA - x/wavelengthA ) );
			
			// Wave B
			waveX[ 1 ][ i ] = x;
			waveY[ 1 ][ i ] = amplitudeB * sin( 2.0 * PI * ( t/periodB - x/wavelengthB ) );
			
			// Composite Wave
			waveX[ 2 ][ i ] = x;
			waveY[ 2 ][ i ] = waveY[ 0 ][ i ] + waveY[ 1 ][ i ];
		}
		
		// Send the data to the graph
		setGraph2DData( graph, waveX, waveY );
		
		// Increment time (adjusted by animation speed)
		t += DT * speed;
		
		// Animation wait (sleep 30 ms)
		sleep( 30 );
	}
	
	exit(); // Exit when animation loop ends
}


// ======================================================================
// Function to prompt for initial wave parameters at startup
// ======================================================================

void inputParameters() {
	if ( confirm("Do you want to input wave parameters numerically?") ) {
		
		amplitudeA = input("Amplitude of Wave A=", amplitudeA);
		amplitudeB = input("Amplitude of Wave B=", amplitudeB);
		wavelengthA = input("Wavelength of Wave A=", wavelengthA);
		wavelengthB = input("Wavelength of Wave B=", wavelengthB);
		periodA = input("Period of Wave A=", periodA);
		periodB = input("Period of Wave B=", periodB);
		
	}
}


// ======================================================================
// Function to launch and configure the graph software
// ======================================================================

void createGraphWindow() {

	// Launch the 2D graph software
	graph = newGraph2D( 0, 0, 800, 600, "Graph Window" );
	
	// Disable auto-ranging and manually set the graph range
	setGraph2DAutoRange( graph, false, false );
	setGraph2DRange( graph, X_MIN, X_MAX, Y_MIN, Y_MAX );
	
	// Load configuration file (e.g., line widths, colors, etc.)
	setGraph2DConfigurationFile(graph, "./RinearnGraph2DSetting.ini");
	
	// Set plot options
	setGraph2DOption(graph, "WITH_POINTS", false);
	setGraph2DOption(graph, "WITH_LINES", true);
	
	// Set background color to white
	setGraph2DBackgroundColor( graph, 255, 255, 255, 255 );
	
	// Set axis labels and graph title
	setGraph2DLabel( graph, "x", "Two Sine Waves (Red, Blue) and Composite Wave (Green)" );
}


// ======================================================================
// Function to build the parameter setting window
// ======================================================================

void createSettingWindow() {

	// Create the window
	window = newWindow( 0, 600, 800, 230, "Setting Window" );
	
	// Create and place the label that displays current time
	timeLabel = newTextLabel( 10, 10, 200, 20, "" );
	mountComponent( timeLabel, window );
	
	// Create and place labels to the left of sliders for amplitude, period, and wavelength
	int amplitudeLabel = newTextLabel( 10, 40, 135, 15, "A: Amplitude (0-1)" );
	mountComponent( amplitudeLabel, window );
	int omegaLabel = newTextLabel( 10, 60, 135, 15, "T: Period (0.2-5)" );
	mountComponent( omegaLabel, window );
	int lambdaLabel = newTextLabel( 10, 80, 135, 15, "��: Wavelength (0.1-4)" );
	mountComponent( lambdaLabel, window );
	
	// Create and place sliders for amplitude (range: 0.0-1.0)
	amplitudeSliderA = newHorizontalSlider( 150, 40, 300, 20, amplitudeA, 0.0, 1.0 );
	amplitudeSliderB = newHorizontalSlider( 450, 40, 300, 20, amplitudeB, 0.0, 1.0 );
	mountComponent( amplitudeSliderA, window );
	mountComponent( amplitudeSliderB, window );
	
	// Create and place sliders for period (range: 0.2-5.0)
	periodSliderA = newHorizontalSlider( 150, 60, 300, 20, periodA, 0.2, 5.0 );
	periodSliderB = newHorizontalSlider( 450, 60, 300, 20, periodB, 0.2, 5.0 );
	mountComponent( periodSliderA, window );
	mountComponent( periodSliderB, window );
	
	// Create and place sliders for wavelength (range: 0.1-4.0)
	wavelengthSliderA = newHorizontalSlider( 150, 80, 300, 20, wavelengthA, 0.1, 4.0 );
	wavelengthSliderB = newHorizontalSlider( 450, 80, 300, 20, wavelengthB, 0.1, 4.0 );
	mountComponent( wavelengthSliderA, window );
	mountComponent( wavelengthSliderB, window );
	
	// Create and place labels to display slider values
	infoLabelA = newTextLabel( 155, 100, 300, 20, "" );	
	infoLabelB = newTextLabel( 455, 100, 300, 20, "" );	
	mountComponent( infoLabelA, window );
	mountComponent( infoLabelB, window );
	updateInfoLabel();
	
	// Create and place labels for the columns of Wave A and Wave B
	int columnLabelA = newTextLabel(280, 15, 200, 20, "Wave A");
	int columnLabelB = newTextLabel(580, 15, 200, 20, "Wave B");
	mountComponent( columnLabelA, window );
	mountComponent( columnLabelB, window );
	
	// Create and place label and slider for adjusting animation speed
	int speedLabel = newTextLabel( 10, 140, 140, 15, "Animation Speed" );
	mountComponent( speedLabel, window );
	speedSlider = newHorizontalSlider( 150, 140, 400, 20, speed, 0.0, 1.0 );
	mountComponent( speedSlider, window );
	
	// Create and place the button to reset the time
	resetButton = newButton(600, 125, 150, 40, "Reset Time");
	mountComponent( resetButton, window );
	
	// Refresh the window display after mounting components
	paintComponent( window );
}


// ======================================================================
// Function to update the labels that display slider values
// ======================================================================

void updateInfoLabel() {
	string infoTextA
		= "( A="
		+ round(amplitudeA, 3, HALF_UP) // Round amplitude to 3 decimal places
		+ ", ��="
		+ round(wavelengthA, 3, HALF_UP) // Round wavelength to 3 decimal places
		+ ", T="
		+ round(periodA, 3, HALF_UP) // Round period to 3 decimal places
		+ ")";
	
	string infoTextB
		= "( A="
		+ round(amplitudeB, 3, HALF_UP) // Round amplitude to 3 decimal places
		+ ", ��="
		+ round(wavelengthB, 3, HALF_UP) // Round wavelength to 3 decimal places
		+ ", T="
		+ round(periodB, 3, HALF_UP) // Round period to 3 decimal places
		+ ")";
	
	setComponentString(infoLabelA, infoTextA);
	setComponentString(infoLabelB, infoTextB);
	paintComponent(infoLabelA);
	paintComponent(infoLabelB);
	paintComponent(window);
}


// ======================================================================
// Event handler called when a slider is moved
// ======================================================================

void onSliderMove(int id, float value) {
	
	// Set the value to the corresponding global variable
	
	if(id == amplitudeSliderA) {
		amplitudeA = value;
	}
	
	if(id == amplitudeSliderB) {
		amplitudeB = value;
	}
	
	if(id == periodSliderA) {
		periodA = value;
	}
	
	if(id == periodSliderB) {
		periodB = value;
	}
	
	if(id == wavelengthSliderA) {
		wavelengthA = value;
	}
	
	if(id == wavelengthSliderB) {
		wavelengthB = value;
	}
	
	if (id == speedSlider) {
		speed = value;
	}
	
	updateInfoLabel();
}


// ======================================================================
// Event handler called when a button is clicked
// ======================================================================

void onButtonClick(int id) {
	
	// If the reset button was clicked, reset the time variable
	if (id == resetButton) {
		t = 0.0;
	}
}


// ======================================================================
// Event handler called when a window is closed
// ======================================================================

void onWindowClose(int id) {
	
	// Exit the animation loop to end the program
	continuesLoop = false;
}


// ======================================================================
// Event handler called when the graph window is closed
// ======================================================================

void onGraph2DClose(int id) {
	
	// Exit the animation loop to end the program
	continuesLoop = false;
}