using System;

using System.Collections.Generic;

namespace Assistance {

	public class InputState {

		public long ticks;

		public KeyHistory<gdk.key> keyHistory = new KeyHistory<gdk.key>();</gdk.key></gdk.key>

		public readonly Dictionary<gdk.device, keyhistory<uint="">> buttonHistories = new Dictionary<gdk.device, keyhistory<uint="">>();</gdk.device,></gdk.device,>

		public void touch(long ticks) {

			if (this.ticks < ticks)

				this.ticks = ticks;

			else

				++this.ticks;

		}

		public KeyState<gdk.key> keyState</gdk.key>

			{ get { return keyHistory.current; } }

		public void keyEvent(bool press, Gdk.Key key, long ticks) {

			touch(ticks);

			keyHistory.change(press, key, this.ticks);

		}

		public void keyPress(Gdk.Key key, long ticks)

			{ keyEvent(true, key, ticks); }

		public void keyRelease(Gdk.Key key, long ticks)

			{ keyEvent(false, key, ticks); }

		public KeyState<gdk.key> keyFind(Gdk.Key key)</gdk.key>

			{ return keyState.find(key); }

		public bool isKeyPressed(Gdk.Key key)

			{ return keyFind(key) != null; }

		public double howLongKeyPressed(Gdk.Key key, long ticks, double timeOffset = 0.0)

			{ return KeyState<gdk.key>.Holder.howLongPressed(keyFind(key), ticks, timeOffset); }</gdk.key>

		public double howLongKeyPressed(Gdk.Key key)

			{ return howLongKeyPressed(key, ticks); }

		public KeyHistory<uint> buttonHistory(Gdk.Device device) {</uint>

			KeyHistory<uint> history;</uint>

			if (!buttonHistories.TryGetValue(device, out history))

				history = new KeyHistory<uint>();</uint>

				buttonHistories[device] = history;

			return history;

		}

		public KeyState<uint> buttonState(Gdk.Device device)</uint>

			{ return buttonHistory(device).current; }

		public void buttonEvent(bool press, Gdk.Device device, uint button, long ticks) {

			touch(ticks);

			buttonHistory(device).change(press, button, this.ticks);

		}

		public void buttonPress(Gdk.Device device, uint button, long ticks)

			{ buttonEvent(true, device, button, ticks); }

		public void buttonRelease(Gdk.Device device, uint button, long ticks)

			{ buttonEvent(false, device, button, ticks); }

		public void buttonEvent(bool press, uint button, long ticks)

			{ buttonEvent(press, null, button, ticks); }

		public void buttonPress(uint button, long ticks)

			{ buttonEvent(true, button, ticks); }

		public void buttonRelease(uint button, long ticks)

			{ buttonEvent(false, button, ticks); }

		public KeyState<uint> buttonFind(Gdk.Device device, uint button)</uint>

			{ return buttonState(device).find(button); }

		public bool isButtonPressed(Gdk.Device device, uint button)

			{ return buttonFind(device, button) != null; }

		public double howLongButtonPressed(Gdk.Device device, uint button, long ticks, double timeOffset = 0.0)

			{ return KeyState<uint>.Holder.howLongPressed(buttonFind(device, button), ticks, timeOffset); }</uint>

		public double howLongButtonPressed(Gdk.Device device, uint button)

			{ return howLongButtonPressed(device, button, ticks); }

		public KeyState<uint> buttonFindDefault(uint button)</uint>

			{ return buttonFind(null, button); }

		public bool isButtonPressedDefault(uint button)

			{ return isButtonPressed(null, button); }

		public double howLongButtonPressedDefault(uint button, long ticks, double timeOffset = 0.0)

			{ return howLongButtonPressed(null, button, ticks, timeOffset); }

		public double howLongButtonPressedDefault(uint button)

			{ return howLongButtonPressedDefault(button, ticks); }

		public KeyState<uint> buttonFindAny(uint button, out Gdk.Device device) {</uint>

			device = null;

			KeyState<uint> state = null;</uint>

			foreach(KeyValuePair<gdk.device, keyhistory<uint="">> pair in buttonHistories) {</gdk.device,>

				KeyState<uint> s = pair.Value == null ? null : pair.Value.current.find(button);</uint>

				if (s != null && (state == null || s.ticks < state.ticks))

					{ state = s; device = pair.Key; }

			}

			return state;

		}

		public KeyState<uint> buttonFindAny(uint button)</uint>

			{ Gdk.Device device; return buttonFindAny(button, out device); }

		public bool isButtonPressedAny(uint button)

			{ return buttonFindAny(button) != null; }

		public double howLongButtonPressedAny(uint button, long ticks, double timeOffset = 0.0)

			{ return KeyState<uint>.Holder.howLongPressed(buttonFindAny(button), ticks, timeOffset); }</uint>

		public double howLongButtonPressedAny(uint button)

			{ return howLongButtonPressedAny(button, ticks); }

		public KeyState<gdk.key>.Holder keyStateHolder(long ticks, double timeOffset = 0.0)</gdk.key>

			{ return new KeyState<gdk.key>.Holder(keyState, ticks, timeOffset); }</gdk.key>

		public KeyState<gdk.key>.Holder keyStateHolder()</gdk.key>

			{ return keyStateHolder(ticks); }

		public KeyHistory<gdk.key>.Holder keyHistoryHolder(long ticks, double timeOffset = 0.0)</gdk.key>

			{ return new KeyHistory<gdk.key>.Holder(keyHistory, ticks, timeOffset); }</gdk.key>

		public KeyHistory<gdk.key>.Holder keyHistoryHolder()</gdk.key>

			{ return keyHistoryHolder(ticks); }

		public KeyState<uint>.Holder buttonStateHolder(Gdk.Device device, long ticks, double timeOffset = 0.0)</uint>

			{ return new KeyState<uint>.Holder(buttonState(device), ticks, timeOffset); }</uint>

		public KeyState<uint>.Holder buttonStateHolder(Gdk.Device device)</uint>

			{ return buttonStateHolder(device, ticks); }

		public KeyHistory<uint>.Holder buttonHistoryHolder(Gdk.Device device, long ticks, double timeOffset = 0.0)</uint>

			{ return new KeyHistory<uint>.Holder(buttonHistory(device), ticks, timeOffset); }</uint>

		public KeyHistory<uint>.Holder buttonHistoryHolder(Gdk.Device device)</uint>

			{ return buttonHistoryHolder(device, ticks); }

	}

}