#include "Input.h"



Input::Input()
{
	for (int i = 0; i < InputNS::KEYS_ARRAY_LENGTH; i++)
	{
		_keyDown[i] = false;
		_keyPressed[i] = false;
	}
	_newLine = true;
	_charIn = 0;
	_textIn = "";

	_mouseRawX = _mouseRawY = _mouseX = _mouseY = 0;
	_mouseLeftButton = _mouseMiddleButton = _mouseRightButton = _mouseX1Button = _mouseX2Button = false;

	for (int i = 0; i < MAX_CONTROLLERS; i++)
	{
		_controllerState[i].vibrateTimeLeft = 0;
		_controllerState[i].vibrateTimeRight = 0;
	}

	_thumbstickDeadzone = GAMEPAD_THUMBSTICK_DEADZONE;
	_triggerDeadzone = GAMEPAD_TRIGGER_DEADZONE;
}


Input::~Input()
{
	if (_mouseCaptured)
		ReleaseCapture();
}

void Input::checkControllers()
{
	DWORD result;
	for (DWORD i = 0; i <MAX_CONTROLLERS; i++)
	{
		result = XInputGetState(i, &_controllerState[i].state);
		if (result == ERROR_SUCCESS)
			_controllerState[i].connected = true;
		else
			_controllerState[i].connected = false;
	}
}

void Input::initialize(HWND hwnd, bool capture)
{
	try
	{
		_mouseCaptured = capture;
		_rid[0].usUsagePage = HID_USAGE_PAGE_GENERIC;
		_rid[0].usUsage = HID_USAGE_GENERIC_MOUSE;
		_rid[0].dwFlags = RIDEV_INPUTSINK;
		_rid[0].hwndTarget = hwnd;
		RegisterRawInputDevices(_rid, 1, sizeof(_rid[0]));

		if (_mouseCaptured)
			SetCapture(hwnd);
		ZeroMemory(_controllerState, sizeof(ControllerState) * MAX_CONTROLLERS);
		checkControllers();
	}
	catch (...)
	{
		throw (Error(ERRORNS::FATAL_ERROR, "Error initializing input system"));
	}
}

void Input::keyDown(WPARAM w)
{
	if (w < InputNS::KEYS_ARRAY_LENGTH)
	{
		_keyDown[w] = true;
		_keyPressed[w] = true;
	}
}

void Input::keyUp(WPARAM w)
{
	if (w < InputNS::KEYS_ARRAY_LENGTH)
		_keyDown[w] = false;
}

void Input::keyIn(WPARAM w)
{
	if (_newLine)
	{
		_textIn.clear();
		_newLine = false;
	}
	if (w == '\b')
	{
		if (_textIn.length() > 0)
			_textIn.erase(_textIn.size() - 1);
	}
	else
	{
		_textIn += w;
		_charIn = w;
	}
	if (w == '\r')
		_newLine = true;
}

bool Input::isKeyDown(UCHAR w) const
{
	if (w < InputNS::KEYS_ARRAY_LENGTH)
		return _keyDown[w];
	return false;
}

bool Input::wasKeyPressed(UCHAR w) const
{
	if (w < InputNS::KEYS_ARRAY_LENGTH)
		return _keyPressed[w];
	return false;
}

bool Input::anyKeyPressed() const
{
	for (int i = 0; i < InputNS::KEYS_ARRAY_LENGTH; i++)
		if (_keyPressed[i] == true)
			return true;
	return false;
}

void Input::clearKeyPress(UCHAR w)
{
	if (w < InputNS::KEYS_ARRAY_LENGTH)
		_keyPressed[w] = false;
}

void Input::clearAll()
{
	clear(InputNS::KEYS_MOUSE_TEXT);
	clear(InputNS::KEYS_DOWN);
}

void Input::clear(UCHAR what)
{
	if (what & InputNS::KEYS_DOWN)
	{
		for (int i = 0; i < InputNS::KEYS_ARRAY_LENGTH; i++)
			_keyDown[i] = false;
	}
	if (what & InputNS::KEYS_PRESSED)
	{
		for (int i = 0; i < InputNS::KEYS_ARRAY_LENGTH; i++)
			_keyPressed[i] = false;
	}
	if (what & InputNS::MOUSE)
	{
		_mouseX = _mouseRawX = _mouseY = _mouseRawY = 0;
	}
	if (what & InputNS::TEXT_IN)
	{
		_textIn.clear();
	}
}

void Input::mouseIn(LPARAM l)
{
	_mouseX = GET_X_LPARAM(l);
	_mouseY = GET_Y_LPARAM(l);
}

void Input::mouseRawIn(LPARAM l)
{
	UINT dwSize = 40;
	static BYTE lbp[40];
	GetRawInputData((HRAWINPUT)l, RID_INPUT, lbp, &dwSize, sizeof(RAWINPUTHEADER));
	RAWINPUT *rawInput = (RAWINPUT *)lbp;
	if (rawInput->header.dwType == RIM_TYPEMOUSE)
	{
		_mouseRawX = rawInput->data.mouse.lLastX;
		_mouseRawY = rawInput->data.mouse.lLastY;
	}
}

void Input::readController()
{
	DWORD result;
	for (DWORD i = 0; i < MAX_CONTROLLERS; i++)
	{
		if (_controllerState[i].connected)
		{
			result = XInputGetState(i, &_controllerState[i].state);
			if (result == ERROR_DEVICE_NOT_CONNECTED)
			{
				_controllerState[i].connected = false;
			}
		}
	}
}

const ControllerState * Input::getControllerState(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return &_controllerState[n];
}

const WORD Input::getGamepadButtons(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.wButtons;
}


bool Input::getGamepadDPadUp(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return ((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_DPAD_UP) != 0);
}

bool Input::getGamepadDPadDown(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return ((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_DPAD_DOWN) != 0);
}

bool Input::getGamepadDPadLeft(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return ((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_DPAD_LEFT) != 0);
}

bool Input::getGamepadDPadRight(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_DPAD_RIGHT) != 0);
}

bool Input::getGamepadStart(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_START_BUTTON) != 0);
}

bool Input::getGamepadBack(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_BACK_BUTTON) != 0);
}

bool Input::getGamepadLeftThumb(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_LEFT_THUMB) != 0);
}

bool Input::getGamepadRightThumb(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_RIGHT_THUMB) != 0);
}


bool Input::getGamepadLeftShoulder(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_LEFT_SHOULDER) != 0);
}


bool Input::getGamepadRightShoulder(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_RIGHT_SHOULDER) != 0);
}


bool Input::getGamepadA(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_A) != 0);
}


bool Input::getGamepadB(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_B) != 0);
}


bool Input::getGamepadX(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_X) != 0);
}


bool Input::getGamepadY(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return bool((_controllerState[n].state.Gamepad.wButtons&GAMEPAD_Y) != 0);
}

BYTE Input::getGamepadLeftTrigger(UINT n)
{
	BYTE value = getGamepadLeftTriggerUndead(n);
	if (value > _triggerDeadzone)
		value = (value - _triggerDeadzone) * 255 / (255 - _triggerDeadzone);
	else
		value = 0;
	return value;
}

BYTE Input::getGamepadLeftTriggerUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.bLeftTrigger;
}

BYTE Input::getGamepadRightTrigger(UINT n)
{
	BYTE value = getGamepadRightTriggerUndead(n);
	if (value > _triggerDeadzone)
		value = (value - _triggerDeadzone) * 255 /
		(255 - _triggerDeadzone);
	else
		value = 0;
	return value;
}

BYTE Input::getGamepadRightTriggerUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.bRightTrigger;
}

SHORT Input::getGamepadThumbLX(UINT n)
{
	int x = getGamepadThumbLXUndead(n);
	if (x > _thumbstickDeadzone)
		x = (x - _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else if (x < -_thumbstickDeadzone)
		x = (x + _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else
		x = 0;
	return static_cast<SHORT>(x);
}

SHORT Input::getGamepadThumbLXUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.sThumbLX;
}

SHORT Input::getGamepadThumbLY(UINT n)
{
	int y = getGamepadThumbLYUndead(n);
	if (y > _thumbstickDeadzone)
		y = (y - _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else if (y < -_thumbstickDeadzone)
		y = (y + _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else
		y = 0;
	return static_cast<SHORT>(y);
}

SHORT Input::getGamepadThumbLYUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.sThumbLY;
}

SHORT Input::getGamepadThumbRX(UINT n)
{
	int x = getGamepadThumbRXUndead(n);
	if (x > _thumbstickDeadzone)
		x = (x - _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else if (x < -_thumbstickDeadzone)
		x = (x + _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else
		x = 0;
	return static_cast<SHORT>(x);
}

SHORT Input::getGamepadThumbRXUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.sThumbRX;
}

SHORT Input::getGamepadThumbRY(UINT n)
{
	int y = getGamepadThumbRYUndead(n);
	if (y > _thumbstickDeadzone)
		y = (y - _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else if (y < -_thumbstickDeadzone)
		y = (y + _thumbstickDeadzone) * 32767 / (32767 - _thumbstickDeadzone);
	else
		y = 0;
	return static_cast<SHORT>(y);
}

SHORT Input::getGamepadThumbRYUndead(UINT n)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	return _controllerState[n].state.Gamepad.sThumbRY;
}

void Input::gamePadVibrateLeft(UINT n, WORD speed, float sec)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	_controllerState[n].vibration.wLeftMotorSpeed = speed;
	_controllerState[n].vibrateTimeLeft = sec;
}

void Input::gamePadVibrateRight(UINT n, WORD speed, float sec)
{
	if (n > MAX_CONTROLLERS - 1)
		n = MAX_CONTROLLERS - 1;
	_controllerState[n].vibration.wRightMotorSpeed = speed;
	_controllerState[n].vibrateTimeRight = sec;
}

void Input::vibrateControllers(float frameTime)
{
	for (int i = 0; i < MAX_CONTROLLERS; i++)
	{
		if (_controllerState[i].connected)
		{
			_controllerState[i].vibrateTimeLeft -= frameTime;
			if (_controllerState[i].vibrateTimeLeft < 0)
			{
				_controllerState[i].vibrateTimeLeft = 0;
				_controllerState[i].vibration.wLeftMotorSpeed = 0;
			}
			_controllerState[i].vibrateTimeRight -= frameTime;
			if (_controllerState[i].vibrateTimeRight < 0)
			{
				_controllerState[i].vibrateTimeRight = 0;
				_controllerState[i].vibration.wRightMotorSpeed = 0;
			}
			XInputSetState(i, &_controllerState[i].vibration);
		}
	}
}