#include "Unix/WindowImplUnix.h"
#include "Window.h"

#include "Core/Util.h"
#include "Core/Logger.h"

#include <X11/Xutil.h>
#include <X11/Xos.h>
#include <X11/Xatom.h>
#include <X11/XKBlib.h>
#include <X11/keysym.h>

#include <iostream>
#include <string_view>
#include <thread>

namespace sh::window {
	WindowImplUnix::~WindowImplUnix()
	{
		Close();
	}

	auto WindowImplUnix::Create(const std::string& title, int wsize, int hsize, uint32_t style) -> WinHandle
	{
		SH_INFO("Create Window");

		XInitThreads();

		//디스플레이 서버에 접속한다.
		display = XOpenDisplay(NULL);
		screen = DefaultScreen(display);

		setlocale(LC_ALL, "");
		XSetLocaleModifiers("");

		XSetWindowAttributes attrs;
		attrs.background_pixel = WhitePixel(display, screen);
		attrs.event_mask = FocusChangeMask | ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | PointerMotionMask | KeyPressMask | KeyReleaseMask | StructureNotifyMask | EnterWindowMask | LeaveWindowMask;

		root = XDefaultRootWindow(display);
		win = XCreateWindow(display, root, 0, 0, wsize, hsize, 1,
			CopyFromParent, InputOutput, CopyFromParent,
			CWBackPixel | CWEventMask, &attrs);

		xim = XOpenIM(display, nullptr, nullptr, nullptr);
		if (xim)
		{
			xic = XCreateIC(
				xim,
				XNInputStyle, XIMPreeditNothing | XIMStatusNothing,
				XNClientWindow, win,
				XNFocusWindow, win,
				nullptr
			);
		}

		widthPrevious = wsize;
		heightPrevious = hsize;

		//창 제목 설정
		Atom netWmName = XInternAtom(display, "_NET_WM_NAME", false);
		Atom utf8String = XInternAtom(display, "UTF8_STRING", false);
		XChangeProperty(display, win, netWmName, utf8String, 8, PropModeReplace,
			(const unsigned char*)title.c_str(), title.size());
		
		//event_mask에 해당하는 이벤트를 선택
		XSelectInput(display, win, attrs.event_mask); 

		//창 닫는 이벤트 등록
		wmDeleteMessage = XInternAtom(display, "WM_DELETE_WINDOW", false); 
		XSetWMProtocols(display, win, &wmDeleteMessage, 1);

		//////////////////////////////////창 스타일////////////////////////////////////
		Atom windowHints = XInternAtom(display, "_MOTIF_WM_HINTS", false);

		struct MwmHints {
			unsigned long flags;
			unsigned long functions;
			unsigned long decorations;
			long inputMode;
			unsigned long status;
		};

		static const unsigned long MWM_HINTS_FUNCTIONS = 1 << 0;
		static const unsigned long MWM_HINTS_DECORATIONS = 1 << 1;

		static const unsigned long MWM_DECOR_BORDER = 1 << 1;
		static const unsigned long MWM_DECOR_RESIZEH = 1 << 2;
		static const unsigned long MWM_DECOR_TITLE = 1 << 3;
		static const unsigned long MWM_DECOR_MENU = 1 << 4;
		static const unsigned long MWM_DECOR_MINIMIZE = 1 << 5;
		static const unsigned long MWM_DECOR_MAXIMIZE = 1 << 6;

		static const unsigned long MWM_FUNC_RESIZE = 1 << 1;
		static const unsigned long MWM_FUNC_MOVE = 1 << 2;
		static const unsigned long MWM_FUNC_MINIMIZE = 1 << 3;
		static const unsigned long MWM_FUNC_MAXIMIZE = 1 << 4;
		static const unsigned long MWM_FUNC_CLOSE = 1 << 5;

		struct MwmHints hints;
		hints.flags = MWM_HINTS_FUNCTIONS | MWM_HINTS_DECORATIONS;
		hints.decorations = MWM_DECOR_BORDER | MWM_DECOR_TITLE | MWM_DECOR_MINIMIZE | MWM_DECOR_MENU;
		hints.functions = MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE | MWM_FUNC_CLOSE;
		if (style & Window::Style::Resize)
		{
			hints.decorations |= MWM_DECOR_MAXIMIZE | MWM_DECOR_RESIZEH;
			hints.functions |= MWM_FUNC_MAXIMIZE | MWM_FUNC_RESIZE;
		}

		XChangeProperty(display, win, windowHints, windowHints, 32,
			PropModeReplace, (unsigned char*)&hints, 5);

		if (!(style & Window::Style::Resize))
		{
			XSizeHints sizeHints{};
			sizeHints.flags = PMinSize | PMaxSize | USPosition;
			sizeHints.min_width = sizeHints.max_width = static_cast<int>(wsize);
			sizeHints.min_height = sizeHints.max_height = static_cast<int>(hsize);
			sizeHints.x = 0;
			sizeHints.y = 0;
			XSetWMNormalHints(display, win, &sizeHints);
		}
		/////////////////////////////////////////////////////////////////////////////////

		XMapWindow(display, win);
		XFlush(display);

		return std::make_pair(display, win);
	}

	void WindowImplUnix::Close()
	{
		if (xic) { XDestroyIC(xic); xic = nullptr; }
		if (xim) { XCloseIM(xim); xim = nullptr; }

		if (display && win) XDestroyWindow(display, win);
		if (display) XCloseDisplay(display);

		win = 0;
		display = nullptr;
	}

	//현재 윈도우에서 발생한 이벤트인가?
	auto WindowImplUnix::CheckEvent(Display*, XEvent* evt, XPointer userData) -> int {
		return evt->xany.window == reinterpret_cast<::Window>(userData);
	}

	void WindowImplUnix::ProcessEvent()
	{
		while (XCheckIfEvent(display, &e, &CheckEvent, reinterpret_cast<XPointer>(win)))
		{
			if (xic && XFilterEvent(&e, None))
				continue;

			Event evt;
			switch (e.type)
			{
				//window
			case ClientMessage:
				if (e.xclient.data.l[0] == wmDeleteMessage)
				{
					evt.type = Event::EventType::Close;
					PushEvent(evt);
				}
				break;
			case FocusIn:
				if (xic) XSetICFocus(xic);
				evt.type = Event::EventType::WindowFocus;
				PushEvent(evt);
				break;
			case FocusOut:
				if (xic) XUnsetICFocus(xic);
				evt.type = Event::EventType::WindowFocusOut;
				PushEvent(evt);
				break;
			case ConfigureNotify: //resize
				if (e.xconfigure.width != widthPrevious || e.xconfigure.height != heightPrevious)
				{
					evt.type = Event::EventType::Resize;
					PushEvent(evt);
					widthPrevious = e.xconfigure.width;
					heightPrevious = e.xconfigure.height;
				}
				break;

				//Keyboard
			case KeyPress:
			{
				XKeyEvent* keyEvent = reinterpret_cast<XKeyEvent*>(&e);
				evt.type = Event::EventType::KeyDown;
				unsigned int state;
				bool bCaps = false;
				if (XkbGetIndicatorState(display, XkbUseCoreKbd, &state) == Success)
					bCaps = (state & 0x01); // 0x01 = capslock
				evt.data = Event::KeyEvent{ CovertKeyCode(keyEvent->keycode), bCaps };
				PushEvent(evt);

				char buf[128];
				int len = 0;

				if (xic)
				{
					KeySym keysym = 0;
					Status status = 0;
					len = Xutf8LookupString(xic, keyEvent, buf, (int)sizeof(buf) - 1, &keysym, &status);

					if (status == XLookupChars || status == XLookupBoth)
					{
						buf[len] = '\0';

						uint32_t unicode = 0;
						core::Util::UTF8ToUnicode(buf, buf + len, unicode);

						evt.type = Event::EventType::InputText;
						evt.data = Event::InputText{ unicode };
						PushEvent(evt);
					}
				}
				else
				{
					// IME 없이도 최소한 영문은 들어오게
					KeySym keysym = 0;
					len = XLookupString(keyEvent, buf, (int)sizeof(buf) - 1, &keysym, nullptr);
					if (len > 0)
					{
						buf[len] = '\0';

						uint32_t unicode = 0;
						core::Util::UTF8ToUnicode(buf, buf + len, unicode);

						evt.type = Event::EventType::InputText;
						evt.data = Event::InputText{ unicode };
						PushEvent(evt);
					}
				}
				break;
			}
			case KeyRelease:
			{
				XKeyEvent* keyEvent = reinterpret_cast<XKeyEvent*>(&e);
				evt.type = Event::EventType::KeyUp;
				evt.data = Event::KeyEvent{ CovertKeyCode(keyEvent->keycode), false };
				PushEvent(evt);
				break;
			}
			//Mouse
			case MotionNotify: //move
			{
				Event::MousePosition::mouseX = e.xmotion.x;
				Event::MousePosition::mouseY = e.xmotion.y;
				evt.type = Event::EventType::MouseMove;
				PushEvent(evt);
				break;
			}
			case ButtonPress:
			{
				XButtonEvent* buttonEvent = reinterpret_cast<XButtonEvent*>(&e);

				switch (buttonEvent->button)
				{
				case Button1:
					evt.type = Event::EventType::MousePressed;
					evt.data = Event::MouseType::Left;
					PushEvent(evt);
					break;
				case Button2:
					evt.type = Event::EventType::MousePressed;
					evt.data = Event::MouseType::Middle;
					PushEvent(evt);
					break;
				case Button3:
					evt.type = Event::EventType::MousePressed;
					evt.data = Event::MouseType::Right;
					PushEvent(evt);
					break;
				case Button4:
				case Button5:
					evt.type = Event::EventType::MouseWheelScrolled;
					Event::MouseWheelScrolled::delta = (buttonEvent->button == Button4) ? 1.0f : -1.0f;
					PushEvent(evt);
					break;
				}
				break;
			}
			case ButtonRelease:
			{
				XButtonEvent* buttonEvent = reinterpret_cast<XButtonEvent*>(&e);

				switch (buttonEvent->button)
				{
				case Button1:
					evt.type = Event::EventType::MouseReleased;
					evt.data = Event::MouseType::Left;
					PushEvent(evt);
					break;
				case Button2:
					evt.type = Event::EventType::MouseReleased;
					evt.data = Event::MouseType::Middle;
					PushEvent(evt);
					break;
				case Button3:
					evt.type = Event::EventType::MouseReleased;
					evt.data = Event::MouseType::Right;
					PushEvent(evt);
					break;
				}
				break;
			}
			}//switch
		}

	}

	auto WindowImplUnix::GetDisplay() -> Display*
	{
		return display;
	}

	auto WindowImplUnix::CovertKeyCode(unsigned int keycode) -> Event::KeyType
	{
		KeySym keySym = XkbKeycodeToKeysym(display, keycode, 0, 0);
		switch (keySym)
		{
		//A...B : C++ 표준 문법은 아님!
		case XK_0 ... XK_9:
			return static_cast<Event::KeyType>(keySym - XK_0 + static_cast<int>(Event::KeyType::Num0));
		case XK_F1 ... XK_F12: 
			return static_cast<Event::KeyType>(keySym - XK_F1 + static_cast<int>(Event::KeyType::F1));
		case XK_a ... XK_z:
			return static_cast<Event::KeyType>(keySym - XK_a + static_cast<int>(Event::KeyType::A));
		case XK_A ... XK_Z:
			return static_cast<Event::KeyType>(keySym - XK_A + static_cast<int>(Event::KeyType::A));
		case XK_Shift_L: return Event::KeyType::Shift;
		case XK_Shift_R: return Event::KeyType::Shift;
		case XK_Control_L: return Event::KeyType::LCtrl;
		case XK_Control_R: return Event::KeyType::RCtrl;
		case XK_Alt_L: return Event::KeyType::LAlt;
		case XK_Alt_R: return Event::KeyType::RAlt;
		case XK_space: return Event::KeyType::Space;
		case XK_BackSpace: return Event::KeyType::BackSpace;
		case XK_Return: return Event::KeyType::Enter;
		case XK_Tab: return Event::KeyType::Tab;
		case XK_Escape: return Event::KeyType::Esc;
		case XK_Left: return Event::KeyType::Left;
		case XK_Up: return Event::KeyType::Up;
		case XK_Right: return Event::KeyType::Right;
		case XK_Down: return Event::KeyType::Down;
		case XK_Delete : return Event::KeyType::Delete;
		case XK_Insert: return Event::KeyType::Insert;
		case XK_Page_Up: return Event::KeyType::PageUp;
		case XK_Page_Down: return Event::KeyType::PageDown;
		case XK_End: return Event::KeyType::End;
		case XK_Home: return Event::KeyType::Home;
		case XK_KP_0 ... XK_KP_9: 
			return static_cast<Event::KeyType>(keySym - XK_KP_0 + static_cast<int>(Event::KeyType::Numpad0));
		case XK_KP_Add: return Event::KeyType::NumpadAdd;
		case XK_KP_Subtract: return Event::KeyType::NumpadSubtract;
		case XK_KP_Divide: return Event::KeyType::NumpadDivide;
		case XK_KP_Multiply: return Event::KeyType::NumpadMultiply;
		case XK_KP_Decimal: return Event::KeyType::NumpadDecimal;
		case XK_comma: return Event::KeyType::Comma;
		case XK_period: return Event::KeyType::Period;
		case XK_slash: return Event::KeyType::Slash;
		case XK_minus: return Event::KeyType::Minus;
		case XK_equal: return Event::KeyType::Equal;
		case XK_grave: return Event::KeyType::Grave;
		case XK_bracketleft: return Event::KeyType::LBracket;
		case XK_braceright: return Event::KeyType::RBracket;
		case XK_colon: return Event::KeyType::Colon;
		case XK_semicolon: return Event::KeyType::Semicolon;
		case XK_Print: return Event::KeyType::Print;
		case XK_Scroll_Lock: return Event::KeyType::Scroll;
		case XK_Pause: return Event::KeyType::Pause;
		case XK_Num_Lock : return Event::KeyType::NumLock;
		case XK_Caps_Lock: return Event::KeyType::CapsLock;
		}
		return Event::KeyType::Unknown;
	}

	void WindowImplUnix::SetTitle(std::string_view title)
	{
		Atom netWmName = XInternAtom(display, "_NET_WM_NAME", false);
		Atom utf8String = XInternAtom(display, "UTF8_STRING", false);
		XChangeProperty(display, win, netWmName, utf8String, 8, PropModeReplace,
			(const unsigned char*)title.data(), title.size());
	}

	auto WindowImplUnix::GetWidth() const -> uint32_t
	{
		XWindowAttributes attributes;
		XGetWindowAttributes(display, win, &attributes);
		return attributes.width;
	}
	auto WindowImplUnix::GetHeight() const -> uint32_t
	{
		XWindowAttributes attributes;
		XGetWindowAttributes(display, win, &attributes);
		return attributes.height;
	}

	void WindowImplUnix::StopTimer(uint32_t ms)
	{
		struct timespec ts;
		ts.tv_sec = ms / 1000;
		ts.tv_nsec = (ms % 1000) * 1000000; // 나머지 밀리초를 나노초로 변환

		while (::nanosleep(&ts, &ts) == -1 && errno == EINTR); // 이 방법은 신호에 의해 중단될 수 있음. EINTR 오류를 반환할 경우 루프를 통해 다시 시도
	}
	void WindowImplUnix::Resize(int width, int height)
	{
		if (!display || win == 0)
			return;

		if (width <= 0) 
			width = 1;
		if (height <= 0) 
			height = 1;

		// 서버(또는 윈도우 매니저)에 크기 변경 요청
		XResizeWindow(display, win, static_cast<unsigned int>(width), static_cast<unsigned int>(height));

		// 만약 이전에 고정 크기(min == max)로 설정되어 있었다면,
		// 그 힌트를 새 크기에 맞춰 갱신해 윈도우 매니저가 강제로 원래 크기를 유지하는 상황을 방지
		XSizeHints hints;
		long supplied_return;
		if (XGetWMNormalHints(display, win, &hints, &supplied_return))
		{
			bool wasFixed = false;
			if ((hints.flags & PMinSize) && (hints.flags & PMaxSize))
			{
				if (hints.min_width == hints.max_width && hints.min_height == hints.max_height)
					wasFixed = true;
			}

			if (wasFixed)
			{
				hints.min_width = hints.max_width = width;
				hints.min_height = hints.max_height = height;
				hints.flags |= PMinSize | PMaxSize;
				XSetWMNormalHints(display, win, &hints);
			}
		}

		XFlush(display);

		widthPrevious = width;
		heightPrevious = height;
	}

}//namespace