// odbctest.cpp : Definiert den Einstiegspunkt für die Anwendung.
//

#include "stdafx.h"
#include "odbctest.h"

#define MAX_LOADSTRING 100

#if (defined(_WIN64)) 
	#define XGWL_WNDPROC GWLP_WNDPROC
#else
	#define XGWL_WNDPROC GWL_WNDPROC
#endif

#define ErrorBox(hwnd, pchCaption, pchMessage) \
        MessageBox (hwnd, pchMessage, pchCaption, MB_ICONSTOP | MB_OK);
        
#define InfoBox(hwnd, pchCaption, pchMessage) \
        MessageBox (hwnd, pchMessage, pchCaption, MB_ICONINFORMATION | MB_OK);

// Globale Variablen:
HINSTANCE hInst;								// Aktuelle Instanz
char szTitle[MAX_LOADSTRING];					// Titelleistentext
char szWindowClass[MAX_LOADSTRING];			// Klassenname des Hauptfensters

HENV			henv;				// Datenbankvariablen
HDBC			hdbc;          
char			name[256], 
				vorname[256];

// Vorwärtsdeklarationen der in diesem Codemodul enthaltenen Funktionen:
ATOM				MyRegisterClass(HINSTANCE hInstance);
BOOL				InitInstance(HINSTANCE, int);
LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);


int APIENTRY WinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPTSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: Hier Code einfügen.
	MSG msg;
	HACCEL hAccelTable;

	// Globale Zeichenfolgen initialisieren
	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
	LoadString(hInstance, IDC_ODBCTEST, szWindowClass, MAX_LOADSTRING);
	MyRegisterClass(hInstance);

	// Anwendungsinitialisierung ausführen:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

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

	// Hauptnachrichtenschleife:
	while (GetMessage(&msg, NULL, 0, 0))
	{
		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	return (int) msg.wParam;
}



//
//  FUNKTION: MyRegisterClass()
//
//  ZWECK: Registriert die Fensterklasse.
//
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_ODBCTEST));
	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_ODBCTEST);
	wcex.lpszClassName	= szWindowClass;
	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

	return RegisterClassEx(&wcex);
}

//
//   FUNKTION: InitInstance(HINSTANCE, int)
//
//   ZWECK: Speichert das Instanzenhandle und erstellt das Hauptfenster.
//
//   KOMMENTARE:
//
//        In dieser Funktion wird das Instanzenhandle in einer globalen Variablen gespeichert, und das
//        Hauptprogrammfenster wird erstellt und angezeigt.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;

   hInst = hInstance; // Instanzenhandle in der globalen Variablen speichern

   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

   if (!hWnd)
   {
      return FALSE;
   }

   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);

   return TRUE;
}

//
//  FUNKTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  ZWECK:  Verarbeitet Meldungen vom Hauptfenster.
//
//  WM_COMMAND	- Verarbeiten des Anwendungsmenüs
//  WM_PAINT	- Zeichnen des Hauptfensters
//  WM_DESTROY	- Beenden-Meldung anzeigen und zurückgeben
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	PAINTSTRUCT ps;
	HDC hdc;
	LONG				rc;					// ODBC Returncode
    HSTMT				hstmt;

#if (defined(_WIN64)) 
    SQLLEN				cbCount;
#else
    SDWORD				cbCount;
#endif

    char				achSQLString[1000];
	char				achDBName[SQL_MAX_DSN_LENGTH];
    char				text[1000];
	BOOL				fOK;
	int					iCount = 0, y=10;

	switch (message)
	{
	case WM_CREATE:
		PostMessage (hWnd, WM_USER, 0, 0L);
		break;

	case WM_USER:
		rc = SQLAllocEnv(&henv);				// Allocate environment handle 
		rc = SQLAllocConnect(henv, &hdbc);		// Allocate connection handle  
		strcpy_s (achDBName, sizeof(achDBName), "stodb");
		rc = SQLConnect(hdbc, (SQLCHAR *)achDBName, (SWORD)strlen(achDBName), (SQLCHAR *)"test", (SWORD)4, (SQLCHAR *)"test", (SWORD)4);

		if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO)
		{
			ErrorBox (hWnd, "ERROR", "CONNECTION TO DB FAILED");
			PostQuitMessage (-1);
			break;
		}

		rc = SQLAllocStmt(hdbc, &hstmt);

		sprintf_s (achSQLString, sizeof(achSQLString), "select lastname, firstname from support where status=1 and (lastname like '%%mö%%' or firstname like '%%mö%%') order by lastname");

		rc = SQLExecDirect(hstmt, (SQLCHAR *)achSQLString, (SQLINTEGER)strlen(achSQLString));

		hdc = GetDC (hWnd);

		if (rc == SQL_SUCCESS)
		{
			fOK=TRUE;

			SQLBindCol(hstmt, 1, SQL_C_CHAR, name,        sizeof(name),       &cbCount);
			SQLBindCol(hstmt, 2, SQL_C_CHAR, vorname,     sizeof(vorname),    &cbCount);

			TextOut (hdc, 10, y, achSQLString, (int)strlen(achSQLString));
			y+=40;
			
			while (fOK)
			{
				memset (name,       '\0', sizeof (name));
				memset (vorname,    '\0', sizeof (vorname));
	
				rc = SQLFetch (hstmt);  

				switch (rc)
				{
					case SQL_SUCCESS:
						sprintf_s (text, sizeof(text), "%s %s", name, vorname);
						TextOut (hdc, 10, y, text, (int)strlen(text));
						y+=20; iCount++;
						break;

					case SQL_NO_DATA:
						fOK=FALSE;
						break;

					case SQL_ERROR:
						TextOut (hdc, 10, y, "SQLFetch FROM TABLE support FAILED", 34);
						y+=20;
						fOK = FALSE;
						break;

					default:
						fOK = FALSE;
						break;
				}
			}
			y+=20;
			sprintf_s (text, sizeof(text), "Records found: %i", iCount);
			TextOut (hdc, 10, y, text, (int)strlen(text));
		}
		else
		{
			TextOut (hdc, 10, y, "CAN'T READ DATA FROM TABLE support.", 35);
		}
		UpdateWindow (hWnd);

		SQLFreeStmt(hstmt, SQL_DROP);    
		SQLDisconnect  (hdbc);
		SQLFreeConnect(hdbc);
		SQLFreeEnv(henv);
		break;

	case WM_COMMAND:
		wmId    = LOWORD(wParam);
		wmEvent = HIWORD(wParam);
		// Menüauswahl bearbeiten:
		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: Hier den Zeichnungscode hinzufügen.
		EndPaint(hWnd, &ps);
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}

// Meldungshandler für Infofeld.
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;
}