using System;

namespace Assistance {

	public class KeyState<t> where T: IComparable, new() {</t>

		public struct Holder {

			public KeyState<t> state;</t>

			public long ticks;

			public double timeOffset;

			public Holder(KeyState<t> state, long ticks = 0, double timeOffset = 0.0) {</t>

				this.state = state;

				this.ticks = ticks;

				this.timeOffset = timeOffset;

			}

			public KeyState<t> find(T value)</t>

				{ return state == null ? null : state.find(value); }

			public bool isEmpty

				{ get { return state == null || state.isEmpty; } }

			public bool isPressed(T value)

				{ return find(value) != null; }

			public double howLongPressed(T value)

				{ return howLongPressed(find(value), ticks, timeOffset); }

			public static double howLongPressed(KeyState<t> state, long ticks, double timeOffset) {</t>

				return state == null ? 0.0

				     : Math.Max(Timer.step, (ticks - state.ticks)*Timer.step + timeOffset);

			}

		}

		public static readonly T none = new T();

		public static readonly KeyState<t> empty = new KeyState<t>();</t></t>

		public readonly KeyState<t> previous;</t>

		public readonly long ticks;

		public readonly T value;

		public KeyState(): this(null, 0, none) { }

		private KeyState(KeyState<t> previous, long ticks, T value) {</t>

			this.previous = previous;

			this.ticks = ticks;

			this.value = value;

		}

		public KeyState<t> find(T value) {</t>

			if (value.CompareTo(none) == 0)

				return null;

			if (value.CompareTo(this.value) == 0)

				return this;

			if (previous == null)

				return null;

			return previous.find(value);

		}

		private KeyState<t> makeChainWithout(KeyState<t> ks) {</t></t>

			if (this == ks || previous == null) return previous;

			return new KeyState<t>(previous.makeChainWithout(ks), ticks, value);</t>

		}

		public KeyState<t> change(bool press, T value, long ticks) {</t>

			if (value.CompareTo(none) == 0)

				return this;

			if (ticks <= this.ticks)

				ticks = this.ticks + 1;

			KeyState<t> p = find(value);</t>

			if (press) {

				if (p != null) return this;

				return new KeyState<t>(isEmpty ? null : this, ticks, value);</t>

			}

			if (p == null) return this;

			KeyState<t> chain = makeChainWithout(p);</t>

			return chain == null ? new KeyState<t>() : chain;</t>

		}

		public bool isEmpty

			{ get { return value.CompareTo(none) == 0 && (previous == null || previous.isEmpty); } }

		public bool isPressed(T value)

			{ return find(value) != null; }

		public KeyState<t> press(T value, long ticks)</t>

			{ return change(true, value, ticks); }

		public KeyState<t> release(T value, long ticks)</t>

			{ return change(false, value, ticks); }

	}

}