#ifndef RAWTRACK_HH
#define RAWTRACK_HH

#include "narrow.hh"
#include "serialize_meta.hh"
#include <cstdint>
#include <optional>
#include <span>
#include <vector>

namespace openmsx {

class CRC16;

// This class represents a raw disk track. It contains the logical sector
// content, but also address blocks, CRC checksums, sync blocks and the data
// in the gaps between these blocks.
//
// The internal representation is based on the DMK disk image file format. See:
//    http://www.trs-80.com/wordpress/dsk-and-dmk-image-utilities/
//    (at the bottom of the page)
//
// Besides the raw track data, this format also stores the positions of the
// 'address marks' in the track (this roughly corresponds with the start of a
// sector). Of course a real disk doesn't have such a list. In a real disk this
// information is stored as 'MFM encodings with missing clock transitions'.
//
// Normal MFM encoding goes like this: An input bit of '0' is encoded as 'x0'
// with x the inverse of the previously encoded bit. A '1' input bit is encoded
// as '01'. (More in detail: a '1' encoded bit indicates a magnetic flux
// transition, a '0' bit is no flux transition). So for example the input byte
// 0xA1 (binary 10100001) is MFM encoded as '01 00 01 00 10 10 10 01'. (Note
// that decoding is simply taking every 2nd bit (the data bits), the other bits
// (the clock bits) ensure that between encoded '1' bits is always at least 1
// and at most 3 zero bits. So no too dense flux transitions and not too far
// apart to keep the stream synchronized).
//
// Now for the missing clock transitions: besides the encodings for the 256
// possible input bytes, the FDC can write two other encodings, namely:
//   01 00 01 00 10 00 10 01  (0xA1 with missing clock between bit 4 and 5)
//   01 01 00 10 00 10 01 00  (0xC2 with missing clock between bit 3 and 4)
//
// So in principle we should store each of these special 0xA1 or 0xC2 bytes.
// Instead we only store the locations of '0xA1 0xA1 0xA1 0xFE' sequences (the
// 0xA1 bytes have missing clocks, this sequence indicates the start of an
// address mark). So we don't store the location of the special 0xC2 bytes, nor
// the location of each special 0xA1 byte. These certainly do occur on a real
// disk track, but the WD2793 controller only reacts to the full sequence
// above, so for us this is good enough. (The FDC also uses these special
// encodings to re-synchronize itself with the input stream, e.g. figure out
// which bit is the start bit in a byte, but from a functional emulation point
// of view we can ignore this).
//
// Also note that it's possible to create real disks that have still completely
// different magnetic flux patterns than the 256+2 possible MFM patterns
// described above. Such disks cannot be described by this class. But for
// openMSX that's not a problem because the WD2793 or TC8566AF disk controllers
// anyway can't handle such disks (they would always interpret the flux pattern
// as one of the 256+2 MFM patterns). Other systems (like Amiga) have disk
// controllers that allow more direct access to the disk and could for example
// encode the data in a more efficient way than MFM (e.g. GCR6). That's why
// Amiga can fit more data on the same disk (even more than simply storing 10
// or 11 sectors on a track by making the gaps between the sectors smaller).

class RawTrack {
public:
	// Typical track length is 6250 bytes:
	//    250kbps, 300rpm -> 6250 bytes per rotation.
	// The IBM Disk Format Specification confirms this number.
	// Of course this is in ideal circumstances: in reality the rotation
	// speed can vary and thus the disk can be formatted with slightly more
	// or slightly less raw bytes per track. This class can also represent
	// tracks of different lengths.
	static constexpr unsigned STANDARD_SIZE = 6250;

	struct Sector
	{
		// note: initialize to avoid UMR on savestate
		int addrIdx = 0;
		int dataIdx = 0;
		uint8_t track = 0;
		uint8_t head = 0;
		uint8_t sector = 0;
		uint8_t sizeCode = 0;
		bool deleted = false;
		bool addrCrcErr = false;
		bool dataCrcErr = false;

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

	/* Construct a (cleared) track. */
	explicit RawTrack(unsigned size = STANDARD_SIZE);

	/** Clear track data. Also sets the track length. */
	void clear(unsigned size);

	/** Get track length. */
	[[nodiscard]] unsigned getLength() const { return unsigned(data.size()); }

	void addIdam(unsigned idx);

	// In the methods below, 'index' is allowed to be 'out-of-bounds',
	// it will wrap like in a circular buffer.

	[[nodiscard]] uint8_t read(int idx) const { return data[wrapIndex(idx)]; }
	void write(int idx, uint8_t val, bool setIdam = false);
	[[nodiscard]] int wrapIndex(int idx) const {
		// operator% is not a modulo but a remainder operation (makes a
		// difference for negative inputs). Hence the extra test.
		int size = narrow<int>(data.size());
		int tmp = idx % size;
		return (tmp >= 0) ? tmp : (tmp + size);
	}

	[[nodiscard]] std::span<      uint8_t> getRawBuffer()       { return data; }
	[[nodiscard]] std::span<const uint8_t> getRawBuffer() const { return data; }
	[[nodiscard]] const auto& getIdamBuffer() const { return idam; }

	/** Get info on all sectors in this track. */
	[[nodiscard]] std::vector<Sector> decodeAll() const;

	/** Get the next sector (starting from a certain index). */
	[[nodiscard]] std::optional<Sector> decodeNextSector(unsigned startIdx) const;

	/** Get a sector with a specific number.
	  * Note that if a sector with the same number occurs multiple times,
	  * this method will always return the same (the first) sector. So
	  * don't use it in the implementation of FDC / DiskDrive code.
	  */
	[[nodiscard]] std::optional<Sector> decodeSector(uint8_t sectorNum) const;

	/** Like memcpy() but copy from/to circular buffer. */
	void readBlock (int idx, std::span<uint8_t> destination) const;
	void writeBlock(int idx, std::span<const uint8_t> source);

	/** Convenience method to calculate CRC for part of this track. */
	[[nodiscard]] uint16_t calcCrc(int idx, int size) const;
	void updateCrc(CRC16& crc, int idx, int size) const;

	void applyWd2793ReadTrackQuirk();

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

private:
	[[nodiscard]] std::optional<Sector> decodeSectorImpl(int idx) const;

private:
	// Index into 'data'-array to positions where an address mark
	// starts (it points to the 'FE' byte in the 'A1 A1 A1 FE ..'
	// sequence.
	std::vector<unsigned> idam;

	// MFM-decoded raw data, this does NOT include the missing clock
	// transitions that can occur in the encodings of the 'A1' and
	// 'C2' bytes.
	std::vector<uint8_t> data;
};
SERIALIZE_CLASS_VERSION(RawTrack, 2);

} // namespace openmsx

#endif