/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef BAGEL_MFC_MINWINDEF_H
#define BAGEL_MFC_MINWINDEF_H

#include "common/scummsys.h"
#include "common/algorithm.h"
#include "common/rect.h"
#define WINVER 0
#include "bagel/mfc/winnt.h"

namespace Bagel {
namespace MFC {

#define ASSERT assert

#undef FAR
#undef  NEAR
#define FAR
#define NEAR
#ifndef CONST
	#define CONST const
#endif

#define CALLBACK
#define WINAPI
#define WINAPIV
#define APIENTRY    WINAPI
#define APIPRIVATE
#define PASCAL
#define AFXAPI
#define AFX_DATA
#define AFX_NOVTABLE
#define BASED_CODE
#define AFX_CDECL

// We're temporary disabling virtual Create functions
// for ScummVM due to the warnings it generates
#define CVIRTUAL

#ifndef _In_
	#define _In_
#endif
#ifndef _Out_
	#define _Out_
#endif
#ifndef _In_z_
	#define _In_z_
#endif
#ifndef _Inout_
	#define _Inout_
#endif

// Dummy try/catch implementation
#define TRY if (1) {
#define END_TRY }
#define CATCH(KLASS, VAL) KLASS *VAL = nullptr; if (0)
#define END_CATCH }

DECLARE_HANDLE(HACCEL);
DECLARE_HANDLE(HCURSOR);
DECLARE_HANDLE(HDROP);
DECLARE_HANDLE(HHOOK);
DECLARE_HANDLE(HICON);
DECLARE_HANDLE(HMENU);
DECLARE_HANDLE(HRAWINPUT);

struct CGdiObjectImpl {
	virtual ~CGdiObjectImpl() {};
};
typedef CGdiObjectImpl *HGDIOBJ;
typedef HGDIOBJ HBITMAP;
typedef HGDIOBJ HBRUSH;
typedef HGDIOBJ HFONT;
typedef HGDIOBJ HPALETTE;
typedef HGDIOBJ HPEN;
typedef HGDIOBJ HRGN;
typedef HGDIOBJ HENHMETAFILE;

typedef void *HDC;
class CWnd;
typedef CWnd *HWND;


/* Types use for passing & returning polymorphic values */
typedef uintptr            WPARAM;
typedef intptr            LPARAM;
typedef intptr            LRESULT;

typedef LRESULT(CALLBACK *HOOKPROC)(int code, WPARAM wParam, LPARAM lParam);
typedef LRESULT(CALLBACK *WNDPROC)(HWND, unsigned int, WPARAM, LPARAM);
typedef intptr(FAR WINAPI *FARPROC)();
typedef intptr(NEAR WINAPI *NEARPROC)();
typedef intptr(WINAPI *PROC)();
typedef intptr(CALLBACK *DLGPROC)(HWND, unsigned int, WPARAM, LPARAM);

#ifndef max
	#define max(a,b)            (((a) > (b)) ? (a) : (b))
#endif

#ifndef min
	#define min(a,b)            (((a) < (b)) ? (a) : (b))
#endif

#define MAKEWORD(a, b)      ((uint16)(((byte)(((uintptr)(a)) & 0xff)) | ((uint16)((byte)(((uintptr)(b)) & 0xff))) << 8))
#define MAKELONG(a, b)      ((long)(((uint16)(((uintptr)(a)) & 0xffff)) | ((uint32)((uint16)(((uintptr)(b)) & 0xffff))) << 16))
#define LOWORD(l)           ((uint16)(((uintptr)(l)) & 0xffff))
#define HIWORD(l)           ((((uintptr)(l)) >> 16))
#define LOBYTE(w)           ((byte)(((uintptr)(w)) & 0xff))
#define HIBYTE(w)           ((byte)((((uintptr)(w)) >> 8) & 0xff))

#define POINTTOPOINTS(pt)      (MAKELONG((short)((pt).x), (short)((pt).y)))
#define MAKEWPARAM(l, h)      ((WPARAM)(uint32)MAKELONG(l, h))
#define MAKELPARAM(l, h)      ((LPARAM)(uint32)MAKELONG(l, h))
#define MAKELRESULT(l, h)     ((LRESULT)(uint32)MAKELONG(l, h))

typedef void *HANDLE;
typedef HANDLE NEAR *SPHANDLE;
typedef HANDLE FAR *LPHANDLE;
typedef HANDLE HGLOBAL;
typedef HANDLE HLOCAL;
typedef HANDLE GLOBALHANDLE;
typedef HANDLE LOCALHANDLE;

#define DECLARE_HANDLE(name) struct name##__{int unused;}; typedef struct name##__ *name

typedef uint16                ATOM;   //BUGBUG - might want to remove this from minwin

DECLARE_HANDLE(HKEY);
typedef HKEY *PHKEY;
DECLARE_HANDLE(HMETAFILE);
DECLARE_HANDLE(HINSTANCE);
typedef HINSTANCE HMODULE;      /* HMODULEs can be used in place of HINSTANCEs */
DECLARE_HANDLE(HRSRC);
DECLARE_HANDLE(HSPRITE);
DECLARE_HANDLE(HLSURF);
DECLARE_HANDLE(HSTR);
DECLARE_HANDLE(HTASK);
DECLARE_HANDLE(HWINSTA);
DECLARE_HANDLE(HKL);

typedef struct tagPOINT {
	int x;
	int y;
} POINT, *PPOINT, NEAR *NPPOINT, FAR *LPPOINT;

typedef struct tagSIZE {
	int cx;
	int cy;
} SIZE, *PSIZE, *LPSIZE;

typedef SIZE SIZEL;
typedef SIZE *PSIZEL, *LPSIZEL;

typedef struct tagPOINTS {
	SHORT x;
	SHORT y;
} POINTS, *PPOINTS, *LPPOINTS;

typedef struct tagRECT {
	int left;
	int top;
	int right;
	int bottom;

	operator Common::Rect() const {
		return Common::Rect(left, top, right, bottom);
	}
	bool contains(int x, int y) const {
		Common::Rect r = *this;
		return r.contains(x, y);
	}
	bool contains(const POINT &pt) const {
		Common::Rect r = *this;
		return r.contains(pt.x, pt.y);
	}
} RECT, *PRECT, NEAR *NPRECT, FAR *LPRECT;
typedef const RECT FAR *LPCRECT;

inline Common::Rect RECTtoRect(const RECT &src) {
	return src;
}
inline RECT RectToRECT(const Common::Rect &src) {
	RECT dest;
	dest.left = src.left;
	dest.top = src.top;
	dest.right = src.right;
	dest.bottom = src.bottom;
	return dest;
}
inline RECT RectToRECT(int x1, int y1, int x2, int y2) {
	RECT dest;
	dest.left = x1;
	dest.top = y1;
	dest.right = x2;
	dest.bottom = y2;
	return dest;
}

inline bool RectsIntersect(const RECT &r1, const RECT &r2) {
	return RECTtoRect(r1).intersects(RECTtoRect(r2));
}

typedef struct _FILETIME {
	uint32 dwLowDateTime;
	uint32 dwHighDateTime;
} FILETIME, *PFILETIME, *LPFILETIME;

typedef struct _SYSTEMTIME {
	uint16 wYear;
	uint16 wMonth;
	uint16 wDayOfWeek;
	uint16 wDay;
	uint16 wHour;
	uint16 wMinute;
	uint16 wSecond;
	uint16 wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;

typedef struct tagPAINTSTRUCT {
	HDC         hdc;
	bool        fErase;
	RECT        rcPaint;
	bool        fRestore;
	bool        fIncUpdate;
	byte        rgbReserved[32];
} PAINTSTRUCT, *PPAINTSTRUCT, *NPPAINTSTRUCT, *LPPAINTSTRUCT;

/*
 * Message structure
 */
typedef struct tagMSG {
	HWND        hwnd = 0;
	unsigned int        message = 0;
	WPARAM      wParam = 0;
	LPARAM      lParam = 0;
	uint32       time = 0;
	POINT       pt;

	// Extra fields for TranslateMessage convenience
	byte        _kbdFlags = 0;
	char        _ascii = 0;

	tagMSG() {
		pt.x = pt.y = 0;
	}
	tagMSG(HWND hwnd_, unsigned int message_, WPARAM wParam_ = 0,
	       LPARAM lParam_ = 0) :
			hwnd(hwnd_), message(message_), wParam(wParam_),
			lParam(lParam_) {
		pt.x = pt.y = 0;
	}
} MSG, *PMSG, NEAR *NPMSG, FAR *LPMSG;

inline bool PtInRect(const RECT *lprc, const POINT &pt) {
	return pt.x >= lprc->left && pt.x < lprc->right &&
	       pt.y >= lprc->top && pt.y < lprc->bottom;
}

typedef struct tagWNDCLASS {
	unsigned int        style;
	WNDPROC     lpfnWndProc;
	int         cbClsExtra;
	int         cbWndExtra;
	HINSTANCE   hInstance;
	HICON       hIcon;
	HCURSOR     hCursor;
	HBRUSH      hbrBackground;
	const char *     lpszMenuName;
	const char *     lpszClassName;
} WNDCLASS, *PWNDCLASS, *NPWNDCLASS, *LPWNDCLASS;

struct CDataExchange {
	bool m_bSaveAndValidate;
};

} // namespace MFC
} // namespace Bagel

#endif