#ifndef STATECHANGE_HH

#define STATECHANGE_HH

#include "EmuTime.hh"

#include "TclObject.hh"

#include "dynarray.hh"

#include "serialize_meta.hh"

#include <variant>

#include <vector>

namespace openmsx {

/** Base class for all external MSX state changing events.

 * These are typically triggered by user input, like keyboard presses. The main

 * reason why these events exist is to be able to record and replay them.

 */

class StateChangeBase

{

public:

	[[nodiscard]] EmuTime getTime() const { return time; }

	template<typename Archive>

	void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.serialize("time", time);

	}

protected:

	StateChangeBase() = default; // for serialize

	explicit StateChangeBase(EmuTime time_)

		: time(time_) {}

private:

	EmuTime time = EmuTime::zero();

};

REGISTER_BASE_NAME_HELPER(StateChangeBase, "StateChange");

class EndLogEvent final : public StateChangeBase

{

public:

	EndLogEvent() = default; // for serialize

	explicit EndLogEvent(EmuTime time_)

		: StateChangeBase(time_) {}

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

	}

};

class KeyMatrixState final : public StateChangeBase

{

public:

	KeyMatrixState() = default; // for serialize

	KeyMatrixState(EmuTime time_, uint8_t row_, uint8_t press_, uint8_t release_)

		: StateChangeBase(time_)

		, row(row_), press(press_), release(release_)

	{

		// disallow useless events

		assert((press != 0) || (release != 0));

		// avoid confusion about what happens when some bits are both

		// set and reset (in other words: don't rely on order of and-

		// and or-operations)

		assert((press & release) == 0);

	}

	[[nodiscard]] auto getRow()     const { return row; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("row",     row,

		             "press",   press,

		             "release", release);

	}

private:

	uint8_t row, press, release;

};

class ArkanoidState final : public StateChangeBase

{

public:

	ArkanoidState() = default; // for serialize

	ArkanoidState(EmuTime time_, int delta_, bool press_, bool release_)

		: StateChangeBase(time_)

		, delta(delta_), press(press_), release(release_) {}

	[[nodiscard]] auto getDelta()   const { return delta; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("delta",   delta,

		             "press",   press,

		             "release", release);

	}

private:

	int delta;

	bool press, release;

};

/** This class is used to for Tcl commands that directly influence the MSX

  * state (e.g. plug, disk<x>, cassetteplayer, reset). It's passed via an

  * event because the recording needs to see these.

  */

class MSXCommandEvent final : public StateChangeBase

{

public:

	MSXCommandEvent() = default; // for serialize

	MSXCommandEvent(EmuTime time_, std::span<const TclObject> tokens_)

		: StateChangeBase(time_)

		, tokens(dynarray<TclObject>::construct_from_range_tag{}, tokens_)

	{

	}

	[[nodiscard]] const auto& getTokens() const { return tokens; }

	template<typename Archive>

	void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		// serialize vector<TclObject> as vector<string>

		std::vector<std::string> str;

		if constexpr (!Archive::IS_LOADER) {

			str = to_vector(std::views::transform(

				tokens, [](auto& t) { return std::string(t.getString()); }));

		}

		ar.serialize("tokens", str);

		if constexpr (Archive::IS_LOADER) {

			assert(tokens.empty());

			tokens = dynarray<TclObject>(dynarray<TclObject>::construct_from_range_tag{},

				std::views::transform(str, [](const auto& s) { return TclObject(s); }));

		}

	}

private:

	dynarray<TclObject> tokens;

};

class TrackballState final : public StateChangeBase

{

public:

	TrackballState() = default; // for serialize

	TrackballState(EmuTime time_, int deltaX_, int deltaY_,

	               uint8_t press_, uint8_t release_)

		: StateChangeBase(time_)

		, deltaX(deltaX_), deltaY(deltaY_)

		, press(press_), release(release_) {}

	[[nodiscard]] auto getDeltaX()  const { return deltaX; }

	[[nodiscard]] auto getDeltaY()  const { return deltaY; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("deltaX",  deltaX,

		             "deltaY",  deltaY,

		             "press",   press,

		             "release", release);

	}

private:

	int deltaX, deltaY;

	uint8_t press, release;

};

enum class AutofireID : uint8_t { RENSHATURBO, UNKNOWN };

inline std::string_view nameForId(AutofireID id)

{

	switch (id) {

		case AutofireID::RENSHATURBO: return "renshaturbo";

		default: return "unknown-autofire";

	}

}

class AutofireStateChange final : public StateChangeBase

{

public:

	AutofireStateChange() = default; // for serialize

	AutofireStateChange(EmuTime time_, AutofireID id_, int value_)

		: StateChangeBase(time_)

		, id(id_), value(value_) {}

	[[nodiscard]] auto getId()    const { return id; }

	[[nodiscard]] auto getValue() const { return value; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		// for backwards compatibility serialize 'id' as 'name'

		std::string name = Archive::IS_LOADER ? "" : std::string(nameForId(id));

		ar.serialize("name",  name,

		             "value", value);

		if constexpr (Archive::IS_LOADER) {

			using enum AutofireID;

			id = (name == nameForId(RENSHATURBO)) ? RENSHATURBO : UNKNOWN;

		}

	}

private:

	AutofireID id;

	int value;

};

class MSXJoyState final : public StateChangeBase

{

public:

	MSXJoyState() = default; // for serialize

	MSXJoyState(EmuTime time_, uint8_t id_,

	            uint8_t press_, uint8_t release_)

		: StateChangeBase(time_), id(id_)

		, press(press_), release(release_) {}

	[[nodiscard]] auto getId()      const { return id; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/) {

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("id",      id,

		             "press",   press,

		             "release", release);

	}

private:

	uint8_t id, press, release;

};

class JoyMegaState final : public StateChangeBase

{

public:

	JoyMegaState() = default; // for serialize

	JoyMegaState(EmuTime time_, uint8_t id_,

	             unsigned press_, unsigned release_)

		: StateChangeBase(time_)

		, press(press_), release(release_), id(id_) {}

	[[nodiscard]] auto getId()       const { return id; }

	[[nodiscard]] auto getPress()    const { return press; }

	[[nodiscard]] auto getRelease()  const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("id",      id,

		             "press",   press,

		             "release", release);

	}

private:

	unsigned press, release;

	uint8_t id;

};

class JoyHandleState final : public StateChangeBase

{

public:

	JoyHandleState() = default; // for serialize

	JoyHandleState(EmuTime time_, uint8_t id_,

	               uint8_t press_, uint8_t release_, float analog_)

		: StateChangeBase(time_), id(id_)

		, press(press_), release(release_), analog(analog_) {}

	[[nodiscard]] auto getId()      const { return id; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	[[nodiscard]] auto getAnalog()  const { return analog; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/) {

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("id",      id,

		             "press",   press,

		             "release", release,

		             "analog",  analog);

	}

private:

	uint8_t id, press, release;

	float analog;

};

class PaddleState final : public StateChangeBase

{

public:

	PaddleState() = default; // for serialize

	PaddleState(EmuTime time_, int delta_)

		: StateChangeBase(time_), delta(delta_) {}

	[[nodiscard]] auto getDelta() const { return delta; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("delta", delta);

	}

private:

	int delta;

};

class TouchpadState final : public StateChangeBase

{

public:

	TouchpadState() = default; // for serialize

	TouchpadState(EmuTime time_,

	              uint8_t x_, uint8_t y_, bool touch_, bool button_)

		: StateChangeBase(time_)

		, x(x_), y(y_), touch(touch_), button(button_) {}

	[[nodiscard]] auto getX()      const { return x; }

	[[nodiscard]] auto getY()      const { return y; }

	[[nodiscard]] auto getTouch()  const { return touch; }

	[[nodiscard]] auto getButton() const { return button; }

	template<typename Archive> void serialize(Archive& ar, unsigned /*version*/)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("x",      x,

		             "y",      y,

		             "touch",  touch,

		             "button", button);

	}

private:

	uint8_t x, y;

	bool touch, button;

};

class MouseState final : public StateChangeBase

{

public:

	MouseState() = default; // for serialize

	MouseState(EmuTime time_, int deltaX_, int deltaY_,

	           uint8_t press_, uint8_t release_)

		: StateChangeBase(time_)

		, deltaX(deltaX_), deltaY(deltaY_)

		, press(press_), release(release_) {}

	[[nodiscard]] auto getDeltaX()  const { return deltaX; }

	[[nodiscard]] auto getDeltaY()  const { return deltaY; }

	[[nodiscard]] auto getPress()   const { return press; }

	[[nodiscard]] auto getRelease() const { return release; }

	template<typename Archive> void serialize(Archive& ar, unsigned version)

	{

		ar.template serializeBase<StateChangeBase>(*this);

		ar.serialize("deltaX",  deltaX,

		             "deltaY",  deltaY,

		             "press",   press,

		             "release", release);

		if (ar.versionBelow(version, 2)) {

			assert(Archive::IS_LOADER);

			// Old versions stored host (=unscaled) mouse movement

			// in the replay-event-log. Apply the (old) algorithm

			// to scale host to msx mouse movement.

			// In principle the code snippet below does:

			//    delta{X,Y} /= SCALE

			// except that it doesn't accumulate rounding errors

			static constexpr int SCALE = 2;

			int oldMsxX = absHostX / SCALE;

			int oldMsxY = absHostY / SCALE;

			absHostX += deltaX;

			absHostY += deltaY;

			int newMsxX = absHostX / SCALE;

			int newMsxY = absHostY / SCALE;

			deltaX = newMsxX - oldMsxX;

			deltaY = newMsxY - oldMsxY;

		}

	}

private:

	int deltaX, deltaY; // msx mouse movement

	uint8_t press, release;

public:

	inline static int absHostX = 0, absHostY = 0; // (only) for old savestates

};

SERIALIZE_CLASS_VERSION(MouseState, 2);

using StateChange = std::variant<

	EndLogEvent,

	KeyMatrixState,

	ArkanoidState,

	MSXCommandEvent,

	TrackballState,

	AutofireStateChange,

	MSXJoyState,

	PaddleState,

	TouchpadState,

	MouseState,

	JoyMegaState,

	JoyHandleState

>;

inline auto getTime(const StateChange& event)

{

	return std::visit(

		[](const StateChangeBase& e) { return e.getTime(); },

		event);

}

template<> struct Serializer<StateChange> : VariantSerializer<StateChange> {

	static constexpr auto stateChangeInfo = std::to_array<enum_string<size_t>>({

		{"EndLog",              index<EndLogEvent>        },

		{"KeyMatrixState",      index<KeyMatrixState>     },

		{"ArkanoidState",       index<ArkanoidState>      },

		{"MSXCommandEvent",     index<MSXCommandEvent>    },

		{"TrackballState",      index<TrackballState>     },

		{"AutofireStateChange", index<AutofireStateChange>},

		{"MSXJoyState",         index<MSXJoyState>        },

		{"PaddleState",         index<PaddleState>        },

		{"TouchpadState",       index<TouchpadState>      },

		{"MouseState",          index<MouseState>         },

		{"JoyMegaState",        index<JoyMegaState>       },

		{"JoyHandleState",      index<JoyHandleState>     }

	});

	static constexpr std::span<const enum_string<size_t>> info() {

		return stateChangeInfo;

	}

};

} // namespace openmsx

#endif