/**

 * RGB assembler

 * Copyright © 2017 František Kučera (frantovo.cz)

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#pragma once

#include "types.h"

const address_t MEMORY_SIZE = 1024;

class Memory {

private:

	template<typename T> T logMemoryError(const address_t &index) {

		wprintf(L"memory error: index = %d, sizeof(T) = %d, MEMORY_SIZE = %d\n", index, sizeof (T), MEMORY_SIZE);

		// TODO: return error value or throw exception

		return T();

	}

	octet_t * memory;

	address_t index;

public:

	Memory() {

		memory = (octet_t*) malloc(MEMORY_SIZE);

		index = 0;

	}

	virtual ~Memory() {

		free(memory);

		memory = nullptr;

	}

	/**

	 * Reads data on current position in memory and increments the index (position).

	 * @return value found at current position

	 */

	template<typename T> T read() {

		// TODO: map higher memory to static hardcoded areas or peripherals

		if (index + sizeof (T) <= MEMORY_SIZE) {

			T * value = reinterpret_cast<T*> (memory + index);

			index += sizeof (T);

			return *value;

		} else {

			return logMemoryError<T>(index);

		}

	}

	/**

	 * Reads data on given position in memory (without affecting the current position).

	 * @return value found at given position

	 */

	template<typename T> T read(const address_t &address) {

		// TODO: map higher memory to static hardcoded areas or peripherals

		if (address + sizeof (T) <= MEMORY_SIZE) {

			return *(reinterpret_cast<T*> (memory + address));

		} else {

			return logMemoryError<T>(address);

		}

	}

	/**

	 * Writes data to current position in memory and increments the index (position).

	 * @param value value to be written at current position

	 */

	template<typename T> T write(const T value) {

		if (index + sizeof (T) <= MEMORY_SIZE) {

			T * m = reinterpret_cast<T*> (memory + index);

			*m = value;

			index += sizeof (value);

		} else {

			return logMemoryError<T>(index);

		}

	}

	/**

	 * Writes data to given position in memory (without affecting the current position).

	 * @param value value to be written at given position

	 */

	template<typename T> T write(const address_t &address, const T value) {

		if (address + sizeof (T) <= MEMORY_SIZE) {

			T * m = reinterpret_cast<T*> (memory + address);

			*m = value;

		} else {

			return logMemoryError<T>(address);

		}

	}

	/**

	 * Set current addres to given position.

	 * @param index

	 */

	void setAddress(address_t &index) {

		this->index = index;

	}

	/**

	 * @return Current position in the memory.

	 */

	address_t getAddress() {

		return index;

	}

	/**

	 * @return whether the current position is inside the memory boundaries = still processing.

	 */

	bool isNotOver() {

		return index < MEMORY_SIZE;

	}

	/**

	 * Set current position to the start of the memory = position 0.

	 */

	void setAddressToBeginning() {

		index = 0;

	}

	/**

	 * Set current position behind the end of the memory = stop processing.

	 */

	void setAddressToEnd() {

		index = MEMORY_SIZE;

	}

};