package main

import (
	"syscall"
	"unsafe"
)

/*
#cgo LDFLAGS: -lD2d1
#include "main.h"
*/
import "C"

const (
	className = "someClass"
	width     = 500
	height    = 500
)

const sOk       = 0

const (
	WMDestroy = 0x00000002
	WMClose   = 0x00000010
	WMPaint   = 0x0000000f
)

var (
	factory unsafe.Pointer
	target  unsafe.Pointer
)

func main() {

	//
	// Convert class name
	//

	windowClassNameUtf16, err := syscall.UTF16PtrFromString(className)
	if err != nil {
		panic(err.Error())
	}

	//
	// Create window
	//

	var window unsafe.Pointer
	window = unsafe.Pointer(C.CreateWindowCgo(C.LPCWSTR(unsafe.Pointer(windowClassNameUtf16)), C.WNDPROC(unsafe.Pointer(syscall.NewCallback(procudere))), width, height))
	if window == nil {
		panic("Unable create window")
	}

	//
	// Create Direct2D factory
	//

	var tmpFactory unsafe.Pointer // use "tmpFactory" instead of global "factory" because of "cgo argument has Go pointer to Go pointer". Another BUG ???
	errI := C.D2D1CreateFactoryCgo((*unsafe.Pointer)(unsafe.Pointer(&tmpFactory)))
	if errI != sOk {
		panic("Unable create factory")
	}
	factory = tmpFactory

	//
	// Create Direct2D window render target
	//

	var tmpTarget unsafe.Pointer // use "tmpTarget" instead of global "target" because of "cgo argument has Go pointer to Go pointer". Another BUG ???
	errI = C.ID2D1Factory_CreateHwndRenderTargetCgo(
		(*C.ID2D1Factory)(factory),
		C.HWND(window),
		(**C.ID2D1HwndRenderTarget)(unsafe.Pointer(&tmpTarget)),
	)
	if errI != sOk {
		panic("Unable create window render target")
	}
	target = tmpTarget

	//
	// Check for BUG
	//

	if target == nil { // Special check to be 100% sure
		panic("Nil target")
	}

	_ = C.ID2D1HwndRenderTarget_GetSizeCgo((*C.ID2D1HwndRenderTarget)(target))      // Here crash
	_ = C.ID2D1HwndRenderTarget_GetPixelSizeCgo((*C.ID2D1HwndRenderTarget)(target)) // And here crash too
	C.ID2D1HwndRenderTarget_DrawLineCgo((*C.ID2D1HwndRenderTarget)(target))         // But this works

	//
	// Enter main event loop
	//

	C.MainLoop()
}

func procudere(window unsafe.Pointer, msg uint32, wParam uint64, lParam int64) int64 {
	switch msg {
	case WMClose:
		C.ID2D1HwndRenderTarget_ReleaseCgo((*C.ID2D1HwndRenderTarget)(target))
		C.ID2D1Factory_ReleaseCgo((*C.ID2D1Factory)(factory))
		C.DestroyWindow(C.HWND(window))
		return 0
	case WMDestroy:
		C.PostQuitMessage(0)
		return 0
	case WMPaint:
		if target != nil {
			C.ID2D1HwndRenderTarget_DrawLineCgo((*C.ID2D1HwndRenderTarget)(target))
		}
		return 0
	default:
		return int64(C.DefWindowProcW(
			C.HWND(window),
			C.UINT(msg),
			C.WPARAM(wParam),
			C.LPARAM(lParam),
		))
	}
}

#define INITGUID
#include <Windows.h>
#include <D2d1.h>

HWND CreateWindowCgo(LPCWSTR windowClassName, WNDPROC windowProc, int width, int height)
{
    HMODULE hModule;
    if(!GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,NULL,&hModule)){
        return NULL;
    }

    WNDCLASSEXW windowClass;
    windowClass.cbSize=sizeof(WNDCLASSEXW);
    windowClass.style=0;
    windowClass.lpfnWndProc=windowProc;
    windowClass.cbClsExtra=0;
    windowClass.cbWndExtra=0;
    windowClass.hInstance=hModule;
    windowClass.hIcon=NULL;
    windowClass.hCursor=NULL;
    windowClass.hbrBackground=NULL;
    windowClass.lpszMenuName=NULL;
    windowClass.lpszClassName=windowClassName;
    windowClass.hIconSm=NULL;

    ATOM windowClassAtom = RegisterClassExW(&windowClass);
    if (windowClassAtom==0){
        return NULL;
    }

    HWND window = CreateWindowExW(
      0,                                            //    In    DWORD        dwExStyle
      (LPCWSTR)(MAKEINTRESOURCE(windowClassAtom)),  //    In    LPCTSTR      lpClassName
      NULL,                                         //    In    LPCTSTR      lpWindowName
      WS_VISIBLE,                                   //    In    DWORD        dwStyle
      CW_USEDEFAULT,                                //    In    int          x
      CW_USEDEFAULT,                                //    In    int          y
      width,                                        //    In    int          nWidth
      height,                                       //    In    int          nHeight
      NULL,                                         //    In    HWND         hWndParent
      NULL,                                         //    In    HMENU        hMenu
      NULL,                                         //    In    HINSTANCE    hInstance
      NULL                                          //    In    LPVOID       lpParam
    );

    return window;
}

void MainLoop(){
    MSG msg;

    while( TRUE ) {
        switch (GetMessage( &msg, NULL, 0, 0 )){
        case -1:
        case 0:
            return;
        default:
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
}


HRESULT D2D1CreateFactoryCgo(void **ppIFactory){
    D2D1_FACTORY_OPTIONS options;
    options.debugLevel = D2D1_DEBUG_LEVEL_WARNING;

    return D2D1CreateFactory(
        D2D1_FACTORY_TYPE_SINGLE_THREADED,
        &IID_ID2D1Factory,
        &options,
        ppIFactory
    );
}

HRESULT ID2D1Factory_CreateHwndRenderTargetCgo(
    ID2D1Factory *This,
    HWND hwnd,
    ID2D1HwndRenderTarget **hwndRenderTarget
){
    D2D1_RENDER_TARGET_PROPERTIES properties;
    properties.type = D2D1_RENDER_TARGET_TYPE_DEFAULT;
    properties.pixelFormat.format = DXGI_FORMAT_B8G8R8A8_UNORM;
    properties.pixelFormat.alphaMode = D2D1_ALPHA_MODE_PREMULTIPLIED;
    properties.dpiX = 0;
    properties.dpiY = 0;
    properties.usage = D2D1_RENDER_TARGET_USAGE_NONE;
    properties.minLevel = D2D1_FEATURE_LEVEL_DEFAULT;

    RECT rc;
    GetClientRect(hwnd, &rc);

    D2D1_SIZE_U size;
    size.width = rc.right - rc.left;
    size.height = rc.bottom - rc.top;

    D2D1_HWND_RENDER_TARGET_PROPERTIES hwndProperties;
    hwndProperties.hwnd = hwnd;
    hwndProperties.pixelSize = size;
    hwndProperties.presentOptions = D2D1_PRESENT_OPTIONS_NONE;

    return ID2D1Factory_CreateHwndRenderTarget(
        This,
        &properties,
        &hwndProperties,
        hwndRenderTarget
    );
}

D2D1_SIZE_F ID2D1HwndRenderTarget_GetSizeCgo(ID2D1HwndRenderTarget *This){
    return ID2D1HwndRenderTarget_GetSize(This);
}

D2D1_SIZE_U ID2D1HwndRenderTarget_GetPixelSizeCgo(ID2D1HwndRenderTarget *This){
    return ID2D1HwndRenderTarget_GetPixelSize(This);
}

void ID2D1HwndRenderTarget_DrawLineCgo(ID2D1HwndRenderTarget *This){
    ID2D1HwndRenderTarget_BeginDraw(This);

    D2D1_POINT_2F point0;
    point0.x = 0;
    point0.y = 0;
    D2D1_POINT_2F point1;
    point1.x = 200;
    point1.y = 200;

    FLOAT strokeWidth = 1;

    D2D1_COLOR_F color;
    color.r = 1;
    color.a = 0.5;

    D2D1_BRUSH_PROPERTIES properties;
    properties.opacity = 1.0f;
    properties.transform._11 = 1;
    properties.transform._12 = 0;
    properties.transform._21 = 0;
    properties.transform._22 = 1;
    properties.transform._31 = 0;
    properties.transform._32 = 0;

    ID2D1SolidColorBrush *brush;
    ID2D1HwndRenderTarget_CreateSolidColorBrush(This, &color, &properties, &brush);

    ID2D1HwndRenderTarget_DrawLine(This,point0,point1,(ID2D1Brush *)brush,strokeWidth,NULL);

    ID2D1SolidColorBrush_Release(brush);

    ID2D1HwndRenderTarget_EndDraw(This,NULL,NULL);
}

ULONG ID2D1HwndRenderTarget_ReleaseCgo(ID2D1HwndRenderTarget *This){ return ID2D1HwndRenderTarget_Release(This); }

ULONG ID2D1Factory_ReleaseCgo(ID2D1Factory *This){ return ID2D1Factory_Release(This); }