#pragma once

#include "CoreMinimal.h"
#include "StringDecoder.h"
#include "Containers/Deque.h"

////////////////////////////////////////////////
//
// This is copied over from Luprex source.  Not ideal.
//
////////////////////////////////////////////////

enum EAnimValueType {
	T_STRING,
	T_NUMBER,
	T_BOOLEAN,
	T_XYZ,
	T_UNINITIALIZED
};

////////////////////////////////////////////////
//
// An single animation step.
// 
// The body consists of a sequence of FAnimField
// records.  The body is encoded, to read the
// FAnimField records you need an FAnimStepDecoder.
// This comes in two versions: the string version,
// and the string_view version.
//
////////////////////////////////////////////////

struct FAnimStep {
	uint32 Hash;
	std::string_view Body;

	FAnimStep() : Hash(0), Body("") {}
	FAnimStep(uint32 h, std::string_view b) : Hash(h), Body(b) {}
};

struct FAnimStoredStep {
	uint64 Hash;
	std::string Body;

	FAnimStoredStep() : Hash(0), Body("") {}
	FAnimStoredStep(uint32 h, std::string_view b) : Hash(h), Body(b) {}
};

////////////////////////////////////////////////
//
// A single animation field.
// 
// A field consists of a variable name,
// a persistent flag, a type, and some fields
// to hold the values.
//
// If the value is boolean, it is stored in
// X, as either 1 or 0.   If the value is double,
// it is stored in X.
// 
////////////////////////////////////////////////

struct FAnimField {
	std::string_view Name;
	bool Persistent;
	EAnimValueType Type;
	double X, Y, Z;
	std::string_view S;
};

////////////////////////////////////////////////
//
// An Animation Queue Decoder.
//
// This acts a lot like a stream reader,
// it reads one AnimEntry at a time from
// the animation queue until you reach
// 'end-of-file'.
//
////////////////////////////////////////////////

class FAnimQueueDecoder {
private:
	FStringDecoder Decoder;

public:
	// Initialize the FAnimQueueDecoder with the encoded animation queue.
	//
	FAnimQueueDecoder(std::string_view s) : Decoder(s) {}

	// Return true if the parser has reached the end of the string.
	//
	bool AtEOF() { return Decoder.at_eof(); }

	// Read one animation step.
	// 
	FAnimStep ReadStep();

	// Convert an AnimQueue to an FString.
	//
	static FString DebugString(std::string_view s);
};

////////////////////////////////////////////////
//
// An Animation Step Decoder.
//
// This acts a lot like a stream reader,
// it reads one FAnimField at a time from
// the animation queue until you reach
// 'end-of-file'.
//
////////////////////////////////////////////////

class FAnimStepDecoder {
private:
	FStringDecoder Decoder;

public:
	// Initialize the FAnimStepDecoder from the FAnimStep.
	// 
	FAnimStepDecoder(const FAnimStep &step) : Decoder(step.Body) {}
	FAnimStepDecoder(const FAnimStoredStep& step) : Decoder(step.Body) {}

	// Return true if the parser has reached the end of the string.
	//
	bool AtEOF() { return Decoder.at_eof(); }

	// Read one field.
	// 
	FAnimField ReadField();

	// Convert an AnimStep to an FString.
	//
	static FString DebugString(const FAnimStep &step);
};

////////////////////////////////////////////////
//
// FAnimTracker
//
// This class monitors the animation queue for a single
// tangible.  It can identify when a new animation has
// appeared on the animation queue, and when animations have
// been removed from the animation queue.  It also
// keeps track of which animations have been started.
// 
////////////////////////////////////////////////

class FAnimTracker {
public:
	// Our own copy of the animation queue.  We only
	// store the hashes, not the steps.  The First element
	// of the queue is the oldest item.
	//
	TDeque<FAnimStoredStep> AQ;

	// The sequence number of the first item in AQ.
	//
	int32 FirstSeqno;

	// Map from hash to sequence number.
	//
	TMap<uint64, int32> HashToSeqno;

	// The sequence number of the first unstarted animation.
	//
	int32 UnstartedSeqno;

	// Array of recently-aborted hash values.
	TArray<uint64> AbortedHashes;

public:
	// Construct a tracker.
	//
	// Initially, the tracker is in the empty (Clear) state.
	//
	FAnimTracker();

	// Update from the specified animation queue.
	//
	// After the update is done, AQ will be a copy
	// of the animation queue that is passed in.
	//
	void Update(std::string_view encqueue);

	// Fetch the aborted hash values.
	//
	// This gets the array of aborted hashes and clears
	// the stored array.
	//
	TArray<uint64> GetAborted();

	// Return true if there are any unstarted animation steps.
	//
	bool AnyUnstarted();

	// Get the next unstarted animation step.
	//
	// You may only call this if AnyUnstarted returns true.
	//
	FAnimStoredStep GetUnstarted();

	// Declare that an animation has been started.
	//
	// After starting an animation, you should call this.
	//
	void Started(uint64 Hash);
};