#include "clock.hpp"

#include "uart/uart.hpp"

constexpr auto READ_FLASH_CMD = 'f';
constexpr auto WRITE_FLASH_CMD = 'F';
constexpr auto READ_EEPROM_CMD = 'e';
constexpr auto WRITE_EEPROM_CMD = 'E';
constexpr auto READ_USERDATA_CMD = 'c';
constexpr auto WRITE_USERDATA_CMD = 'C';
constexpr auto REQUEST_CMD = '?';
constexpr auto CONFIRM_CMD = '!';
constexpr auto AUTO_BAUDING_CMD = '@';

using uart_interface = uart::Hardware0<uart::Config<115200>, uart::Driven::BLOCKING>;

enum class State {
	WAITING,
	ACTIVE,
};

struct DeviceInfo {
	char name[3] = {'T', 'S', 'B'};
	uint8_t date[2] = {0x1a, 0x1f};
	uint8_t status = 0xf0;
	uint8_t signature[3] = {0x1e, 0x95, 0x0f};
	uint8_t pageSize = 0x40;
	uint16_t flashSize = 0x3ec0;
	uint16_t eepromSize = 0x03ff;
};

struct UserData {
	uint16_t jumpAddress = 0xAAAA;
	uint8_t timeout = 0x21;
};

static inline void sendDeviceInfo()
{
	uart::Uart<uart_interface> serial;

	constexpr DeviceInfo deviceInfo;
	constexpr UserData userData;

	for (uint8_t i = 0; i < sizeof(deviceInfo); ++i) {
		serial.txByte(*(reinterpret_cast<const uint8_t *>(&deviceInfo) + i));
	}

	for (uint8_t i = 0; i < sizeof(userData); ++i) {
		serial.txByte(*(reinterpret_cast<const uint8_t *>(&userData) + i));
	}
}

static uint8_t g_lastPage[128] = {};

static inline void sendUserData()
{
	uart::Uart<uart_interface> serial;

	for (uint8_t i = 0; i < sizeof(g_lastPage); ++i) {
		serial.txByte(*(reinterpret_cast<const uint8_t *>(&g_lastPage) + i));
	}
}

static inline void sendConfirm()
{
	uart::Uart<uart_interface> serial;
	serial.txByte(CONFIRM_CMD);
}

int main()
{
	uart::Uart<uart_interface> serial;
	serial.init();

	State state = State::WAITING;

	uint8_t receivedByte = 0;
	uint8_t autoBaudingCounter = 0;

	while (true) {
		if (serial.rxByte(receivedByte)) {
			if (state == State::WAITING) {
				if (receivedByte == AUTO_BAUDING_CMD) {
					++autoBaudingCounter;
				}
				if (autoBaudingCounter == 3) {
					autoBaudingCounter = 0;
					state = State::ACTIVE;
					sendDeviceInfo();
				}
			} else if (state == State::ACTIVE) {
				if (receivedByte == READ_USERDATA_CMD) {
					sendUserData();
					sendConfirm();
					state = State::WAITING;
				}
			}
		}
	}

	return 0;
}