/**

 * WinPR: Windows Portable Runtime

 * Window Notification System

 *

 * Copyright 2014 Marc-Andre Moreau <marcandre.moreau@gmail.com>

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <winpr/crt.h>

#include <winpr/collections.h>

#include <winpr/wnd.h>

#ifndef _WIN32

#include "wnd.h"

/**

 * Custom Functions

 */

static wArrayList* g_WindowClasses = NULL;

static BOOL InitializeWindowClasses(void)

{

	if (g_WindowClasses)

		return TRUE;

	g_WindowClasses = ArrayList_New(TRUE);

	return g_WindowClasses != NULL;

}

static WNDCLASSEXA* CloneWindowClass(CONST WNDCLASSEXA* lpwcx)

{

	WNDCLASSEXA* _lpwcx = NULL;

	_lpwcx = malloc(sizeof(WNDCLASSEXA));

	if (!_lpwcx)

		return NULL;

	CopyMemory(_lpwcx, lpwcx, sizeof(WNDCLASSEXA));

	_lpwcx->lpszClassName = _strdup(lpwcx->lpszClassName);

	_lpwcx->lpszMenuName = _strdup(lpwcx->lpszMenuName);

	if (!_lpwcx->lpszClassName || !_lpwcx->lpszMenuName)

	{

		free((LPSTR)_lpwcx->lpszClassName);

		free((LPSTR)_lpwcx->lpszMenuName);

		free(_lpwcx);

		return NULL;

	}

	return _lpwcx;

}

static WNDCLASSEXA* FindWindowClass(LPCSTR lpClassName)

{

	int index;

	int count;

	BOOL found = FALSE;

	WNDCLASSEXA* lpwcx = NULL;

	ArrayList_Lock(g_WindowClasses);

	count = ArrayList_Count(g_WindowClasses);

	for (index = 0; index < count; index++)

	{

		lpwcx = (WNDCLASSEXA*)ArrayList_GetItem(g_WindowClasses, index);

		if (strcmp(lpClassName, lpwcx->lpszClassName) == 0)

		{

			found = TRUE;

			break;

		}

	}

	ArrayList_Unlock(g_WindowClasses);

	return (found) ? lpwcx : NULL;

}

/**

 * Standard Functions

 */

WORD WINAPI GetWindowWord(HWND hWnd, int nIndex)

{

	return 0;

}

WORD WINAPI SetWindowWord(HWND hWnd, int nIndex, WORD wNewWord)

{

	return 0;

}

LONG WINAPI GetWindowLongA(HWND hWnd, int nIndex)

{

	return 0;

}

LONG WINAPI GetWindowLongW(HWND hWnd, int nIndex)

{

	return 0;

}

LONG WINAPI SetWindowLongA(HWND hWnd, int nIndex, LONG dwNewLong)

{

	return 0;

}

LONG WINAPI SetWindowLongW(HWND hWnd, int nIndex, LONG dwNewLong)

{

	return 0;

}

LONG_PTR WINAPI GetWindowLongPtrA(HWND hWnd, int nIndex)

{

	return 0;

}

LONG_PTR WINAPI GetWindowLongPtrW(HWND hWnd, int nIndex)

{

	return 0;

}

LONG_PTR WINAPI SetWindowLongPtrA(HWND hWnd, int nIndex, LONG_PTR dwNewLong)

{

	return 0;

}

LONG_PTR WINAPI SetWindowLongPtrW(HWND hWnd, int nIndex, LONG_PTR dwNewLong)

{

	return 0;

}

BOOL WINAPI DestroyWindow(HWND hWnd)

{

	WINPR_WND* pWnd;

	pWnd = (WINPR_WND*)hWnd;

	if (!pWnd)

		return FALSE;

	free(pWnd->lpClassName);

	free(pWnd->lpWindowName);

	free(pWnd);

	return TRUE;

}

VOID WINAPI PostQuitMessage(int nExitCode)

{

}

ATOM WINAPI RegisterClassA(CONST WNDCLASSA* lpWndClass)

{

	return 1;

}

ATOM WINAPI RegisterClassW(CONST WNDCLASSW* lpWndClass)

{

	return 1;

}

ATOM WINAPI RegisterClassExA(CONST WNDCLASSEXA* lpwcx)

{

	WNDCLASSEXA* _lpwcx;

	if (!InitializeWindowClasses())

		return 0;

	_lpwcx = CloneWindowClass(lpwcx);

	return ArrayList_Add(g_WindowClasses, (void*)_lpwcx) >= 0;

}

ATOM WINAPI RegisterClassExW(CONST WNDCLASSEXW* lpwcx)

{

	return 1;

}

BOOL WINAPI UnregisterClassA(LPCSTR lpClassName, HINSTANCE hInstance)

{

	return TRUE;

}

BOOL WINAPI UnregisterClassW(LPCWSTR lpClassName, HINSTANCE hInstance)

{

	return TRUE;

}

HWND WINAPI CreateWindowExA(DWORD dwExStyle, LPCSTR lpClassName, LPCSTR lpWindowName, DWORD dwStyle,

                            int X, int Y, int nWidth, int nHeight, HWND hWndParent, HMENU hMenu,

                            HINSTANCE hInstance, LPVOID lpParam)

{

	HWND hWnd;

	WINPR_WND* pWnd;

	WNDCLASSEXA* lpwcx;

	InitializeWindowClasses();

	if (!lpClassName)

		return NULL;

	lpwcx = FindWindowClass(lpClassName);

	if (!lpwcx)

		return NULL;

	pWnd = (WINPR_WND*)calloc(1, sizeof(WINPR_WND));

	if (!pWnd)

		return NULL;

	hWnd = (HWND)pWnd;

	pWnd->X = X;

	pWnd->Y = Y;

	pWnd->nWidth = nWidth;

	pWnd->nHeight = nHeight;

	pWnd->lpClassName = _strdup(lpClassName);

	if (!pWnd->lpClassName)

		goto out_fail;

	if (lpWindowName)

	{

		pWnd->lpWindowName = _strdup(lpWindowName);

		if (!pWnd->lpWindowName)

			goto out_fail;

	}

	pWnd->hWndParent = hWndParent;

	pWnd->hMenu = hMenu;

	pWnd->hInstance = hInstance;

	pWnd->lpParam = lpParam;

	pWnd->lpwcx = lpwcx;

	return hWnd;

out_fail:

	free(pWnd->lpClassName);

	free(pWnd->lpWindowName);

	free(pWnd);

	return NULL;

}

HWND WINAPI CreateWindowExW(DWORD dwExStyle, LPCWSTR lpClassName, LPCWSTR lpWindowName,

                            DWORD dwStyle, int X, int Y, int nWidth, int nHeight, HWND hWndParent,

                            HMENU hMenu, HINSTANCE hInstance, LPVOID lpParam)

{

	return NULL;

}

HWND WINAPI FindWindowA(LPCSTR lpClassName, LPCSTR lpWindowName)

{

	return NULL;

}

HWND WINAPI FindWindowW(LPCWSTR lpClassName, LPCWSTR lpWindowName)

{

	return NULL;

}

HWND WINAPI FindWindowExA(HWND hWndParent, HWND hWndChildAfter, LPCSTR lpszClass, LPCSTR lpszWindow)

{

	return NULL;

}

HWND WINAPI FindWindowExW(HWND hWndParent, HWND hWndChildAfter, LPCWSTR lpszClass,

                          LPCWSTR lpszWindow)

{

	return NULL;

}

BOOL WINAPI GetMessageA(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)

{

	return TRUE;

}

BOOL WINAPI GetMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)

{

	return TRUE;

}

DWORD WINAPI GetMessagePos(VOID)

{

	return 0;

}

LONG WINAPI GetMessageTime(VOID)

{

	return 0;

}

LPARAM WINAPI GetMessageExtraInfo(VOID)

{

	return 0;

}

LPARAM WINAPI SetMessageExtraInfo(LPARAM lParam)

{

	return 0;

}

BOOL WINAPI SetMessageQueue(int cMessagesMax)

{

	return TRUE;

}

LRESULT WINAPI SendMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	LRESULT status;

	WINPR_WND* pWnd;

	WNDPROC lpfnWndProc;

	pWnd = (WINPR_WND*)hWnd;

	if (!pWnd)

		return 0;

	lpfnWndProc = pWnd->lpwcx->lpfnWndProc;

	if (!lpfnWndProc)

		return 0;

	status = lpfnWndProc(hWnd, Msg, wParam, lParam);

	return status;

}

LRESULT WINAPI SendMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	return 0;

}

LRESULT WINAPI SendMessageTimeoutA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags,

                                   UINT uTimeout, PDWORD_PTR lpdwResult)

{

	return 0;

}

LRESULT WINAPI SendMessageTimeoutW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT fuFlags,

                                   UINT uTimeout, PDWORD_PTR lpdwResult)

{

	return 0;

}

BOOL WINAPI SendNotifyMessageA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	return TRUE;

}

BOOL WINAPI SendNotifyMessageW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	return TRUE;

}

BOOL WINAPI SendMessageCallbackA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam,

                                 SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData)

{

	return TRUE;

}

BOOL WINAPI SendMessageCallbackW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam,

                                 SENDASYNCPROC lpResultCallBack, ULONG_PTR dwData)

{

	return TRUE;

}

BOOL WINAPI TranslateMessage(CONST MSG* lpMsg)

{

	return TRUE;

}

LRESULT WINAPI DispatchMessageA(CONST MSG* lpMsg)

{

	return 0;

}

LRESULT WINAPI DispatchMessageW(CONST MSG* lpMsg)

{

	return 0;

}

BOOL WINAPI PeekMessageA(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax,

                         UINT wRemoveMsg)

{

	return TRUE;

}

BOOL WINAPI PeekMessageW(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax,

                         UINT wRemoveMsg)

{

	return TRUE;

}

BOOL WINAPI ReplyMessage(LRESULT lResult)

{

	return TRUE;

}

BOOL WINAPI WaitMessage(VOID)

{

	return TRUE;

}

LRESULT WINAPI CallWindowProcA(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam,

                               LPARAM lParam)

{

	return 0;

}

LRESULT WINAPI CallWindowProcW(WNDPROC lpPrevWndFunc, HWND hWnd, UINT Msg, WPARAM wParam,

                               LPARAM lParam)

{

	return 0;

}

LRESULT WINAPI DefWindowProcA(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	return 0;

}

LRESULT WINAPI DefWindowProcW(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)

{

	return 0;

}

#endif