// ----------------------------------------------------------------
// From Game Programming in C++ by Sanjay Madhav
// Copyright (C) 2017 Sanjay Madhav. All rights reserved.
// 
// Released under the BSD License
// See LICENSE in root directory for full details.
// ----------------------------------------------------------------

#include "InputSystem.h"
#include <SDL/SDL.h>
#include <sstream>
#include <cstring>
#include <iostream>
#include <fstream>
#include <algorithm>
#include "InputDetector.h"

bool KeyboardState::GetKeyValue(SDL_Scancode keyCode) const
{
	return mCurrState[keyCode] == 1;
}

ButtonState KeyboardState::GetKeyState(SDL_Scancode keyCode) const
{
	if (mPrevState[keyCode] == 0)
	{
		if (mCurrState[keyCode] == 0)
		{
			return ENone;
		}
		else
		{
			return EPressed;
		}
	}
	else // Prev state must be 1
	{
		if (mCurrState[keyCode] == 0)
		{
			return EReleased;
		}
		else
		{
			return EHeld;
		}
	}
}

bool MouseState::GetButtonValue(int button) const
{
	return (SDL_BUTTON(button) & mCurrButtons) == 1;
}

ButtonState MouseState::GetButtonState(int button) const
{
	int mask = SDL_BUTTON(button);
	if ((mask & mPrevButtons) == 0)
	{
		if ((mask & mCurrButtons) == 0)
		{
			return ENone;
		}
		else
		{
			return EPressed;
		}
	}
	else
	{
		if ((mask & mCurrButtons) == 0)
		{
			return EReleased;
		}
		else
		{
			return EHeld;
		}
	}
}

bool ControllerState::GetButtonValue(SDL_GameControllerButton button) const
{
	return mCurrButtons[button] == 1;
}

ButtonState ControllerState::GetButtonState(SDL_GameControllerButton button) const
{
	if (mPrevButtons[button] == 0)
	{
		if (mCurrButtons[button] == 0)
		{
			return ENone;
		}
		else
		{
			return EPressed;
		}
	}
	else // Prev state must be 1
	{
		if (mCurrButtons[button] == 0)
		{
			return EReleased;
		}
		else
		{
			return EHeld;
		}
	}
}
InputState::InputState()
{
	cButtons[""] = SDL_CONTROLLER_BUTTON_INVALID;
	cButtons["A"] = SDL_CONTROLLER_BUTTON_A;
	cButtons["B"] = SDL_CONTROLLER_BUTTON_B;
	cButtons["X"] = SDL_CONTROLLER_BUTTON_X;
	cButtons["Y"] = SDL_CONTROLLER_BUTTON_Y;
	cButtons["Back"] = SDL_CONTROLLER_BUTTON_BACK;
	cButtons["Guide"] = SDL_CONTROLLER_BUTTON_GUIDE;
	cButtons["Start"] = SDL_CONTROLLER_BUTTON_START;
	cButtons["LeftStick"] = SDL_CONTROLLER_BUTTON_LEFTSTICK;
	cButtons["RightStick"] = SDL_CONTROLLER_BUTTON_RIGHTSTICK;
	cButtons["LeftShoulder"] = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
	cButtons["RightShoulder"] = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;
	cButtons["DPadUp"] = SDL_CONTROLLER_BUTTON_DPAD_UP;
	cButtons["DPadDown"] = SDL_CONTROLLER_BUTTON_DPAD_DOWN;
	cButtons["DPadLeft"] = SDL_CONTROLLER_BUTTON_DPAD_LEFT;
	cButtons["DPadRight"] = SDL_CONTROLLER_BUTTON_DPAD_RIGHT;
	cButtons[""] = SDL_CONTROLLER_BUTTON_MAX;
}
InputState::~InputState()
{
	for (auto kv : bindings) {
		delete kv.second;
	}
	ClearBinding();
}
// InputState
bool InputState::GetBoolValue(const std::string & name) const
{
	return bindings.at(name)->GetBoolValue(Self());
}

ButtonState InputState::GetButtonValue(const std::string & name) const
{
	return bindings.at(name)->GetButtonValue(Self());
}

float InputState::GetFloatValue(const std::string & name) const
{
	return bindings.at(name)->GetFloatValue(Self());
}

Vector2 InputState::GetAxisValue(const std::string & name) const
{
	return bindings.at(name)->GetAxisValue(Self());
}

void InputState::ParseBindingFromFile(const std::string & path)
{
	std::ifstream ifs(path);
	std::string str((std::istreambuf_iterator<char>(ifs)), std::istreambuf_iterator<char>());
	ParseBindingFromString(str);
}

void InputState::ParseBindingFromString(const std::string & source)
{
	ClearBinding();
	const char* sentence = source.c_str();
	std::stringstream ss(sentence);
	std::string to;

	if (sentence != NULL)
	{
		while (std::getline(ss, to, '\n')) {
			if (to[0] == '#') {
				continue;
			}
			AddBinding(to);
		}
	}
}

void InputState::AddBinding(const std::string & oneline)
{
	std::vector<std::string> words;
	split(oneline, words, ' ');
	std::string name = words[0];
	std::string type = words[1];
	if (type == "Key") {
		PutBinding(name, new KeyDetector((SDL_Scancode)std::stoi(words[2])));
	}
	else if (type == "Mouse") {
		if (words[2] == "Left") {
			PutBinding(name, new MouseDetector(SDL_BUTTON_LEFT));
		}
		else if (words[2] == "Right") {
			PutBinding(name, new MouseDetector(SDL_BUTTON_RIGHT));
		}
		else {
			throw std::logic_error("unknown mouse type: " + words[2]);
		}
	}
	else if (type == "ControllerButton") {
		PutBinding(name, new ControllerButtonDetector(cButtons[words[2]]));
	}
	else if (type == "ControllerStick") {
		if (words[2] == "Left") {
			PutBinding(name, new ControllerStickDetector(ControllerDirection::Left));
		}
		else if (words[2] == "Right") {
			PutBinding(name, new ControllerStickDetector(ControllerDirection::Right));
		}
		else {
			throw std::logic_error("unknown stick type: " + words[2]);
		}
	}
	else if (type == "ControllerTrigger") {
		if (words[2] == "Left") {
			PutBinding(name, new ControllerTriggerDetector(ControllerDirection::Left));
		}
		else if (words[2] == "Right") {
			PutBinding(name, new ControllerTriggerDetector(ControllerDirection::Right));
		}
		else {
			throw std::logic_error("unknown stick type: " + words[2]);
		}
	}
	else {
		throw std::logic_error("unsupported input type: " + type);
	}
}

void InputState::PutBinding(const std::string & key, InputDetector * detector)
{
	bindings[key] = detector;
}

void InputState::RemoveBinding(const std::string & key)
{
	bindings.erase(key);
}

bool InputState::HasBinding(const std::string & key) const
{
	return bindings.count(key) > 0;
}

void InputState::ClearBinding()
{
	bindings.clear();
}

const InputState & InputState::Self() const
{
	return *this;
}

size_t InputState::split(const std::string & txt, std::vector<std::string>& strs, char ch)
{
	//https://stackoverflow.com/questions/5888022/split-string-by-single-spaces
	size_t pos = txt.find(ch);
	size_t initialPos = 0;
	strs.clear();

	// Decompose statement
	while (pos != std::string::npos) {
		strs.push_back(txt.substr(initialPos, pos - initialPos));
		initialPos = pos + 1;

		pos = txt.find(ch, initialPos);
	}

	// Add the last one
	strs.push_back(txt.substr(initialPos, std::min(pos, txt.size()) - initialPos + 1));

	return strs.size();
}


// InputSystem
bool InputSystem::Initialize(const std::string& bindingFile)
{
	// Keyboard
	// Assign current state pointer
	mState.Keyboard.mCurrState = SDL_GetKeyboardState(NULL);
	// Clear previous state memory
	memset(mState.Keyboard.mPrevState, 0,
		SDL_NUM_SCANCODES);

	// Mouse (just set everything to 0)
	mState.Mouse.mCurrButtons = 0;
	mState.Mouse.mPrevButtons = 0;

	// Get the connected controller, if it exists
	mController = SDL_GameControllerOpen(0);
	// Initialize controller state
	mState.Controller.mIsConnected = (mController != nullptr);
	memset(mState.Controller.mCurrButtons, 0,
		SDL_CONTROLLER_BUTTON_MAX);
	memset(mState.Controller.mPrevButtons, 0,
		SDL_CONTROLLER_BUTTON_MAX);
	mState.ParseBindingFromFile(bindingFile);
	return true;
}

void InputSystem::Shutdown()
{
}

void InputSystem::PrepareForUpdate()
{
	// Copy current state to previous
	// Keyboard
	memcpy(mState.Keyboard.mPrevState,
		mState.Keyboard.mCurrState,
		SDL_NUM_SCANCODES);

	// Mouse
	mState.Mouse.mPrevButtons = mState.Mouse.mCurrButtons;
	mState.Mouse.mIsRelative = false;
	mState.Mouse.mScrollWheel = Vector2::Zero;

	// Controller
	memcpy(mState.Controller.mPrevButtons,
		mState.Controller.mCurrButtons,
		SDL_CONTROLLER_BUTTON_MAX);
}

void InputSystem::Update()
{
	// Mouse
	int x = 0, y = 0;
	if (mState.Mouse.mIsRelative)
	{
		mState.Mouse.mCurrButtons = 
			SDL_GetRelativeMouseState(&x, &y);
	}
	else
	{
		mState.Mouse.mCurrButtons = 
			SDL_GetMouseState(&x, &y);
	}

	mState.Mouse.mMousePos.x = static_cast<float>(x);
	mState.Mouse.mMousePos.y = static_cast<float>(y);

	// Controller
	// Buttons
	for (int i = 0; i < SDL_CONTROLLER_BUTTON_MAX; i++)
	{
		mState.Controller.mCurrButtons[i] =
			SDL_GameControllerGetButton(mController, 
				SDL_GameControllerButton(i));
	}

	// Triggers
	mState.Controller.mLeftTrigger =
		Filter1D(SDL_GameControllerGetAxis(mController,
			SDL_CONTROLLER_AXIS_TRIGGERLEFT));
	mState.Controller.mRightTrigger =
		Filter1D(SDL_GameControllerGetAxis(mController,
			SDL_CONTROLLER_AXIS_TRIGGERRIGHT));

	// Sticks
	x = SDL_GameControllerGetAxis(mController,
		SDL_CONTROLLER_AXIS_LEFTX);
	y = -SDL_GameControllerGetAxis(mController,
		SDL_CONTROLLER_AXIS_LEFTY);
	mState.Controller.mLeftStick = Filter2D(x, y);

	x = SDL_GameControllerGetAxis(mController,
		SDL_CONTROLLER_AXIS_RIGHTX);
	y = -SDL_GameControllerGetAxis(mController,
		SDL_CONTROLLER_AXIS_RIGHTY);
	mState.Controller.mRightStick = Filter2D(x, y);
}

void InputSystem::ProcessEvent(SDL_Event& event)
{
	switch (event.type)
	{
	case SDL_MOUSEWHEEL:
		mState.Mouse.mScrollWheel = Vector2(
			static_cast<float>(event.wheel.x),
			static_cast<float>(event.wheel.y));
		break;
	default:
		break;
	}
}

void InputSystem::SetRelativeMouseMode(bool value)
{
	SDL_bool set = value ? SDL_TRUE : SDL_FALSE;
	SDL_SetRelativeMouseMode(set);

	mState.Mouse.mIsRelative = value;
}

float InputSystem::Filter1D(int input)
{
	// A value < dead zone is interpreted as 0%
	const int deadZone = 250;
	// A value > max value is interpreted as 100%
	const int maxValue = 30000;

	float retVal = 0.0f;

	// Take absolute value of input
	int absValue = input > 0 ? input : -input;
	// Ignore input within dead zone
	if (absValue > deadZone)
	{
		// Compute fractional value between dead zone and max value
		retVal = static_cast<float>(absValue - deadZone) /
		(maxValue - deadZone);
		// Make sure sign matches original value
		retVal = input > 0 ? retVal : -1.0f * retVal;
		// Clamp between -1.0f and 1.0f
		retVal = Math::Clamp(retVal, -1.0f, 1.0f);
	}

	return retVal;
}

Vector2 InputSystem::Filter2D(int inputX, int inputY)
{
	const float deadZone = 8000.0f;
	const float maxValue = 30000.0f;

	// Make into 2D vector
	Vector2 dir;
	dir.x = static_cast<float>(inputX);
	dir.y = static_cast<float>(inputY);

	float length = dir.Length();

	// If length < deadZone, should be no input
	if (length < deadZone)
	{
		dir = Vector2::Zero;
	}
	else
	{
		// Calculate fractional value between
		// dead zone and max value circles
		float f = (length - deadZone) / (maxValue - deadZone);
		// Clamp f between 0.0f and 1.0f
		f = Math::Clamp(f, 0.0f, 1.0f);
		// Normalize the vector, and then scale it to the
		// fractional value
		dir *= f / length;
	}

	return dir;
}