/*

Questions go here:

1. is a reference another word for handle?
2. research TCHAR datatype.
3. Difference between WNDCLASSEX and WNDCLASS?
  WNDCLASSEX is the newer one. There are more differences but for our purposes
  lets assume that the newer one is the "better one". 
*/

//always necessary to include windows.h for making windowed programs


#include <windows.h>
#include "stdafx.h"

#include <SP.h>;

//function prototypes

short int* extractChannelValues(short int* PCM_DATA, long arraySize, int speaker);

short int* calculatePoints(short int* speakerData, long arraySize);

void drawAxis();

void draw(short int* graphPoints, int Resolution, int speaker);

short int modulus(short int value);

ATOM produceAndregisterClass();

int createAndShowWindow();

LRESULT CALLBACK WindowProcedure
  (HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam);

//global variables follow

HINSTANCE hinst; //a reference to the application instance

HWND mainWindow; //this reference will eventually point to the main Window,
   //once instantiated

TCHAR className[] = "myWindow"; //the name of the "class" which we will register

short int* PCM_Data;
long sampleValues = 0;

short int* LEFT_SPEAKER;
short int* LEFT_SPEAKER_GRAPH_POINTS;

/* Main Steps 

1. Define a window "class". Populate a WND Class Ex structure.
2. Register the window class. Pass the WNDCLASSEX struct pointer to RegisterClassEx.
3. Provide a windows procedure. This is the function which will deal with the user's
  interaction with the window.
4. Create and show the window.
5. Put application into a "message loop". 

*/

//entry point into a windowed application is main 

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{

	
	/*load wave file into memory*/
	WAVEDATA drawData = validWAVEFile("x3.wav");

	PCM_Data = drawData.PCM_Data;
	sampleValues = drawData.dataSize;

	/*extract the information for left channel*/
	LEFT_SPEAKER = extractChannelValues(PCM_Data, sampleValues, 0);

	LEFT_SPEAKER_GRAPH_POINTS = calculatePoints(LEFT_SPEAKER, sampleValues/2);
	
	hinst = hInstance;

	if ( produceAndregisterClass() == 0 )
 return -1; //producing and registering class did not work for whatever reason
    //thus we will exit early.

	if ( createAndShowWindow () == 0 )
 return -1; //again, something went wrong so exit early.

	ShowWindow(mainWindow,nCmdShow);
	UpdateWindow(mainWindow);

	//message loop goes here

	BOOL bRet;

	MSG msg;

	while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0)
	{ 
 if (bRet == -1)
 {
    return -1;
 }
 else
 {	
    TranslateMessage(&msg); 
    DispatchMessage(&msg); 
 }
 
	}
	
	return 0;
}

ATOM produceAndregisterClass()
{

	//first let us populate a WNDCLASSEX struct. 
	//this struct contains all the details of windows we will display

	WNDCLASSEX windowClass = { 0 };

	//set the size. when dealing with WNDCLASSEX structures, the RHS of the
	//code is always the same when setting the cbSize member

	windowClass.cbSize = sizeof(WNDCLASSEX); 

	//a style helps determine the window's behavior. these are enumerated
	//at the MSDN website.
	//it is my understanding that using the | operator allows you to specify a combination of styles
	//I've set it to redraw the window whenever the height or width is adjusted.
	
	windowClass.style = CS_HREDRAW | CS_VREDRAW;

	//pointer to the programmer defined window procedure to deal with the user interaction with window

	windowClass.lpfnWndProc = (WNDPROC) WindowProcedure; 

	//number of extra bytes to allocate to structure. i'm saying 0 because this is a simple window,
	//although it remains to be seen exactly how you work how much more you need if the window was
	//"complex".

	windowClass.cbClsExtra = 0;

	windowClass.cbWndExtra = 0;

	//assign the reference to the application instance

	windowClass.hInstance = hinst;

	//assignment of an icon. NULL means system provides default.

	windowClass.hIcon = 0;

	//assignment of cursor. NULL means default.

	windowClass.hCursor = 0;

	//background colour assignment, this can be a handle to a data type called HBRUSH or
	//alternatively it can be a specified colour (if the latter must cast to HBRUSH).
	//always must add 1 to chosen colour.

	windowClass.hbrBackground = (HBRUSH) (COLOR_WINDOW + 1);

	//this should be a string pointing to a resource that specifies a menu. 
	//but a NULL value means no menu, which is what we want for this simple window.

	windowClass.lpszMenuName = 0;

	//assign the class name (which we've stored in a global variable)

	windowClass.lpszClassName = className;

  //i guess this icon member is for the icon your app should have when it is listed
	//in a directory. don't really know but its not that important. we'll just use NULL.

	windowClass.hIconSm = 0; 

	//The structure is filled and now we must register it.

	return RegisterClassEx(&windowClass);
}

//call this function to create and display window only after registering the class.

int createAndShowWindow()
{

	
mainWindow = CreateWindow( className,
            0, 
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT,
            0, 
            CW_USEDEFAULT, 
            0, 
            0, 
            0, 
            hinst, 
            0);
   
/*

mainWindow = CreateWindowEx(
   	WS_EX_APPWINDOW,//window behavior
   	className, 
   	"Test Window", //title bar string
   	WS_CAPTION, //style
   	CW_USEDEFAULT, //x position
   	CW_USEDEFAULT, //y position
   	CW_USEDEFAULT, //width
   	CW_USEDEFAULT, //height
   	0, //handle to parent window, but there is no parent so...?
   	0, //menu handle. null means use the one specified in class
   	hinst, //handle instance
   	0 //lparam value...not really sure what its for
   	);
*/

if ( !mainWindow ) return 0;

return 1;

}

//this function always has this signature and it deals with the user interaction
//messages are passed from the operating system to this function which processes 
//the messages

LRESULT CALLBACK WindowProcedure
  (HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam)

{

//the window will do nothing, except vanish when we ask it to
//if there is a message we have not dealt with in the case statement
//we use the defaultwindowprocedure called DefWindowPoc.

	switch (message)
  {
//	PAINTSTRUCT ps; 
  //HDC hdc; 
 
 case WM_PAINT: 
 	drawAxis();
 	/*get the co-ordinates for the left channel graph sub graph*/
 	draw(LEFT_SPEAKER_GRAPH_POINTS, 1024, 0);
 	return 0;
      /* hdc = BeginPaint(hwnd, &ps); 
      TextOut(hdc, 0, 0, "Hello, Windows!", 15); 
      EndPaint(hwnd, &ps); 
      return 0L;*? 
 	*/
    case WM_DESTROY:
 	delete (LEFT_SPEAKER_GRAPH_POINTS);
 	PostQuitMessage (0);
      return 0;

  }
  return DefWindowProc (hwnd, message, wParam, lParam );

}

void draw(short int* graphPoints, int Resolution, int speaker)
{

	int silentVoltage = 0;

	if (speaker == 0) silentVoltage = 180; else silentVoltage=540;

	int x = 0;

	HDC hdc; 

	hdc = GetDC(mainWindow);

	MoveToEx(hdc, x, silentVoltage, (LPPOINT) NULL);

	int sample = 0;

	while ( x < Resolution )
	{
 sample = graphPoints[x];
 sample=sample/182;
 if (sample > 0) sample = silentVoltage - sample;
 if (sample < 0) sample = modulus(sample) + silentVoltage;
 if (sample == 0) sample = silentVoltage;

 LineTo(hdc, x, sample);

 x++;

	}

	ReleaseDC(mainWindow, hdc);

}
	
void drawAxis()
{
	HDC hdc; 

	hdc = GetDC(mainWindow);
	
	/* POLYbezier function for one curve needs
	1 point for starting point
	2 point for control point
	3 point for control point
	4 point for where we are going to
	
	POINT points[] = { 100,508, 125, 75, 150, 125, 175, 100};
	//MoveToEx(hdc, 500, 500, (LPPOINT) NULL);
	PolyBezier(hdc, points, 4);
	*/
	
	//draw line dividing left speaker and right speaker
	int x = 0;
	int y = 360;

  MoveToEx(hdc, (int) x, (int) y, (LPPOINT) NULL); 
  LineTo(hdc, (int) x + 1023, (int) y); 

	//draw 0 volt line for left speaker
	x = 0;
	y = 180;
	MoveToEx(hdc, x, y, (LPPOINT) NULL);
	LineTo(hdc, (int) x + 1023, (int) y); 

	//draw 0 volt line for right speaker

	x = 0;
	y = 540;
	MoveToEx(hdc, x, y, (LPPOINT) NULL);
  LineTo(hdc, (int) x + 1023, (int) y); 

	//move the pen back to the start of the left speaker

	x=0;
	y=180;
	MoveToEx(hdc, x, y, (LPPOINT) NULL);

	ReleaseDC(mainWindow, hdc);
}

short int* calculatePoints(short int* speakerData, long arraySize)
{

	//how many values to plot along x-axis

	int horizontalResolution = 1024; 

	//declare return value array

	short int* GraphPoints;

	GraphPoints = new short int[horizontalResolution];

	//calculate how many samples each pixel is representative of

	int bufferSize = arraySize / horizontalResolution;

	if ( bufferSize % 2 ) bufferSize++;

	short int* buffer;

	buffer = new short int[bufferSize];

	short int sample = 0; //the value to plot at the i'th iteration

	long i = 0; //the loop counter

	int x = 0; //the pixel for the current iteration

return GraphPoints;

}

short int* extractChannelValues(short int* PCM_DATA, long arraySize, int speaker)
{

	long i = 0;

	long speakerValues = arraySize / 2;

	short int* channelValues;

	channelValues = new short int[speakerValues];

	if ( speaker == 0 ) i=0; else i=1;

	long x=0;

	while ( x < speakerValues )
	{
 channelValues[x]=PCM_Data[i];

 i= i+2;
 x++;
	}

return channelValues;

}

short int modulus(short int value)
{
	if (value < 0) return value*-1;
	else return value;
}

/*global variables*/
short int* PCM_Data; //data from the wavefile, for both speakers
long sampleValues = 0; //number of entries to PCM_Data

short int* LEFT_SPEAKER; //all the values from PCM_Data that are meant for the left speaker
short int* LEFT_SPEAKER_GRAPH_POINTS; //the y-co ordinates for the graph

...

//in the main function

/*load wave file into memory*/
WAVEDATA drawData = validWAVEFile("1000.wav");

PCM_Data = drawData.PCM_Data;
sampleValues = drawData.dataSize;

/*extract the information for left channel*/
LEFT_SPEAKER = extractChannelValues(PCM_Data, sampleValues, 0);

LEFT_SPEAKER_GRAPH_POINTS = calculatePoints(LEFT_SPEAKER, sampleValues/2);

.... //some code to build and insantiate the window

//in the window procedure function

switch (message)
  {
            case WM_PAINT: 
 	drawAxis();
 	/*get the co-ordinates for the left channel graph sub graph*/
 	draw(LEFT_SPEAKER_GRAPH_POINTS, 1024, 0);
 	return 0;
   ....
   }

//now the code for the calculatePoints function
short int* calculatePoints(short int* speakerData, long arraySize)
{

	//how many values to plot along x-axis

	int horizontalResolution = 1024; 

	//declare return value array

	short int* GraphPoints;

	GraphPoints = new short int[horizontalResolution];

	//calculate how many samples each pixel is representative of

	int bufferSize = arraySize / horizontalResolution;

	if ( bufferSize % 2 ) bufferSize++;

	short int* buffer;

	buffer = new short int[bufferSize];

	short int sample = 0; //the value to plot at the i'th iteration

	long i = 0; //current index of the sample array

	int x = 0; //the pixel for the current iteration

	double RMS = 0; //variable for ROOT MEANS SQUARE calculation

	while ( true )
	{	
 
 for (int j=i; j<bufferSize; j++)
 {
 	/*square and sum the values*/
 	RMS+= (speakerData[j+i])*(speakerData[j+i]);
 }
 
 RMS = RMS/bufferSize;

 RMS = sqrt(RMS);
 
        GraphPoints[x]=(short int) RMS;

 i=2;

 x++;

 if (x==1024) break;
	}
}

and finally the draw function

void draw(short int* graphPoints, int Resolution, int speaker)
{

	int silentVoltage = 0;

	if (speaker == 0) silentVoltage = 180; else silentVoltage=540;

	int x = 0;

	HDC hdc; 

	hdc = GetDC(mainWindow);

	MoveToEx(hdc, x, silentVoltage, (LPPOINT) NULL);

	long i=0;
	short int sample = 0;

	while ( x < Resolution )
	{
 sample = graphPoints[x];
 sample=sample/180;
 if (sample > 0) sample = silentVoltage - sample;
 if (sample < 0) sample = modulus(sample) + silentVoltage;
 if (sample == 0) sample = silentVoltage;

 LineTo(hdc, x, (int) sample);

 x++;

 i=i+100;
	}

	ReleaseDC(mainWindow, hdc);

}

void draw(short int* graphPoints, int Resolution, int speaker)
{

	WAVEDATA wave = validWAVEFile("x3.wav"); //load up wave in draw function

	int silentVoltage = 0;

	if (speaker == 0) silentVoltage = 180; else silentVoltage=540;

	int x = 0;

	HDC hdc; 

	hdc = GetDC(mainWindow);

	MoveToEx(hdc, x, silentVoltage, (LPPOINT) NULL);

	long i=0;
	short int sample = 0;

	while ( x < Resolution )
	{
 sample=wave.PCM_Data[i];
 sample=sample/180;
 if (sample > 0) sample = silentVoltage - sample;
 if (sample < 0) sample = modulus(sample) + silentVoltage;
 if (sample == 0) sample = silentVoltage;

 LineTo(hdc, x, (int) sample);

 x++;

 i=i+2;
	}

	ReleaseDC(mainWindow, hdc);

}