#ifndef NOWINDHOST_HH
#define NOWINDHOST_HH

#include "DiskImageUtils.hh"
#include "circular_buffer.hh"

#include <array>
#include <cstdint>
#include <fstream>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <vector>

namespace openmsx {

class SectorAccessibleDisk;
class DiskContainer;

class NowindHost
{
public:
	using Drives = std::vector<std::unique_ptr<DiskContainer>>;

	explicit NowindHost(const Drives& drives);
	~NowindHost();

	// public for usb-host implementation
	[[nodiscard]] bool isDataAvailable() const;

	// read one byte of response-data from the host (msx <- pc)
	uint8_t read();

	// like read(), but without side effects (doesn't consume the data)
	[[nodiscard]] uint8_t peek() const;

	// Write one byte of command-data to the host   (msx -> pc)
	// Time parameter is in milliseconds. Emulators can pass emulation
	// time, USB-host can pass real time.
	void write(uint8_t data, unsigned time);

	void setAllowOtherDiskRoms(bool allow) { allowOtherDiskRoms = allow; }
	[[nodiscard]] bool getAllowOtherDiskRoms() const { return allowOtherDiskRoms; }

	void setEnablePhantomDrives(bool enable) { enablePhantomDrives = enable; }
	[[nodiscard]] bool getEnablePhantomDrives() const { return enablePhantomDrives; }

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

	// public for serialization
	enum class State : uint8_t {
		SYNC1,     // waiting for AF
		SYNC2,     // waiting for 05
		COMMAND,   // waiting for command (9 bytes)
		DISKREAD,  // waiting for AF07
		DISKWRITE, // waiting for AA<data>AA
		DEVOPEN,   // waiting for filename (11 bytes)
		IMAGE,     // waiting for filename
		MESSAGE,   // waiting for null-terminated message
	};

private:
	void msxReset();
	[[nodiscard]] SectorAccessibleDisk* getDisk() const;
	void executeCommand();

	void send(uint8_t value);
	void send16(uint16_t value);
	void sendHeader();
	void purge();

	void DRIVES();
	void DSKCHG();
	void CHOICE();
	void INIENV();
	void setDateMSX();

	[[nodiscard]] unsigned getSectorAmount() const;
	[[nodiscard]] unsigned getStartSector() const;
	[[nodiscard]] unsigned getStartAddress() const;
	[[nodiscard]] unsigned getCurrentAddress() const;

	void diskReadInit(SectorAccessibleDisk& disk);
	void doDiskRead1();
	void doDiskRead2();
	void transferSectors(unsigned transferAddress, unsigned amount);
	void transferSectorsBackwards(unsigned transferAddress, unsigned amount);

	void diskWriteInit(const SectorAccessibleDisk& disk);
	void doDiskWrite1();
	void doDiskWrite2();

	[[nodiscard]] uint16_t getFCB() const;
	[[nodiscard]] std::string extractName(int begin, int end) const;
	unsigned readHelper1(unsigned dev, std::span<char, 256> buffer);
	void readHelper2(std::span<const char> buffer);
	[[nodiscard]] int getDeviceNum() const;
	int getFreeDeviceNum();
	void deviceOpen();
	void deviceClose();
	void deviceWrite();
	void deviceRead();

	void callImage(const std::string& filename);

private:
	static constexpr unsigned MAX_DEVICES = 16;

	const Drives& drives;

	cb_queue<uint8_t> hostToMsxFifo;

	struct Device {
		std::optional<std::fstream> fs; // not in use when fs == nullopt
		uint16_t fcb;
	};
	std::array<Device, MAX_DEVICES> devices;

	// state-machine
	std::vector<SectorBuffer> buffer;// work buffer for disk read/write
	unsigned lastTime = 0;   // last time a byte was received from MSX
	State state = State::SYNC1;
	unsigned recvCount;      // how many bytes recv in this state
	unsigned transferred;    // progress within disk read/write
	unsigned retryCount;     // only used for disk read
	unsigned transferSize;   // size of current chunk
	std::array<uint8_t, 9> cmdData; // reg_[cbedlhfa] + cmd
	std::array<uint8_t, 240 + 2> extraData; // extra data for disk read/write

	uint8_t romDisk = 255;      // index of rom disk (255 = no rom disk)
	bool allowOtherDiskRoms = false;
	bool enablePhantomDrives = true;
};

} // namespace openmsx

#endif // NOWINDHOST_HH