#region Gap Handling
/// <summary>
/// Gets the localized name of the gap
/// </summary>
/// <param name="gapName">the gap you want the name for</param>
/// <returns>the localized name of the gap (or null if invalid)</returns>
static public string GetLocalizedGapName(string gapName)
{
	if (string.IsNullOrEmpty(gapName)) { return null; }

	string locID = GapLocPrefix + gapName.ToLowerInvariant();

	string localizedName = LocalizationManager.GetTranslation(locID);
	if (string.IsNullOrEmpty(localizedName))
	{
		localizedName = gapName + " ::LOCALIZE:" + locID;
		Debug.Log("Gap loc missing, locID: " + locID);
	}

	return localizedName;
}

/// <summary>
/// Called when a gap gate is successfully passed through. Typically called by the gate itself.
/// </summary>
/// <param name="performingBoard">the board that went through the gate</param>
/// <param name="theGapGate">the gate they went through</param>
static public void GapGatePassed(ISkateboardGateway performingBoard, GapGateZone theGapGate)
{
	if (singleton == null) { return; }

	SkateboardGapTracker ourTracker = null;
	if (!singleton.completedGapLog.TryGetValue(performingBoard, out ourTracker))
	{
		ourTracker = new SkateboardGapTracker();

		singleton.completedGapLog.Add(performingBoard, ourTracker);
	}

	ourTracker.Log(theGapGate, performingBoard);
}

protected void EvaluateGaps()
{
	// We iterate over the gap logs first, because if we ever optimize this, the simplest to optimize is the defined gaps (with a Dictionary), whereas this will always be an in-order iteration
	foreach (KeyValuePair<ISkateboardGateway, SkateboardGapTracker> skateboardGaps in completedGapLog)
	{
		LinkedListNode<CompletedGapGate> tempNode = skateboardGaps.Value.gapGateLog.First;
		while (tempNode != null)
		{
			// Now, check this against the first entry in each defined gap gate sequence
			// @TODO: If anyone ever wants to optimize this, you'd do it by stuffing the sequences into a Lookup class keyed on their first gate, probably up in Awake(), buuuut I'm too lazy for that
			for (int index = 0; index < namedGaps.Length; index++)
			{
				GapGateSequence namedGap = namedGaps[index];
				if (namedGap.gates == null) { continue; } // (REALLY? fuck it, let's error check, but... REALLY?!)

				bool sequenceCompleted = CheckGap(tempNode, namedGap);
				if (!sequenceCompleted && namedGap.bothWays) { sequenceCompleted = CheckGap(tempNode, namedGap, reverseOrder: true); }

				// If we get this far and it's positive? YAY! We did a gap!
				if (sequenceCompleted)
				{
					skateboardGaps.Key.Combo.AddGap(namedGaps[index]);

					// Since we've just completed a gap, let's trigger a safety purge of this skateboard's logged gaps
					tempNode = null;
					break;
				}
			}

			if (tempNode != null) { tempNode = tempNode.Next; }
			else
			{
				// This means we found a valid gap, and should purge this skateboard's gap log to avoid repeat-detection
				skateboardGaps.Value.gapGateLog.Clear();

				// (and then we'll still be null on tempNode and thus drop nicely out of this on next loop)
			}
		}
	}
}

protected bool CheckGap(LinkedListNode<CompletedGapGate> loggedGateNode, GapGateSequence gapSequence, bool reverseOrder = false)
{
	// First, figure out which way we're evaluating this gap
	int gateSeqIndex = 0;
	int gateSeqStep = 1;

	if (reverseOrder)
	{
		gateSeqIndex = gapSequence.gates.Length - 1;
		gateSeqStep = -1;
	}

	// Then just step through the sequence
	float lastGateTime = -1f;
	float gateTimeAccum = 0f;
	float lastGroundedTime = -1f;
	float groundedTimeAccum = 0f;
	bool sequenceCompleted = true;
	LinkedListNode<CompletedGapGate> tempComparisonNode = loggedGateNode;
	while (gateSeqIndex < gapSequence.gates.Length && gateSeqIndex >= 0)
	{
		// If we run out of logged gap gates before we run out of gates in the sequence, I guess we haven't hit the gap yet
		if (tempComparisonNode == null)
		{
			sequenceCompleted = false;
			break;
		}

		// Step through our logged gates until we find one that matches the next in the gate sequence - or we run out of gates
		while (tempComparisonNode != null && tempComparisonNode.Value.theGapGate != gapSequence.gates[gateSeqIndex])
		{
			// When we start skipping nodes that don't match, it means we need to reset our sequence check to the first one in the sequence again
			gateSeqIndex = reverseOrder ? gapSequence.gates.Length - 1 : 0;
			gateTimeAccum = groundedTimeAccum = 0f;
			lastGateTime = lastGroundedTime = -1f;

			// (this lets us handle cases where gap detections overlap, and there's a totally unrelated gap gate in the space between the two gates that define the gap we're testing for)
			tempComparisonNode = tempComparisonNode.Next;

			// (the fall-through case here wraps around and catches the null check above and falses us out, easy peasy)
		}

		// Assuming we still have a node / we found a node...
		if (tempComparisonNode != null)
		{
			// Handle accumulation of properties between states
			if (lastGateTime >= 0f) { gateTimeAccum += Mathf.Max(tempComparisonNode.Value.timeGapCompleted - lastGateTime, 0f); }
			lastGateTime = tempComparisonNode.Value.timeGapCompleted;

			if (lastGroundedTime >= 0f) { groundedTimeAccum += Mathf.Max(tempComparisonNode.Value.groundedTime - lastGroundedTime, 0f); }
			lastGroundedTime = tempComparisonNode.Value.groundedTime;

			// Neeext
			tempComparisonNode = tempComparisonNode.Next;
		}
		gateSeqIndex += gateSeqStep;

		// If we go past one of our (assigned to something valid) limiters, that's it, the gap doesn't count anyways
		if (gapSequence.maxGrounded > 0f && groundedTimeAccum > gapSequence.maxGrounded)
		{
			sequenceCompleted = false;
			break;
		}

		if (gapSequence.timeLimit > 0f && groundedTimeAccum > gapSequence.timeLimit)
		{
			sequenceCompleted = false;
			break;
		}
	}

	return sequenceCompleted;
}

/// <summary>
/// Sweeps through the gap gate logs and removes entries too old to matter anymore
/// </summary>
protected void PruneGapGateLogs()
{
	foreach (KeyValuePair<ISkateboardGateway, SkateboardGapTracker> skateboardGaps in completedGapLog)
	{
		LinkedListNode<CompletedGapGate> headNode = skateboardGaps.Value.gapGateLog.First;
		while (headNode != null && Time.timeSinceLevelLoad - headNode.Value.timeGapCompleted >= GapCompletionTimeout)
		{
			skateboardGaps.Value.gapGateLog.RemoveFirst();
			headNode = skateboardGaps.Value.gapGateLog.First;
		}
	}
}

protected class SkateboardGapTracker
{
	public LinkedList<CompletedGapGate> gapGateLog = new LinkedList<CompletedGapGate>();

	public CompletedGapGate Log(GapGateZone theGapGate, ISkateboardGateway performingBoard)
	{
		CompletedGapGate newGapGate = null;

		// First, check the very last node. If it's for this gap gate (ie. a repeat trigger), we just update it
		LinkedListNode<CompletedGapGate> logNode = gapGateLog.Last;
		if (logNode != null && logNode.Value.theGapGate == theGapGate)
		{
			newGapGate = logNode.Value;
		}
		// Otherwise, we create a new one and add it to the end
		else
		{
			newGapGate = new CompletedGapGate();
			gapGateLog.AddLast(newGapGate);
		}

		// Either way, update/set the args, and we're done!
		newGapGate.theGapGate = theGapGate;
		newGapGate.timeGapCompleted = Time.timeSinceLevelLoad;
		newGapGate.groundedTime = performingBoard.Movement.TotalTimeGrounded;

		return newGapGate;
	}
}

protected class CompletedGapGate
{
	public GapGateZone theGapGate;
	public float timeGapCompleted = -1f;
	public float groundedTime = -1f;
}

[System.Serializable]
public class GapGateSequence
{
	public string gapName;
	public int score;
	public bool bothWays = true;
	public float timeLimit = -1f;
	public float maxGrounded = -1f;
	public GapGateZone[] gates;
}