/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef NUVIE_KEYBINDING_KEYS_H
#define NUVIE_KEYBINDING_KEYS_H

#include "ultima/nuvie/keybinding/keys_enum.h"
#include "ultima/nuvie/core/nuvie_defs.h"
#include "ultima/shared/std/containers.h"
#include "ultima/shared/std/string.h"
#include "common/events.h"
#include "common/hash-str.h"

namespace Ultima {
namespace Nuvie {

enum joy_axes_pairs {
	AXES_PAIR1, AXES_PAIR2, AXES_PAIR3, AXES_PAIR4, UNHANDLED_AXES_PAIR
};

enum altCodeMode {
	kAltCodeModeBegin = 0,
	kAltCodeModeEnd = 1
};

struct Action;
struct ActionType {
	const Action *action;
	int param;
};

typedef Common::HashMap<uint32, ActionType> KeyMap;

typedef Common::HashMap<Common::String, Common::KeyCode> ParseKeyMap;
typedef Common::HashMap<Common::String, const Action *> ParseActionMap;
typedef Common::HashMap<uint32, ActionType> ParseHashedActionMap;

class Configuration;

char get_ascii_char_from_keysym(Common::KeyState keysym);

class KeyBinder {
private:
	KeyMap _bindings;

	ParseKeyMap _keys;
	ParseActionMap _actions;
	ParseHashedActionMap _actionsHashed;
	int16 _joyAxisPositions[8];

	bool repeat_hat, joy_repeat_enabled; // repeat hat instead of axis when hat is found
	uint32 next_axes_pair_update, next_axes_pair2_update, next_axes_pair3_update,
		next_axes_pair4_update, next_joy_repeat_time;
	uint16 pair1_delay, pair2_delay, pair3_delay, pair4_delay, joy_repeat_delay;
	uint8 x_axis, y_axis, x_axis2, y_axis2, x_axis3, y_axis3, x_axis4, y_axis4;
	sint8 enable_joystick;

	void LoadFromFileInternal(const char *filename);
public:
	KeyBinder(const Configuration *config);
	~KeyBinder();
	/* Add keybinding */
	void AddKeyBinding(Common::KeyCode sym, byte mod, const Action *action,
	                   int nparams, int param);

	/* Delete keybinding */
//	void DelKeyBinding(Common::KeyCode sym, int mod); // unused

	/* Other methods */
	void Flush() {
		_bindings.clear();
	}
	ActionType get_ActionType(const Common::KeyState &key);
	ActionKeyType GetActionKeyType(ActionType a);
	bool DoAction(ActionType const &a) const;
	KeyMap::iterator get_sdlkey_index(const Common::KeyState &key);
	bool HandleEvent(const Common::Event *event);
	bool handleScummVMBoundEvent(const Common::Event *event);

	void LoadFromFile(const char *filename);
	void LoadGameSpecificKeys();
	void LoadFromPatch();
	void handle_wrong_key_pressed();
	bool handle_always_available_keys(ActionType a);

	void ShowKeys() const;
    void AddIosBindings();

	uint8 get_axis(uint8 index) const;
	void set_axis(uint8 index, uint8 value);
	Common::KeyCode get_key_from_joy_walk_axes() {
		return get_key_from_joy_axis_motion(x_axis, true);
	}
	Common::KeyCode get_key_from_joy_axis_motion(int axis, bool repeating);
	Common::KeyCode get_key_from_joy_hat_button(uint8 hat_button) const;
	Common::KeyCode get_key_from_joy_events(Common::Event *event);
	void init_joystick(sint8 joy_num);
//	SDL_Joystick *get_joystick() { return joystick; }
	uint32 get_next_joy_repeat_time() const {
		return next_joy_repeat_time;
	}
	void set_enable_joy_repeat(bool val) {
		if (joy_repeat_delay == 10000) return;
		joy_repeat_enabled = val;
	}
	bool is_joy_repeat_enabled() const {
		return joy_repeat_enabled;
	}
	bool is_hat_repeating() const {
		return repeat_hat;
	}
	void set_hat_repeating(bool val) {
		repeat_hat = val;
	}
	sint8 get_enable_joystick() const {
		return enable_joystick;
	}
	void set_enable_joystick(bool val) {
		enable_joystick = val;
	}

private:
	void ParseText(char *text, int len);
	void ParseLine(const char *line);
	void FillParseMaps();

	joy_axes_pairs get_axes_pair(int axis) const;
	Common::KeyCode get_key_from_joy_button(uint8 button);
	Common::Array<Common::U32String> buildKeyHelp() const;
};

} // End of namespace Nuvie
} // End of namespace Ultima

#endif