using System;

namespace Assistance {

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

		public struct Holder {

			public KeyState<T> state;

			public long ticks;

			public double timeOffset;

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

				this.state = state;

				this.ticks = ticks;

				this.timeOffset = timeOffset;

			}

			public KeyState<T> find(T value)

				{ 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) {

				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>();

		public readonly KeyState<T> previous;

		public readonly long ticks;

		public readonly T value;

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

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

			this.previous = previous;

			this.ticks = ticks;

			this.value = value;

		}

		public KeyState<T> find(T value) {

			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) {

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

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

		}

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

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

				return this;

			if (ticks <= this.ticks)

				ticks = this.ticks + 1;

			KeyState<T> p = find(value);

			if (press) {

				if (p != null) return this;

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

			}

			if (p == null) return this;

			KeyState<T> chain = makeChainWithout(p);

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

		}

		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)

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

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

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

	}

}