// SoundGraphAccess.cpp : Defines the entry point for the application.

//

#include "stdafx.h"

#include "SoundGraphAccess.h"

#include "iMONDisplayAPI.h"

#include <stdio.h>

#define WM_DSP_PLUGIN_NOTIFY			WM_APP + 1100

#define WM_IMON_INIT					WM_APP + 1101

#define WM_IMON_UNINIT					WM_APP + 1102

#define WM_IMON_IS_INIT					WM_APP + 1103

#define WM_IMON_IS_PLUGIN_MODE_ENABLED	WM_APP + 1104

//

#define MAX_LOADSTRING 100

// Global Variables:

HINSTANCE hInst = 0;								// current instance

TCHAR szTitle[MAX_LOADSTRING];					// The title bar text

TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name

HANDLE gThreadReceiver = INVALID_HANDLE_VALUE;

//HANDLE gThreadSender = INVALID_HANDLE_VALUE;

BOOL gQuit=FALSE;

LPTSTR gPipeNameSender = TEXT("\\\\.\\pipe\\sga-sender"); 

LPTSTR gPipeNameReceiver = TEXT("\\\\.\\pipe\\sga-receiver"); 

HANDLE gPipeSender=INVALID_HANDLE_VALUE;

HANDLE gPipeReceiver=INVALID_HANDLE_VALUE;

char gBufferReceiver[256];

char gBufferSender[256];

//

HWND gWnd;

//

BOOL m_bVfdConnected;

BOOL m_bLcdConnected;

// Forward declarations of functions included in this code module:

ATOM				MyRegisterClass(HINSTANCE hInstance);

BOOL				InitInstance(HINSTANCE, int);

LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);

INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

//Supported responses

const char KRspDone[]="done:";

const char KRspPending[]="pending:";

const char KRspError[]="error:";

const char KRspClose[]="close:";

const char KRspOpen[]="open:";

const char KRspUnknown[]="unknown:";

const char KRspTrue[]="true:";

const char KRspFalse[]="false:";

//Supported incoming messages

const char KMsgInit[]="init:";

const char KMsgUninit[]="uninit:";

const char KMsgIsInit[]="is-init:";

const char KMsgIsPluginModeEnabled[]="is-plugin-mode-enabled:";

/**

Send a message to our server.

*/

void SendMessageToServer(const char* aResponse)

	{

	DWORD cbWritten=0;

	char msg[512];

	sprintf(msg,"%s\n",aResponse);

	OutputDebugStringA(msg);

	WriteFile(gPipeSender, aResponse, strlen(aResponse), &cbWritten, NULL);		

	}

/**

Handle messages from our server.

*/

void MessageReceived(const char* aMsg)

	{

	//

	if (strcmp(aMsg,KMsgInit)==0)

		{

		//IMON API call need to be done from window thread for some reason

		SendMessageToServer(KRspPending);

		PostMessage(gWnd,WM_IMON_INIT,0,0);

		}

	else if (strcmp(aMsg,KMsgUninit)==0)

		{

		//IMON API call need to be done from window thread for some reason

		SendMessageToServer(KRspPending);

		PostMessage(gWnd,WM_IMON_UNINIT,0,0);		

		}

	else if (strcmp(aMsg,KMsgIsPluginModeEnabled)==0)

		{

		//IMON API call need to be done from window thread for some reason

		SendMessageToServer(KRspPending);

		PostMessage(gWnd,WM_IMON_IS_PLUGIN_MODE_ENABLED,0,0);		

		}

	else if (strcmp(aMsg,KMsgIsInit)==0)

		{

		//IMON API call need to be done from window thread for some reason

		SendMessageToServer(KRspPending);

		PostMessage(gWnd,WM_IMON_IS_INIT,0,0);		

		}

	else

		{		

		SendMessageToServer(KRspUnknown);

		}

	}

/**

Connect our named pipes from here.

First connect our read pipe then our write pipe.

Then notify our server we are connected.

Then keep on waiting for incoming messages.

*/

DWORD WINAPI ThreadReceiver( LPVOID lpParam )

	{

	//Keep on trying to connect on our read pipe

	while (gPipeReceiver==INVALID_HANDLE_VALUE && !gQuit)

		{

		OutputDebugStringA("Trying to connect...\n");

		gPipeReceiver=CreateFile(gPipeNameReceiver,	GENERIC_READ ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

		Sleep(1000);

		}

	OutputDebugStringA("Read pipe open!\n");

	//Now try connecting on our write pipe

	gPipeSender=CreateFile(gPipeNameSender,	GENERIC_WRITE ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

	if (gPipeSender==INVALID_HANDLE_VALUE)

		{

		OutputDebugStringA("ERROR: Write pipe failure!\n");

		gQuit=TRUE;

		}

	else

		{

		OutputDebugStringA("Write pipe opened.\n");

		OutputDebugStringA("Connected.\n");

		SendMessageToServer(KRspOpen);

		}

	//

	while(!gQuit)

		{

		DWORD cbRead;

		BOOL success=ReadFile(gPipeReceiver,gBufferReceiver,sizeof(gBufferReceiver),&cbRead, NULL); 

		if(success)

			{

			gBufferReceiver[cbRead]='\0';

			OutputDebugStringA(gBufferReceiver);

			MessageReceived(gBufferReceiver);

			}

		//if (!success && GetLastError() != ERROR_MORE_DATA) 

		//	{

		//	OutputDebugStringA("Can't Read\n");

		//	}

		//

		//Sleep(500);

		if (!success)

			{

			gQuit=TRUE;

			}

		}

	//Try tell our server

	SendMessageToServer(KRspClose);

	//Close our pipes

	CloseHandle(gPipeReceiver);	

	gPipeReceiver=INVALID_HANDLE_VALUE;

	CloseHandle(gPipeSender);	

	gPipeSender=INVALID_HANDLE_VALUE;

	//Quit our application

	PostMessage(gWnd,WM_CLOSE,0,0);

	return 0;

	}

/**

*/

int APIENTRY _tWinMain(HINSTANCE hInstance,

                     HINSTANCE hPrevInstance,

                     LPTSTR    lpCmdLine,

                     int       nCmdShow)

{

	UNREFERENCED_PARAMETER(hPrevInstance);

	UNREFERENCED_PARAMETER(lpCmdLine);

	// TODO: Place code here.

	MSG msg;

	HACCEL hAccelTable;

	// Initialize global strings

	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

	LoadString(hInstance, IDC_SOUNDGRAPHACCESS, szWindowClass, MAX_LOADSTRING);

	MyRegisterClass(hInstance);

	// Perform application initialization:

	if (!InitInstance (hInstance, /*SW_HIDE*/ nCmdShow))

		{

		return FALSE;

		}

	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SOUNDGRAPHACCESS));

	// Main message loop:

	while (GetMessage(&msg, NULL, 0, 0))

		{

		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

			{

			TranslateMessage(&msg);

			DispatchMessage(&msg);

			}

		}

	return (int) msg.wParam;

	}

/**

*/

void DisplayPluginMessage(UINT uErrCode, BOOL bError)

	{

	char* strErrMsg = "";

	if(bError)

		{

		switch(uErrCode)

			{

			case DSPN_ERR_IN_USED:			strErrMsg = ("Display Plug-in is Already Used by Other Application.");		break;

			case DSPN_ERR_HW_DISCONNECTED:	strErrMsg = ("iMON HW is Not Connected.");									break;

			case DSPN_ERR_NOT_SUPPORTED_HW:	strErrMsg = ("The Connected iMON HW doesn't Support Display Plug-in.");		break;

			case DSPN_ERR_PLUGIN_DISABLED:	strErrMsg = ("Display Plug-in Mode Option is Disabled.");					break;

			case DSPN_ERR_IMON_NO_REPLY:	strErrMsg = ("The Latest iMON is Not Installed or iMON Not Running.");		break;

			case DSPN_ERR_UNKNOWN:			strErrMsg = ("Unknown Failure.");											break;

			}

		}

	else

		{

		switch(uErrCode)

			{

			case DSPNM_PLUGIN_SUCCEED:		strErrMsg = ("Plug-in Mode Inited Successfully.");			break;

			case DSPNM_IMON_RESTARTED:		strErrMsg = ("iMON Started and Plug-in Mode Inited.");		break;

			case DSPNM_HW_CONNECTED:		strErrMsg = ("iMON HW Connected and Plug-in Mode Inited.");	break;

			}

		}

	//

	OutputDebugStringA(strErrMsg);

	char msg[256];

	if (bError)

		{

		sprintf(msg,"error:%s",strErrMsg);

		}

	else

		{

		sprintf(msg,"done:%s",strErrMsg);	

		}	

	SendMessageToServer(msg);

	}

//

//  FUNCTION: MyRegisterClass()

//

//  PURPOSE: Registers the window class.

//

//  COMMENTS:

//

//    This function and its usage are only necessary if you want this code

//    to be compatible with Win32 systems prior to the 'RegisterClassEx'

//    function that was added to Windows 95. It is important to call this function

//    so that the application will get 'well formed' small icons associated

//    with it.

//

ATOM MyRegisterClass(HINSTANCE hInstance)

{

	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;

	wcex.lpfnWndProc	= WndProc;

	wcex.cbClsExtra		= 0;

	wcex.cbWndExtra		= 0;

	wcex.hInstance		= hInstance;

	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SOUNDGRAPHACCESS));

	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);

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

	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_SOUNDGRAPHACCESS);

	wcex.lpszClassName	= szWindowClass;

	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassEx(&wcex);

}

//

//   FUNCTION: InitInstance(HINSTANCE, int)

//

//   PURPOSE: Saves instance handle and creates main window

//

//   COMMENTS:

//

//        In this function, we save the instance handle in a global variable and

//        create and display the main program window.

//

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

{

   hInst = hInstance; // Store instance handle in our global variable

   gWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,

      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!gWnd)

   {

      return FALSE;

   }

   ShowWindow(gWnd, nCmdShow);

   UpdateWindow(gWnd);

   return TRUE;

}

//

//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

//

//  PURPOSE:  Processes messages for the main window.

//

//  WM_COMMAND	- process the application menu

//  WM_PAINT	- Paint the main window

//  WM_DESTROY	- post a quit message and return

//

//

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

{

	int wmId, wmEvent;

	PAINTSTRUCT ps;

	HDC hdc;

	switch (message)

	{

	case WM_CREATE:

		//IMON_Display_Uninit();

		//IMON_Display_Init(hWnd, WM_DSP_PLUGIN_NOTIFY);

		gThreadReceiver = CreateThread( NULL, 0, ThreadReceiver, NULL/*data pointer*/, 0, NULL);

		break;

	case WM_COMMAND:

		wmId    = LOWORD(wParam);

		wmEvent = HIWORD(wParam);

		// Parse the menu selections:

		switch (wmId)

		{

		case IDM_ABOUT:

			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);

			break;

		case IDM_EXIT:

			DestroyWindow(hWnd);

			break;

		default:

			return DefWindowProc(hWnd, message, wParam, lParam);

		}

		break;

	case WM_PAINT:

		hdc = BeginPaint(hWnd, &ps);

		// TODO: Add any drawing code here...

		EndPaint(hWnd, &ps);

		break;

	case WM_DESTROY:

		gQuit=TRUE;

		//To complete write op

		if (gPipeSender!=INVALID_HANDLE_VALUE)

			{

			CloseHandle(gPipeSender);

			gPipeSender=INVALID_HANDLE_VALUE;

			}

		//To complete read op

		if (gPipeReceiver!=INVALID_HANDLE_VALUE)

			{

			CloseHandle(gPipeReceiver);

			gPipeReceiver=INVALID_HANDLE_VALUE;

			}

		WaitForSingleObject(gThreadReceiver,INFINITE);

		CloseHandle(gThreadReceiver);

		//IMON_Display_Uninit();

		PostQuitMessage(0);

		break;

	case WM_IMON_UNINIT:

		IMON_Display_Uninit();

		SendMessageToServer(KRspDone);

		break;

	case WM_IMON_INIT:

		IMON_Display_Uninit();

		IMON_Display_Init(hWnd, WM_DSP_PLUGIN_NOTIFY);

		break;

	//

	case WM_IMON_IS_PLUGIN_MODE_ENABLED:

		if (IMON_Display_IsPluginModeEnabled()==DSP_S_IN_PLUGIN_MODE)

			{

			SendMessageToServer(KRspTrue);

			}

		else

			{

			SendMessageToServer(KRspFalse);

			}

		break;

	//

	case WM_IMON_IS_INIT:

		if (IMON_Display_IsInited()==DSP_S_INITED)

			{

			SendMessageToServer(KRspTrue);

			}

		else

			{

			SendMessageToServer(KRspFalse);

			}

		break;

	case WM_DSP_PLUGIN_NOTIFY:

		switch(wParam)

			{

			case DSPNM_PLUGIN_SUCCEED:

			case DSPNM_IMON_RESTARTED:

			case DSPNM_HW_CONNECTED:

				{

				//GetDlgItem(IDC_BUTTON1)->EnableWindow(TRUE);

				m_bVfdConnected = FALSE;

				m_bLcdConnected = FALSE;

				if((lParam & DSPN_DSP_VFD) == DSPN_DSP_VFD)		m_bVfdConnected = TRUE;

				if((lParam & DSPN_DSP_LCD) == DSPN_DSP_LCD)		m_bLcdConnected = TRUE;

				//UpdateControlUI();

				DisplayPluginMessage(wParam, FALSE);

				}

				break;

			case DSPNM_PLUGIN_FAILED:

			case DSPNM_HW_DISCONNECTED:

			case DSPNM_IMON_CLOSED:

				{

				//GetDlgItem(IDC_BUTTON1)->EnableWindow(TRUE);

				m_bVfdConnected = FALSE;

				m_bLcdConnected = FALSE;

				//UpdateControlUI();

				DisplayPluginMessage(lParam, TRUE);

				}

				break;

			case DSPNM_LCD_TEXT_SCROLL_DONE:

				{

				//TRACE(_T("LCD Text Scroll Finished.\n"));

				}

				break;

			}

		return 0;

		break;

	default:

		return DefWindowProc(hWnd, message, wParam, lParam);

	}

	return 0;

}

// Message handler for about box.

INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

{

	UNREFERENCED_PARAMETER(lParam);

	switch (message)

	{

	case WM_INITDIALOG:

		return (INT_PTR)TRUE;

	case WM_COMMAND:

		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)

		{

			EndDialog(hDlg, LOWORD(wParam));

			return (INT_PTR)TRUE;

		}

		break;

	}

	return (INT_PTR)FALSE;

}