#ifndef BOOLEAN_INPUT_HH

#define BOOLEAN_INPUT_HH

// A 'BooleanInput' represents an input which has a well defined start and stop.

//

// Some examples:

// * Press a key on the keyboard, later release that key.

// * Same for joystick and mouse buttons.

// * The 4 directions on a joystick hat (d-pad): active when e.g. pressing the

//   'up' direction, it remains active when the 'up-left' or 'up-right'

//   combination is pressed, but becomes deactive for any other combination

//   (including 'center').

// * Joystick axis: becomes active when moving the axis in e.g. the positive

//   direction (the negative direction is a different BooleanInput) past the

//   dead-zone in the center. Becomes deactive when moving the axis back to the

//   center or in the opposite direction.

//

// Counter-examples:

// * Mouse-wheel.

// * Mouse motion.

#include "Event.hh"

#include "JoystickId.hh"

#include "function_ref.hh"

#include "unreachable.hh"

#include <SDL.h>

#include <cstdint>

#include <optional>

#include <string>

#include <string_view>

#include <variant>

namespace openmsx {

class BooleanKeyboard

{

public:

	explicit BooleanKeyboard(SDL_Keycode code)

		: keyCode(code) {}

	[[nodiscard]] auto getKeyCode() const { return keyCode; }

private:

	SDL_Keycode keyCode;

};

class BooleanMouseButton

{

public:

	explicit BooleanMouseButton(uint8_t button_)

		: button(button_) {}

	[[nodiscard]] auto getButton() const { return button; }

private:

	uint8_t button;

};

class BooleanJoystickButton

{

public:

	explicit BooleanJoystickButton(JoystickId joystick_, uint8_t button_)

		: joystick(joystick_), button(button_) {}

	[[nodiscard]] auto getJoystick() const { return joystick; }

	[[nodiscard]] auto getButton() const { return button; }

private:

	JoystickId joystick;

	uint8_t button;

};

class BooleanJoystickHat

{

public:

	enum class Direction : uint8_t {

		UP    = SDL_HAT_UP,

		RIGHT = SDL_HAT_RIGHT,

		DOWN  = SDL_HAT_DOWN,

		LEFT  = SDL_HAT_LEFT,

	};

	explicit BooleanJoystickHat(JoystickId joystick_, uint8_t hat_, Direction value_)

		: joystick(joystick_), hat(hat_), value(value_) {}

	[[nodiscard]] auto getJoystick() const { return joystick; }

	[[nodiscard]] auto getHat() const { return hat; }

	[[nodiscard]] auto getValue() const { return value; }

private:

	JoystickId joystick;

	uint8_t hat;

	Direction value;

};

[[nodiscard]] constexpr std::string_view toString(BooleanJoystickHat::Direction dir)

{

	using namespace std::literals;

	using enum BooleanJoystickHat::Direction;

	switch (dir) {

		case UP:    return "up"sv;

		case RIGHT: return "right"sv;

		case DOWN:  return "down"sv;

		case LEFT:  return "left"sv;

	}

	UNREACHABLE;

}

class BooleanJoystickAxis

{

public:

	enum class Direction : uint8_t { POS, NEG };

	explicit BooleanJoystickAxis(JoystickId joystick_, uint8_t axis_, Direction direction_)

		: joystick(joystick_), axis(axis_), direction(direction_) {}

	[[nodiscard]] auto getJoystick() const { return joystick; }

	[[nodiscard]] auto getAxis() const { return axis; }

	[[nodiscard]] auto getDirection() const { return direction; }

private:

	JoystickId joystick;

	uint8_t axis;

	Direction direction;

};

using BooleanInput = std::variant<

	BooleanKeyboard,

	BooleanMouseButton,

	BooleanJoystickButton,

	BooleanJoystickHat,

	BooleanJoystickAxis>;

[[nodiscard]] std::string toString(const BooleanInput& input);

[[nodiscard]] std::optional<BooleanInput> parseBooleanInput(std::string_view text);

[[nodiscard]] std::optional<BooleanInput> captureBooleanInput(const Event& event, function_ref<int(JoystickId)> getJoyDeadThreshold);

[[nodiscard]] bool operator==(const BooleanInput& x, const BooleanInput& y);

[[nodiscard]] std::optional<bool> match(const BooleanInput& binding, const Event& event,

                                        function_ref<int(JoystickId)> getJoyDeadThreshold);

} // namespace openmsx

#endif